Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Parse_2Parser_8h_source.html below:

clang: include/clang/Parse/Parser.h Source File

BalancedDelimiterTracker;

CorrectionCandidateCallback;

DiagnosticBuilder;

ParsingDeclRAIIObject;

ParsingDeclSpec;

ParsingDeclarator;

ParsingFieldDeclarator;

ColonProtectionRAIIObject;

InMessageExpressionRAIIObject;

PoisonSEHIdentifiersRAIIObject;

ObjCTypeParamList;

OMPTraitProperty;

OMPTraitSelector;

ParenCount = 0, BracketCount = 0, BraceCount = 0;

MisplacedModuleBeginCount = 0;

{ ScopeCacheSize = 16 };

NumCachedScopes;

*ScopeCache[ScopeCacheSize];

*Ident___exception_code,

*Ident_GetExceptionCode;

*Ident___exception_info,

*Ident_GetExceptionInfo;

*Ident___abnormal_termination,

*Ident_AbnormalTermination;

*Ident_generated_declaration, *Ident_USR;

llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;

std::unique_ptr<PragmaHandler> AlignHandler;

std::unique_ptr<PragmaHandler> GCCVisibilityHandler;

std::unique_ptr<PragmaHandler> OptionsHandler;

std::unique_ptr<PragmaHandler> PackHandler;

std::unique_ptr<PragmaHandler> MSStructHandler;

std::unique_ptr<PragmaHandler> UnusedHandler;

std::unique_ptr<PragmaHandler> WeakHandler;

std::unique_ptr<PragmaHandler> RedefineExtnameHandler;

std::unique_ptr<PragmaHandler> FPContractHandler;

std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;

std::unique_ptr<PragmaHandler> OpenMPHandler;

std::unique_ptr<PragmaHandler> OpenACCHandler;

std::unique_ptr<PragmaHandler> PCSectionHandler;

std::unique_ptr<PragmaHandler> MSCommentHandler;

std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;

std::unique_ptr<PragmaHandler> FPEvalMethodHandler;

std::unique_ptr<PragmaHandler> FloatControlHandler;

std::unique_ptr<PragmaHandler> MSPointersToMembers;

std::unique_ptr<PragmaHandler> MSVtorDisp;

std::unique_ptr<PragmaHandler> MSInitSeg;

std::unique_ptr<PragmaHandler> MSDataSeg;

std::unique_ptr<PragmaHandler> MSBSSSeg;

std::unique_ptr<PragmaHandler> MSConstSeg;

std::unique_ptr<PragmaHandler> MSCodeSeg;

std::unique_ptr<PragmaHandler> MSSection;

std::unique_ptr<PragmaHandler> MSStrictGuardStackCheck;

std::unique_ptr<PragmaHandler> MSRuntimeChecks;

std::unique_ptr<PragmaHandler> MSIntrinsic;

std::unique_ptr<PragmaHandler> MSFunction;

std::unique_ptr<PragmaHandler> MSOptimize;

std::unique_ptr<PragmaHandler> MSFenvAccess;

std::unique_ptr<PragmaHandler> MSAllocText;

std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;

std::unique_ptr<PragmaHandler> OptimizeHandler;

std::unique_ptr<PragmaHandler> LoopHintHandler;

std::unique_ptr<PragmaHandler> UnrollHintHandler;

std::unique_ptr<PragmaHandler> NoUnrollHintHandler;

std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;

std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;

std::unique_ptr<PragmaHandler> FPHandler;

std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;

std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;

std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;

std::unique_ptr<PragmaHandler> STDCUnknownHandler;

std::unique_ptr<PragmaHandler> AttributePragmaHandler;

std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;

std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;

std::unique_ptr<PragmaHandler> RISCVPragmaHandler;

std::unique_ptr<CommentHandler> CommentSemaHandler;

GreaterThanIsOperator;

OpenMPDirectiveParsing =

;

OpenACCDirectiveParsing =

;

AllowOpenACCArraySections =

;

OpenACCArraySectionRAII {

OpenACCArraySectionRAII(

&P) :

(

) {

assert(!

.AllowOpenACCArraySections);

.AllowOpenACCArraySections =

;

~OpenACCArraySectionRAII() {

assert(

.AllowOpenACCArraySections);

.AllowOpenACCArraySections =

;

InMessageExpression;

CalledSignatureHelp =

;

TemplateParameterDepth;

TemplateParameterDepthRAII {

AddedLevels;

TemplateParameterDepthRAII(

&Depth)

: Depth(Depth), AddedLevels(0) {}

~TemplateParameterDepthRAII() {

Depth -= AddedLevels;

addDepth(

) {

setAddedDepth(

) {

Depth = Depth - AddedLevels +

;

getDepth()

{

Depth; }

getOriginalDepth()

{

Depth - AddedLevels; }

AttributeFactory AttrFactory;

SmallVector<TemplateIdAnnotation *, 16> TemplateIds;

DelayTemplateIdDestruction =

;

MaybeDestroyTemplateIds() {

(DelayTemplateIdDestruction)

(!TemplateIds.empty() &&

DestroyTemplateIds();

DestroyTemplateIds();

DestroyTemplateIdAnnotationsRAIIObj {

DestroyTemplateIdAnnotationsRAIIObj(Parser &Self) : Self(Self) {}

~DestroyTemplateIdAnnotationsRAIIObj() { Self.MaybeDestroyTemplateIds(); }

DelayTemplateIdDestructionRAII {

PrevDelayTemplateIdDestruction;

DelayTemplateIdDestructionRAII(Parser &Self,

DelayTemplateIdDestruction) noexcept

PrevDelayTemplateIdDestruction(Self.DelayTemplateIdDestruction) {

Self.DelayTemplateIdDestruction = DelayTemplateIdDestruction;

~DelayTemplateIdDestructionRAII() noexcept {

Self.DelayTemplateIdDestruction = PrevDelayTemplateIdDestruction;

SmallVector<const IdentifierInfo *, 8> TentativelyDeclaredIdentifiers;

AngleBracketTracker {

SpaceBeforeLess = 0x0,

NoSpaceBeforeLess = 0x1,

(!Locs.empty() && Locs.back().isActive(

)) {

(Locs.back().Priority <= Prio) {

Locs.back().LessLoc = LessLoc;

Locs.back().Priority = Prio;

Locs.push_back({TemplateName, LessLoc, Prio,

.ParenCount,

.BracketCount,

.BraceCount});

clear(Parser &

) {

(!Locs.empty() && Locs.back().isActiveOrNested(

))

*getCurrent(Parser &

) {

(!Locs.empty() && Locs.back().isActive(

))

AngleBracketTracker AngleBrackets;

IdentifierInfo *getSEHExceptKeyword();

ParsingInObjCContainer;

SkipFunctionBodies;

SourceLocation ExprStatementTokLoc;

ParsedStmtContext {

AllowDeclarationsInC = 0x1,

AllowStandaloneOpenMPDirectives = 0x2,

Compound = AllowDeclarationsInC | AllowStandaloneOpenMPDirectives,

(Preprocessor &PP, Sema &Actions,

SkipFunctionBodies);

assert(!isTokenSpecial() &&

);

PrevTokLocation;

assert(!isTokenSpecial() &&

);

= PrevTokLocation;

ConsumeParen();

(isTokenBracket())

ConsumeBracket();

ConsumeBrace();

(isTokenStringLiteral())

ConsumeStringToken();

(Tok.

(tok::code_completion))

ConsumeCodeCompletionTok ? ConsumeCodeCompletionToken()

: handleUnexpectedCodeCompletionToken();

ConsumeAnnotationToken();

isTokenParen()

{

Tok.

(tok::l_paren, tok::r_paren);

isTokenBracket()

{

Tok.

(tok::l_square, tok::r_square);

isTokenBrace()

{

Tok.

(tok::l_brace, tok::r_brace);

isTokenStringLiteral()

{

isTokenSpecial()

{

isTokenStringLiteral() || isTokenParen() || isTokenBracket() ||

isTokenBrace() || Tok.

(tok::code_completion) || Tok.

();

isTokenEqualOrEqualTypo();

UnconsumeToken(Token &Consumed) {

SourceLocation ConsumeAnnotationToken() {

assert(Tok.

() &&

);

SourceLocation ConsumeParen() {

assert(isTokenParen() &&

);

(Tok.

() == tok::l_paren)

(ParenCount) {

AngleBrackets.clear(*

);

PrevTokLocation;

SourceLocation ConsumeBracket() {

assert(isTokenBracket() &&

);

(Tok.

() == tok::l_square)

(BracketCount) {

AngleBrackets.clear(*

);

PrevTokLocation;

SourceLocation ConsumeBrace() {

assert(isTokenBrace() &&

);

(Tok.

() == tok::l_brace)

(BraceCount) {

AngleBrackets.clear(*

);

PrevTokLocation;

SourceLocation ConsumeStringToken() {

assert(isTokenStringLiteral() &&

);

PrevTokLocation;

SourceLocation ConsumeCodeCompletionToken() {

assert(Tok.

(tok::code_completion));

PrevTokLocation;

SourceLocation handleUnexpectedCodeCompletionToken();

cutOffParsing() {

== tok::eof ||

== tok::annot_module_begin ||

== tok::annot_module_end ||

== tok::annot_module_include ||

== tok::annot_repl_input_end;

initializePragmaHandlers();

resetPragmaHandlers();

HandlePragmaUnused();

HandlePragmaVisibility();

HandlePragmaPack();

HandlePragmaMSStruct();

HandlePragmaMSPointersToMembers();

HandlePragmaMSVtorDisp();

HandlePragmaMSPragma();

HandlePragmaMSSection(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSSegment(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSInitSeg(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSStrictGuardStackCheck(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSFunction(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSAllocText(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaMSOptimize(StringRef PragmaName,

SourceLocation PragmaLocation);

HandlePragmaAlign();

HandlePragmaDump();

HandlePragmaWeak();

HandlePragmaWeakAlias();

HandlePragmaRedefineExtname();

HandlePragmaFPContract();

HandlePragmaFEnvAccess();

HandlePragmaFEnvRound();

HandlePragmaCXLimitedRange();

HandlePragmaFloatControl();

HandlePragmaFP();

HandlePragmaOpenCLExtension();

HandlePragmaLoopHint(LoopHint &Hint);

ParsePragmaAttributeSubjectMatchRuleSet(

SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc);

HandlePragmaAttribute();

Token &GetLookAheadToken(

N) {

(N == 0 || Tok.

(tok::eof))

Tok;

assert((

.isInvalid() ||

.get()) &&

);

NamedDecl *getNonTypeAnnotation(

Token &Tok) {

NamedDecl*

(Tok.getAnnotationValue());

setNonTypeAnnotation(Token &Tok, NamedDecl *ND) {

Tok.setAnnotationValue(ND);

IdentifierInfo *getIdentifierAnnotation(

Token &Tok) {

IdentifierInfo*

(Tok.getAnnotationValue());

setIdentifierAnnotation(Token &Tok, IdentifierInfo *ND) {

Tok.setAnnotationValue(ND);

getExprAnnotation(

Token &Tok) {

ExprResult::getFromOpaquePointer(Tok.getAnnotationValue());

setExprAnnotation(Token &Tok,

ER) {

Tok.setAnnotationValue(ER.getAsOpaquePointer());

CXXScopeSpec &SS,

IsNewScope,

(Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||

(Tok.is(tok::annot_template_id) &&

Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super));

AnnotatedNameKind {

TryAnnotateName(CorrectionCandidateCallback *CCC =

,

AnnotateScopeToken(CXXScopeSpec &SS,

IsNewAnnotation);

TryAltiVecToken(DeclSpec &DS, SourceLocation

,

*&PrevSpec,

&DiagID,

(Tok.getIdentifierInfo() != Ident_vector &&

Tok.getIdentifierInfo() != Ident_bool &&

Tok.getIdentifierInfo() != Ident_Bool &&

(!

().AltiVec || Tok.getIdentifierInfo() != Ident_pixel))

TryAltiVecTokenOutOfLine(DS,

, PrevSpec, DiagID,

);

TryAltiVecVectorToken() {

Tok.getIdentifierInfo() != Ident_vector)

;

TryAltiVecVectorTokenOutOfLine();

TryAltiVecVectorTokenOutOfLine();

TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation

,

*&PrevSpec,

&DiagID,

isObjCInstancetype() {

(Tok.isAnnotation())

(!Ident_instancetype)

Tok.getIdentifierInfo() == Ident_instancetype;

TryKeywordIdentFallback(

DisableKeyword);

TemplateIdAnnotation *takeTemplateIdAnnotation(

Token &tok);

TentativeParsingAction {

PreferredTypeBuilder PrevPreferredType;

PrevTentativelyDeclaredIdentifierCount;

PrevParenCount, PrevBracketCount, PrevBraceCount;

TentativeParsingAction(Parser &p,

Unannotated =

)

:

(p), PrevPreferredType(

.PreferredType) {

PrevTentativelyDeclaredIdentifierCount =

.TentativelyDeclaredIdentifiers.size();

PrevParenCount =

.ParenCount;

PrevBracketCount =

.BracketCount;

PrevBraceCount =

.BraceCount;

.PP.EnableBacktrackAtThisPos(Unannotated);

assert(isActive &&

);

.TentativelyDeclaredIdentifiers.resize(

PrevTentativelyDeclaredIdentifierCount);

.PP.CommitBacktrackedTokens();

assert(isActive &&

);

.PreferredType = PrevPreferredType;

.TentativelyDeclaredIdentifiers.resize(

PrevTentativelyDeclaredIdentifierCount);

.ParenCount = PrevParenCount;

.BracketCount = PrevBracketCount;

.BraceCount = PrevBraceCount;

~TentativeParsingAction() {

assert(!isActive &&

);

RevertingTentativeParsingAction

:

Parser::TentativeParsingAction {

TentativeParsingAction::TentativeParsingAction;

~RevertingTentativeParsingAction() { Revert(); }

ObjCContainerDecl *DC;

SaveAndRestore<bool> WithinObjCContainer;

ObjCDeclContextSwitch(Parser &p)

WithinObjCContainer(

.ParsingInObjCContainer, DC != nullptr) {

.Actions.ObjC().ActOnObjCTemporaryExitContainerContext(DC);

~ObjCDeclContextSwitch() {

.Actions.ObjC().ActOnObjCReenterContainerContext(DC);

= diag::err_expected,

StringRef DiagMsg =

);

ExpectAndConsumeSemi(

DiagID , StringRef TokenUsed =

);

ExtraSemiKind {

OutsideFunction = 0,

InstanceVariableList = 2,

AfterMemberFunctionDefinition = 3

expectIdentifier();

CompoundToken {

checkCompoundToken(SourceLocation FirstTokLoc,

diagnoseUseOfC11Keyword(

Token &Tok);

operator=(

&) =

;

BeforeCompoundStmt =

)

(EnteredScope && !BeforeCompoundStmt)

Self->EnterScope(ScopeFlags);

(BeforeCompoundStmt)

Self->incrementMSManglingNumber();

this->Self =

;

NumScopes = 0;

Self.EnterScope(ScopeFlags);

ParseScopeFlags {

OldFlags = 0;

ParseScopeFlags(

ParseScopeFlags &) =

;

operator=(

ParseScopeFlags &) =

;

ParseScopeFlags(

*

,

ScopeFlags,

ManageFlags =

);

DiagnosticBuilder

(SourceLocation

,

DiagID);

DiagnosticBuilder

(

Token &Tok,

DiagID);

(Tok, DiagID);

(R));

ParsingClass;

LateParsedDeclaration {

~LateParsedDeclaration();

ParseLexedMethodDeclarations();

ParseLexedMemberInitializers();

ParseLexedMethodDefs();

ParseLexedAttributes();

ParseLexedPragmas();

LateParsedClass :

LateParsedDeclaration {

LateParsedClass(

*

, ParsingClass *

);

~LateParsedClass()

;

ParseLexedMethodDeclarations()

;

ParseLexedMemberInitializers()

;

ParseLexedMethodDefs()

;

ParseLexedAttributes()

;

ParseLexedPragmas()

;

LateParsedClass(

LateParsedClass &) =

;

LateParsedClass &operator=(

LateParsedClass &) =

;

ParsingClass *

;

LateParsedAttribute :

LateParsedDeclaration {

IdentifierInfo &AttrName;

IdentifierInfo *MacroII =

;

SourceLocation AttrNameLoc;

SmallVector<Decl*, 2> Decls;

LateParsedAttribute(Parser *

, IdentifierInfo &Name,

SourceLocation

)

: Self(

), AttrName(Name), AttrNameLoc(

) {}

ParseLexedAttributes()

;

addDecl(Decl *

) { Decls.push_back(

); }

LateParsedPragma :

LateParsedDeclaration {

Parser *Self =

;

: Self(

), AS(AS) {}

takeToks(

&Cached) { Toks.swap(Cached); }

ParseLexedPragmas()

;

LateParsedAttrList:

SmallVector<LateParsedAttribute *, 2> {

LateParsedAttrList(

PSoon =

,

LateAttrParseExperimentalExtOnly =

)

LateAttrParseExperimentalExtOnly(LateAttrParseExperimentalExtOnly) {}

parseSoon() {

ParseSoon; }

lateAttrParseExperimentalExtOnly() {

LateAttrParseExperimentalExtOnly;

LateAttrParseExperimentalExtOnly;

LexedMethod :

LateParsedDeclaration {

LexedMethod(Parser *

, Decl *MD) : Self(

),

(MD) {}

ParseLexedMethodDefs()

;

LateParsedDefaultArgument {

LateParsedDefaultArgument(Decl *

,

std::unique_ptr<CachedTokens> Toks =

)

: Param(

), Toks(

::move(Toks)) { }

std::unique_ptr<CachedTokens> Toks;

LateParsedMethodDeclaration :

LateParsedDeclaration {

LateParsedMethodDeclaration(Parser *

, Decl *M)

: Self(

), Method(M), ExceptionSpecTokens(nullptr) {}

ParseLexedMethodDeclarations()

;

SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;

LateParsedMemberInitializer :

LateParsedDeclaration {

LateParsedMemberInitializer(Parser *

, Decl *FD)

: Self(

),

(FD) { }

ParseLexedMemberInitializers()

;

SmallVector<LateParsedDeclaration*,2> LateParsedDeclarationsContainer;

ParsingClass {

ParsingClass(Decl *TagOrTemplate,

TopLevelClass,

IsInterface)

: TopLevelClass(TopLevelClass), IsInterface(IsInterface),

TagOrTemplate(TagOrTemplate) {}

TopLevelClass : 1;

IsInterface : 1;

*TagOrTemplate;

LateParsedDeclarationsContainer LateParsedDeclarations;

std::stack<ParsingClass *> ClassStack;

ParsingClass &getCurrentClass() {

assert(!ClassStack.empty() &&

);

*ClassStack.top();

ParsingClassDefinition {

ParsingClassDefinition(Parser &P, Decl *TagOrTemplate,

TopLevelClass,

State(

.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {

assert(!Popped &&

);

.PopParsingClass(State);

~ParsingClassDefinition() {

.PopParsingClass(State);

ParsedTemplateInfo {

ParsedTemplateInfo() :

(NonTemplate), TemplateParams(nullptr) {}

isSpecialization,

lastParameterListWasEmpty =

)

:

(isSpecialization? ExplicitSpecialization : Template),

TemplateParams(TemplateParams),

LastParameterListWasEmpty(lastParameterListWasEmpty) { }

ParsedTemplateInfo(SourceLocation ExternLoc,

SourceLocation TemplateLoc)

:

(ExplicitInstantiation), TemplateParams(nullptr),

ExternLoc(ExternLoc), TemplateLoc(TemplateLoc),

LastParameterListWasEmpty(

){ }

ExplicitSpecialization,

ExplicitInstantiation

SourceLocation ExternLoc;

SourceLocation TemplateLoc;

LastParameterListWasEmpty;

struct ReenterTemplateScopeRAII;

struct ReenterClassScopeRAII;

LexTemplateFunctionForLateParsing(

&Toks);

ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);

static

LateTemplateParserCallback(

*

, LateParsedTemplate &LPT);

Sema::ParsingClassState

PushParsingClass(Decl *TagOrTemplate,

TopLevelClass,

IsInterface);

DeallocateParsedClasses(ParsingClass *

);

PopParsingClass(Sema::ParsingClassState);

enum CachedInitKind {

CIK_DefaultArgument,

CIK_DefaultInitializer

ParsedAttributesView &AccessAttrs,

ParsingDeclarator &

,

ParsedTemplateInfo &TemplateInfo,

VirtSpecifiers &VS,

SourceLocation PureSpecLoc);

StringLiteral *ParseCXXDeletedFunctionMessage();

SkipDeletedFunctionBody();

ParseCXXNonStaticMemberInitializer(Decl *VarD);

ParseLexedAttributes(ParsingClass &

);

ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *

,

ParseLexedCAttributeList(LateParsedAttrList &LA,

,

ParsedAttributes *OutAttrs =

);

ParseLexedAttribute(LateParsedAttribute &LA,

ParseLexedCAttribute(LateParsedAttribute &LA,

,

ParsedAttributes *OutAttrs =

);

ParseLexedMethodDeclarations(ParsingClass &

);

ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);

ParseLexedMethodDefs(ParsingClass &

);

ParseLexedMethodDef(LexedMethod &LM);

ParseLexedMemberInitializers(ParsingClass &

);

ParseLexedMemberInitializer(LateParsedMemberInitializer &MI);

ParseLexedObjCMethodDefs(LexedMethod &LM,

parseMethod);

ParseLexedPragmas(ParsingClass &

);

ParseLexedPragma(LateParsedPragma &LP);

ConsumeAndStoreFunctionPrologue(

&Toks);

ConsumeAndStoreInitializer(

&Toks, CachedInitKind CIK);

ConsumeFinalToken =

) {

ConsumeAndStoreUntil(T1, T1, Toks,

, ConsumeFinalToken);

ConsumeFinalToken =

);

ParseExternalDeclaration(ParsedAttributes &DeclAttrs,

ParsedAttributes &DeclSpecAttrs,

ParsingDeclSpec *DS =

);

isDeclarationAfterDeclarator();

isStartOfFunctionDefinition(

ParsingDeclarator &Declarator);

ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,

ParseDeclOrFunctionDefInternal(ParsedAttributes &Attrs,

ParsedAttributes &DeclSpecAttrs,

ParsingDeclSpec &DS,

SkipFunctionBody();

*ParseFunctionDefinition(ParsingDeclarator &

,

ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),

LateParsedAttrList *LateParsedAttrs =

);

ParseKNRParamDeclarations(Declarator &

);

ParseSimpleAsm(

ForAsmLabel, SourceLocation *EndLoc);

ParseAsmStringLiteral(

ForAsmLabel);

ParseObjCAtDirectives(ParsedAttributes &DeclAttrs,

ParsedAttributes &DeclSpecAttrs);

ParseObjCAtClassDeclaration(SourceLocation atLoc);

*ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,

ParsedAttributes &prefixAttrs);

ObjCTypeParamListScope;

ObjCTypeParamList *parseObjCTypeParamList();

ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(

ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,

SmallVectorImpl<IdentifierLocPair> &protocolIdents,

SourceLocation &rAngleLoc,

mayBeProtocolList =

);

HelperActionsForIvarDeclarations(ObjCContainerDecl *interfaceDecl,

SourceLocation atLoc,

SmallVectorImpl<Decl *> &AllIvarDecls,

RBraceMissing);

ParseObjCClassInstanceVariables(ObjCContainerDecl *interfaceDecl,

SourceLocation atLoc);

ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &

,

SmallVectorImpl<SourceLocation> &PLocs,

WarnOnDeclarations,

ForObjCContainer,

SourceLocation &LAngleLoc,

SourceLocation &EndProtoLoc,

consumeLastToken);

parseObjCTypeArgsOrProtocolQualifiers(

SourceLocation &typeArgsLAngleLoc,

SmallVectorImpl<ParsedType> &typeArgs,

SourceLocation &typeArgsRAngleLoc,

SourceLocation &protocolLAngleLoc,

SmallVectorImpl<Decl *> &protocols,

SmallVectorImpl<SourceLocation> &protocolLocs,

SourceLocation &protocolRAngleLoc,

consumeLastToken,

warnOnIncompleteProtocols);

parseObjCTypeArgsAndProtocolQualifiers(

SourceLocation &typeArgsLAngleLoc,

SmallVectorImpl<ParsedType> &typeArgs,

SourceLocation &typeArgsRAngleLoc,

SourceLocation &protocolLAngleLoc,

SmallVectorImpl<Decl *> &protocols,

SmallVectorImpl<SourceLocation> &protocolLocs,

SourceLocation &protocolRAngleLoc,

consumeLastToken);

parseObjCProtocolQualifierType(SourceLocation &rAngleLoc);

parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,

consumeLastToken,

SourceLocation &endLoc);

ParseObjCAtProtocolDeclaration(SourceLocation atLoc,

ParsedAttributes &prefixAttrs);

ObjCImplParsingDataRAII {

SmallVector<LexedMethod*, 8> LateParsedObjCMethodContainer;

LateParsedObjCMethodContainer LateParsedObjCMethods;

ObjCImplParsingDataRAII(Parser &parser, Decl *

)

:

(parser), Dcl(

), HasCFunction(

) {

.CurParsedObjCImpl =

;

~ObjCImplParsingDataRAII();

finish(SourceRange AtEnd);

isFinished()

{

Finished; }

ObjCImplParsingDataRAII *CurParsedObjCImpl;

StashAwayMethodOrFunctionBodyTokens(Decl *MDecl);

ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,

ParsedAttributes &Attrs);

*ParseObjCAtAliasDeclaration(SourceLocation atLoc);

*ParseObjCPropertySynthesize(SourceLocation atLoc);

*ParseObjCPropertyDynamic(SourceLocation atLoc);

IdentifierInfo *ParseObjCSelectorPiece(SourceLocation &MethodLocation);

objc_in=0, objc_out, objc_inout, objc_oneway, objc_bycopy, objc_byref,

objc_nonnull, objc_nullable, objc_null_unspecified,

IdentifierInfo *ObjCTypeQuals[objc_NumQuals];

isTokIdentifier_in()

;

ParsedAttributes *ParamAttrs);

*ParseObjCMethodPrototype(

MethodDefinition =

);

MethodDefinition=

);

ParseObjCPropertyAttribute(ObjCDeclSpec &DS);

*ParseObjCMethodDefinition();

&NumLineToksConsumed,

IsUnevaluated);

CastParseKind {

ParseCastExpression(CastParseKind ParseKind,

isAddressOfOperand,

isVectorLiteral =

,

*NotPrimaryExpression =

);

ParseCastExpression(CastParseKind ParseKind,

isAddressOfOperand =

,

isVectorLiteral =

,

*NotPrimaryExpression =

);

isNotExpressionStart();

isPostfixExpressionSuffixStart() {

(K == tok::l_square || K == tok::l_paren ||

K == tok::period || K == tok::arrow ||

K == tok::plusplus || K == tok::minusminus);

diagnoseUnknownTemplateId(

TemplateName, SourceLocation

);

checkPotentialAngleBracket(

&PotentialTemplateName);

checkPotentialAngleBracketDelimiter(

AngleBracketTracker::Loc &,

Token &OpToken);

checkPotentialAngleBracketDelimiter(

Token &OpToken) {

(

*Info = AngleBrackets.getCurrent(*

))

checkPotentialAngleBracketDelimiter(*Info, OpToken);

ParseUnaryExprOrTypeTraitExpression();

ParseSYCLUniqueStableNameExpression();

ParseExprAfterUnaryExprOrTypeTrait(

Token &OpTok,

SourceRange &CastRange);

ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,

llvm::function_ref<

()> ExpressionStarts =

llvm::function_ref<

()>(),

FailImmediatelyOnInvalidExpr =

,

EarlyTypoCorrection =

,

*HasTrailingComma =

);

ParseSimpleExpressionList(SmallVectorImpl<Expr *> &Exprs);

ParenParseOption {

ParseParenExpression(ParenParseOption &ExprType,

stopIfCastExpr,

SourceLocation &RParenLoc);

ParenParseOption &ExprType,

&CastTy,

SourceLocation LParenLoc,

SourceLocation RParenLoc);

ParseGenericSelectionExpression();

tryParseCXXIdExpression(CXXScopeSpec &SS,

isAddressOfOperand,

Token &Replacement);

ParseCXXIdExpression(

isAddressOfOperand =

);

areTokensAdjacent(

Token &A,

Token &B);

CheckForTemplateAndDigraph(Token &Next,

ObjectTypePtr,

EnteringContext, IdentifierInfo &II,

ParseOptionalCXXScopeSpecifier(

CXXScopeSpec &SS,

ObjectType,

ObjectHasErrors,

EnteringContext,

*MayBePseudoDestructor =

,

IsTypename =

,

IdentifierInfo **LastII =

,

OnlyNamespace =

,

InUsingDeclaration =

,

Disambiguation =

);

LambdaIntroducerTentativeParse {

ParseLambdaIntroducer(LambdaIntroducer &Intro,

LambdaIntroducerTentativeParse *Tentative =

);

ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro);

ParseCXXPseudoDestructor(Expr *

, SourceLocation OpLoc,

SourceRange &SpecificationRange,

SmallVectorImpl<ParsedType> &DynamicExceptions,

SmallVectorImpl<SourceRange> &DynamicExceptionRanges,

SourceRange &SpecificationRange,

SmallVectorImpl<ParsedType> &Exceptions,

SmallVectorImpl<SourceRange> &Ranges);

MayBeFollowedByDirectInit);

ParseCXXTypeConstructExpression(

DeclSpec &DS);

ParseCXXSimpleTypeSpecifier(DeclSpec &DS);

ParseCXXTypeSpecifierSeq(

ParseExpressionListOrTypeId(SmallVectorImpl<Expr*> &Exprs,

ParseDirectNewDeclarator(Declarator &

);

ParseCXXNewExpression(

UseGlobal, SourceLocation Start);

ParseCXXDeleteExpression(

UseGlobal,

SourceLocation Start);

ForRangeInfo;

Sema::ConditionResult ParseCXXCondition(

*InitStmt,

SourceLocation

,

ForRangeInfo *FRI =

,

EnterForConditionScope =

);

ParsedAttributes &Attrs);

ParseTrailingRequiresClause(Declarator &

);

(Tok.isNot(tok::l_brace))

ParseBraceInitializer();

MayBeDesignationStart();

DesignatorCompletionInfo {

SmallVectorImpl<Expr *> &InitExprs;

QualType PreferredBaseType;

ParseInitializerWithPotentialDesignator(DesignatorCompletionInfo);

injectEmbedTokens();

ParseObjCAtExpression(SourceLocation AtLocation);

ParseObjCStringLiteral(SourceLocation AtLoc);

ParseObjCCharacterLiteral(SourceLocation AtLoc);

ParseObjCNumericLiteral(SourceLocation AtLoc);

ParseObjCBooleanLiteral(SourceLocation AtLoc,

ArgValue);

ParseObjCArrayLiteral(SourceLocation AtLoc);

ParseObjCDictionaryLiteral(SourceLocation AtLoc);

ParseObjCBoxedExpr(SourceLocation AtLoc);

ParseObjCEncodeExpression(SourceLocation AtLoc);

ParseObjCSelectorExpression(SourceLocation AtLoc);

ParseObjCProtocolExpression(SourceLocation AtLoc);

isSimpleObjCMessageExpression();

ParseObjCMessageExpressionBody(SourceLocation LBracloc,

SourceLocation SuperLoc,

Expr *ReceiverExpr);

ParseAssignmentExprWithObjCMessageExprStart(

SourceLocation LBracloc, SourceLocation SuperLoc,

ReceiverType, Expr *ReceiverExpr);

ParseObjCXXMessageReceiver(

&IsExpr,

*&TypeOrExpr);

SmallVector<Expr*, 12> ExprVector;

ParseStatement(SourceLocation *TrailingElseLoc =

,

ParsedStmtContext StmtCtx = ParsedStmtContext::SubStmt);

&Stmts, ParsedStmtContext StmtCtx,

SourceLocation *TrailingElseLoc =

);

ParseStatementOrDeclarationAfterAttributes(

&Stmts, ParsedStmtContext StmtCtx,

SourceLocation *TrailingElseLoc, ParsedAttributes &DeclAttrs,

ParsedAttributes &DeclSpecAttrs);

ParseExprStatement(ParsedStmtContext StmtCtx);

ParseLabeledStatement(ParsedAttributes &Attrs,

ParsedStmtContext StmtCtx);

ParseCaseStatement(ParsedStmtContext StmtCtx,

MissingCase =

,

ParseDefaultStatement(ParsedStmtContext StmtCtx);

ParseCompoundStatement(

isStmtExpr =

);

ParseCompoundStatement(

isStmtExpr,

ScopeFlags);

ParseCompoundStatementLeadingPragmas();

DiagnoseLabelAtEndOfCompoundStatement();

ParseCompoundStatementBody(

isStmtExpr =

);

ParseParenExprOrCondition(

*InitStmt,

Sema::ConditionResult &CondResult,

SourceLocation &LParenLoc,

SourceLocation &RParenLoc);

ParseIfStatement(SourceLocation *TrailingElseLoc);

ParseSwitchStatement(SourceLocation *TrailingElseLoc);

ParseWhileStatement(SourceLocation *TrailingElseLoc);

ParseForStatement(SourceLocation *TrailingElseLoc);

ParseMicrosoftAsmStatement(SourceLocation AsmLoc);

SourceLocation *TrailingElseLoc,

ParsedAttributes &Attrs);

IfExistsBehavior {

IfExistsCondition {

SourceLocation KeywordLoc;

IfExistsBehavior Behavior;

ParseMicrosoftIfExistsCondition(IfExistsCondition&

);

ParseMicrosoftIfExistsStatement(

&Stmts);

ParseMicrosoftIfExistsExternalDeclaration();

ParseMicrosoftIfExistsClassDeclaration(

TagType,

ParsedAttributes &AccessAttrs,

ParseMicrosoftIfExistsBraceInitializer(ExprVector &InitExprs,

ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,

SmallVectorImpl<Expr *> &Constraints,

SmallVectorImpl<Expr *> &Exprs);

ParseCXXTryBlockCommon(SourceLocation TryLoc,

FnTry =

);

ParseCXXCatchBlock(

FnCatch =

);

ParseObjCAtStatement(SourceLocation atLoc,

ParsedStmtContext StmtCtx);

ParseObjCTryStmt(SourceLocation atLoc);

ParseObjCThrowStmt(SourceLocation atLoc);

ParseObjCSynchronizedStmt(SourceLocation atLoc);

ParseObjCAutoreleasePoolStmt(SourceLocation atLoc);

DeclSpecContext {

DSC_alias_declaration,

DSC_template_type_arg,

DSC_objc_method_result,

isTypeSpecifier(DeclSpecContext DSC) {

DeclSpecContext::DSC_normal:

DeclSpecContext::DSC_template_param:

DeclSpecContext::DSC_template_arg:

DeclSpecContext::DSC_class:

DeclSpecContext::DSC_top_level:

DeclSpecContext::DSC_objc_method_result:

DeclSpecContext::DSC_condition:

DeclSpecContext::DSC_template_type_arg:

DeclSpecContext::DSC_type_specifier:

DeclSpecContext::DSC_conv_operator:

DeclSpecContext::DSC_trailing:

DeclSpecContext::DSC_alias_declaration:

DeclSpecContext::DSC_association:

DeclSpecContext::DSC_new:

llvm_unreachable(

);

AllowDefiningTypeSpec {

AllowDefiningTypeSpec

isDefiningTypeSpecifierContext(DeclSpecContext DSC,

IsCPlusPlus) {

DeclSpecContext::DSC_normal:

DeclSpecContext::DSC_class:

DeclSpecContext::DSC_top_level:

DeclSpecContext::DSC_alias_declaration:

DeclSpecContext::DSC_objc_method_result:

AllowDefiningTypeSpec::Yes;

DeclSpecContext::DSC_condition:

DeclSpecContext::DSC_template_param:

AllowDefiningTypeSpec::YesButInvalid;

DeclSpecContext::DSC_template_type_arg:

DeclSpecContext::DSC_type_specifier:

AllowDefiningTypeSpec::NoButErrorRecovery;

DeclSpecContext::DSC_association:

IsCPlusPlus ? AllowDefiningTypeSpec::NoButErrorRecovery

: AllowDefiningTypeSpec::Yes;

DeclSpecContext::DSC_trailing:

DeclSpecContext::DSC_conv_operator:

DeclSpecContext::DSC_template_arg:

DeclSpecContext::DSC_new:

AllowDefiningTypeSpec::No;

llvm_unreachable(

);

isOpaqueEnumDeclarationContext(DeclSpecContext DSC) {

DeclSpecContext::DSC_normal:

DeclSpecContext::DSC_class:

DeclSpecContext::DSC_top_level:

DeclSpecContext::DSC_alias_declaration:

DeclSpecContext::DSC_objc_method_result:

DeclSpecContext::DSC_condition:

DeclSpecContext::DSC_template_param:

DeclSpecContext::DSC_template_type_arg:

DeclSpecContext::DSC_type_specifier:

DeclSpecContext::DSC_trailing:

DeclSpecContext::DSC_association:

DeclSpecContext::DSC_conv_operator:

DeclSpecContext::DSC_template_arg:

DeclSpecContext::DSC_new:

llvm_unreachable(

);

isClassTemplateDeductionContext(DeclSpecContext DSC) {

DeclSpecContext::DSC_normal:

DeclSpecContext::DSC_template_param:

DeclSpecContext::DSC_template_arg:

DeclSpecContext::DSC_class:

DeclSpecContext::DSC_top_level:

DeclSpecContext::DSC_condition:

DeclSpecContext::DSC_type_specifier:

DeclSpecContext::DSC_association:

DeclSpecContext::DSC_conv_operator:

DeclSpecContext::DSC_new:

DeclSpecContext::DSC_objc_method_result:

DeclSpecContext::DSC_template_type_arg:

DeclSpecContext::DSC_trailing:

DeclSpecContext::DSC_alias_declaration:

llvm_unreachable(

);

getImplicitTypenameContext(DeclSpecContext DSC) {

DeclSpecContext::DSC_class:

DeclSpecContext::DSC_top_level:

DeclSpecContext::DSC_type_specifier:

DeclSpecContext::DSC_template_type_arg:

DeclSpecContext::DSC_trailing:

DeclSpecContext::DSC_alias_declaration:

DeclSpecContext::DSC_template_param:

DeclSpecContext::DSC_new:

DeclSpecContext::DSC_normal:

DeclSpecContext::DSC_objc_method_result:

DeclSpecContext::DSC_condition:

DeclSpecContext::DSC_template_arg:

DeclSpecContext::DSC_conv_operator:

DeclSpecContext::DSC_association:

llvm_unreachable(

);

ForRangeInit {

SourceLocation ColonLoc;

SmallVector<MaterializeTemporaryExpr *, 8> LifetimeExtendTemps;

ParsedForRangeDecl() {

!ColonLoc.

(); }

ForRangeInfo : ForRangeInit {

SourceLocation &DeclEnd,

ParsedAttributes &DeclAttrs,

ParsedAttributes &DeclSpecAttrs,

SourceLocation *DeclSpecStart =

);

ParsedAttributes &DeclAttrs,

ParsedAttributes &DeclSpecAttrs,

RequireSemi,

ForRangeInit *FRI =

,

SourceLocation *DeclSpecStart =

);

ParsedAttributes &Attrs,

ParsedTemplateInfo &TemplateInfo,

SourceLocation *DeclEnd =

,

ForRangeInit *FRI =

);

*ParseDeclarationAfterDeclarator(Declarator &

,

ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());

ParseAsmAttributesAfterDeclarator(Declarator &

);

*ParseDeclarationAfterDeclaratorAndAttributes(

ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),

ForRangeInit *FRI =

);

*ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope);

*ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope);

trySkippingFunctionBody();

ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,

DeclSpecContext DSC, ParsedAttributes &Attrs);

ParseDeclarationSpecifiers(DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,

DeclSpecContext DSC = DeclSpecContext::DSC_normal,

LateParsedAttrList *LateAttrs =

) {

ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC, LateAttrs,

getImplicitTypenameContext(DSC));

ParseDeclarationSpecifiers(DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,

LateParsedAttrList *LateAttrs,

SourceLocation ParsePackIndexingType(DeclSpec &DS);

AnnotateExistingIndexedTypeNamePack(

,

SourceLocation StartLoc,

SourceLocation EndLoc);

DiagnoseMissingSemiAfterTagDefinition(

LateParsedAttrList *LateAttrs =

);

ParseSpecifierQualifierList(

DeclSpecContext DSC = DeclSpecContext::DSC_normal) {

ParseSpecifierQualifierList(DS, getImplicitTypenameContext(DSC), AS, DSC);

ParseSpecifierQualifierList(

DeclSpecContext DSC = DeclSpecContext::DSC_normal);

ParseObjCTypeQualifierList(ObjCDeclSpec &DS,

ParseEnumSpecifier(SourceLocation TagLoc, DeclSpec &DS,

ParsedTemplateInfo &TemplateInfo,

ParseEnumBody(SourceLocation StartLoc, Decl *TagDecl);

ParseStructUnionBody(SourceLocation StartLoc,

TagType,

RecordDecl *TagDecl);

ParseStructDeclaration(

ParsingDeclSpec &DS,

llvm::function_ref<Decl *(ParsingFieldDeclarator &)> FieldsCallback,

LateParsedAttrList *LateFieldAttrs =

);

DisambiguatingWithExpression =

);

isTypeSpecifierQualifier();

isKnownToBeTypeSpecifier(

Token &Tok)

;

isKnownToBeDeclarationSpecifier() {

isDeclarationStatement(

DisambiguatingWithExpression =

) {

isCXXDeclarationStatement(DisambiguatingWithExpression);

isForInitDeclaration() {

Tok.is(tok::kw_using) ||

isCXXSimpleDeclaration(

);

isForRangeIdentifier();

isStartOfObjCClassMessageMissingOpenBracket();

isConstructorDeclarator(

ParsedTemplateInfo *TemplateInfo =

);

TentativeCXXTypeIdContext {

TypeIdAsTemplateArgument,

TypeIdInTrailingReturnType,

TypeIdAsGenericSelectionArgument,

isTypeIdInParens(

&isAmbiguous) {

isCXXTypeId(TypeIdInParens, isAmbiguous);

isAmbiguous =

;

isTypeSpecifierQualifier();

isTypeIdInParens() {

isTypeIdInParens(isAmbiguous);

isTypeIdForGenericSelection() {

isCXXTypeId(TypeIdAsGenericSelectionArgument, isAmbiguous);

isTypeSpecifierQualifier();

isTypeIdUnambiguously() {

isCXXTypeId(TypeIdUnambiguous, isAmbiguous);

isTypeSpecifierQualifier();

isCXXDeclarationStatement(

DisambiguatingWithExpression =

);

isCXXSimpleDeclaration(

AllowForRangeDecl);

isCXXFunctionDeclarator(

*IsAmbiguous =

,

ConditionDeclarationOrInitStatementState;

ConditionOrInitStatement {

ConditionOrInitStatement

isCXXConditionDeclarationOrInitStatement(

CanBeInitStmt,

CanBeForRangeDecl);

isCXXTypeId(TentativeCXXTypeIdContext Context,

&isAmbiguous);

isCXXTypeId(TentativeCXXTypeIdContext Context) {

isCXXTypeId(Context, isAmbiguous);

TPResult {

isEnumBase(

AllowSemi);

TPResult BracedCastResult = TPResult::False,

*InvalidAsDeclSpec =

);

isCXXDeclarationSpecifierAType();

TPResult isTemplateArgumentList(

TokensToSkip);

TPResult isExplicitBool();

isTentativelyDeclared(IdentifierInfo *II);

TPResult TryParseSimpleDeclaration(

AllowForRangeDecl);

TPResult TryParseTypeofSpecifier();

TPResult TryParseProtocolQualifiers();

TPResult TryParsePtrOperatorSeq();

TPResult TryParseOperatorId();

TPResult TryParseInitDeclaratorList(

MayHaveTrailingReturnType =

);

TPResult TryParseDeclarator(

mayBeAbstract,

mayHaveIdentifier =

,

mayHaveDirectInit =

,

mayHaveTrailingReturnType =

);

TPResult TryParseParameterDeclarationClause(

*InvalidAsDeclaration =

,

VersusTemplateArg =

,

TPResult TryParseFunctionDeclarator(

MayHaveTrailingReturnType =

);

NameAfterArrowIsNonType();

TPResult TryParseBracketDeclarator();

TPResult TryConsumeDeclarationSpecifier();

TrySkipAttributes();

DiagnoseBitIntUse(

Token &Tok);

ParsedAttributes *Attrs =

);

ParseBlockId(SourceLocation CaretLoc);

isAllowedCXX11AttributeSpecifier(

Disambiguate =

,

OuterMightBeMessageSend =

) {

(Tok.isRegularKeywordAttribute() ||

isCXX11AttributeSpecifier(Disambiguate, OuterMightBeMessageSend));

CheckProhibitedCXX11Attribute() {

assert(Tok.is(tok::l_square));

DiagnoseProhibitedCXX11Attribute();

DiagnoseProhibitedCXX11Attribute();

CheckMisplacedCXX11Attribute(ParsedAttributes &Attrs,

SourceLocation CorrectLocation) {

(!Tok.isRegularKeywordAttribute() &&

(Tok.isNot(tok::l_square) ||

().isNot(tok::l_square)) &&

Tok.isNot(tok::kw_alignas))

DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);

DiagnoseMisplacedCXX11Attribute(ParsedAttributes &Attrs,

SourceLocation CorrectLocation);

stripTypeAttributesOffDeclSpec(ParsedAttributes &Attrs, DeclSpec &DS,

ProhibitAttributes(ParsedAttributes &Attrs,

SourceLocation FixItLoc = SourceLocation()) {

(Attrs.Range.isInvalid())

DiagnoseProhibitedAttributes(Attrs, FixItLoc);

ProhibitAttributes(ParsedAttributesView &Attrs,

SourceLocation FixItLoc = SourceLocation()) {

(Attrs.Range.isInvalid())

DiagnoseProhibitedAttributes(Attrs, FixItLoc);

Attrs.clearListOnly();

DiagnoseProhibitedAttributes(

ParsedAttributesView &Attrs,

SourceLocation FixItLoc);

ProhibitCXX11Attributes(ParsedAttributes &Attrs,

AttrDiagID,

KeywordDiagId,

DiagnoseEmptyAttrs =

,

WarnOnUnknownAttrs =

);

SourceLocation SkipCXX11Attributes();

DiagnoseAndSkipCXX11Attributes();

DiagnoseCXX11AttributeExtension(ParsedAttributes &Attrs);

ParseUnevaluatedStringInAttribute(

IdentifierInfo &AttrName);

SmallVectorImpl<Expr *> &Exprs,

ParsedAttributeArgumentsProperties ArgsProperties);

ParseAttributeArgsCommon(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,

ParsedAttributes &Attrs, SourceLocation *EndLoc,

IdentifierInfo *ScopeName, SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseAttrKindMask {

PAKM_Declspec = 1 << 1,

PAKM_CXX11 = 1 << 2,

ParseAttributes(

WhichAttrKinds, ParsedAttributes &Attrs,

LateParsedAttrList *LateAttrs =

);

MaybeParseAttributes(

WhichAttrKinds, ParsedAttributes &Attrs,

LateParsedAttrList *LateAttrs =

) {

(Tok.isOneOf(tok::kw___attribute, tok::kw___declspec) ||

isAllowedCXX11AttributeSpecifier()) {

ParseAttributes(WhichAttrKinds, Attrs, LateAttrs);

MaybeParseGNUAttributes(Declarator &

,

LateParsedAttrList *LateAttrs =

) {

(Tok.is(tok::kw___attribute)) {

ParsedAttributes Attrs(AttrFactory);

ParseGNUAttributes(Attrs, LateAttrs, &

);

.takeAttributes(Attrs);

MaybeParseGNUAttributes(ParsedAttributes &Attrs,

LateParsedAttrList *LateAttrs =

) {

(Tok.is(tok::kw___attribute)) {

ParseGNUAttributes(Attrs, LateAttrs);

ParseSingleGNUAttribute(ParsedAttributes &Attrs, SourceLocation &EndLoc,

LateParsedAttrList *LateAttrs =

,

Declarator *

=

);

ParseGNUAttributes(ParsedAttributes &Attrs,

LateParsedAttrList *LateAttrs =

,

Declarator *

=

);

ParseGNUAttributeArgs(IdentifierInfo *AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs, SourceLocation *EndLoc,

IdentifierInfo *ScopeName, SourceLocation ScopeLoc,

ParsedAttr::Form Form, Declarator *

);

IdentifierLoc *ParseIdentifierLoc();

ParseClangAttributeArgs(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,

ParsedAttributes &Attrs, SourceLocation *EndLoc,

IdentifierInfo *ScopeName, SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ReplayOpenMPAttributeTokens(

&OpenMPTokens) {

(!OpenMPTokens.empty()) {

PP.EnterTokenStream(OpenMPTokens,

,

MaybeParseCXX11Attributes(Declarator &

) {

(isAllowedCXX11AttributeSpecifier()) {

ParsedAttributes Attrs(AttrFactory);

ParseCXX11Attributes(Attrs);

.takeAttributes(Attrs);

MaybeParseCXX11Attributes(ParsedAttributes &Attrs,

OuterMightBeMessageSend =

) {

(isAllowedCXX11AttributeSpecifier(

, OuterMightBeMessageSend)) {

ParseCXX11Attributes(Attrs);

ParseOpenMPAttributeArgs(

IdentifierInfo *AttrName,

ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs,

SourceLocation *EndLoc =

);

ParseCXX11AttributeSpecifier(ParsedAttributes &Attrs,

SourceLocation *EndLoc =

) {

ParseCXX11AttributeSpecifierInternal(Attrs, OpenMPTokens, EndLoc);

ReplayOpenMPAttributeTokens(OpenMPTokens);

ParseCXX11Attributes(ParsedAttributes &attrs);

ParseCXX11AttributeArgs(IdentifierInfo *AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs, SourceLocation *EndLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParseCXXAssumeAttributeArg(ParsedAttributes &Attrs,

IdentifierInfo *AttrName,

SourceLocation AttrNameLoc,

SourceLocation *EndLoc,

ParsedAttr::Form Form);

IdentifierInfo *TryParseCXX11AttributeIdentifier(

SourceLocation &

,

IdentifierInfo *EnclosingScope =

);

MaybeParseHLSLAnnotations(Declarator &

,

SourceLocation *EndLoc =

,

CouldBeBitField =

) {

assert(

().

&&

);

(Tok.is(tok::colon)) {

ParsedAttributes Attrs(AttrFactory);

ParseHLSLAnnotations(Attrs, EndLoc, CouldBeBitField);

.takeAttributes(Attrs);

MaybeParseHLSLAnnotations(ParsedAttributes &Attrs,

SourceLocation *EndLoc =

) {

assert(

().

&&

);

(Tok.is(tok::colon))

ParseHLSLAnnotations(Attrs, EndLoc);

ParseHLSLAnnotations(ParsedAttributes &Attrs,

SourceLocation *EndLoc =

,

CouldBeBitField =

);

*ParseHLSLBuffer(SourceLocation &DeclEnd);

MaybeParseMicrosoftAttributes(ParsedAttributes &Attrs) {

Tok.is(tok::l_square)) {

ParsedAttributes AttrsWithRange(AttrFactory);

ParseMicrosoftAttributes(AttrsWithRange);

Attrs.takeAllFrom(AttrsWithRange);

ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs);

ParseMicrosoftAttributes(ParsedAttributes &Attrs);

MaybeParseMicrosoftDeclSpecs(ParsedAttributes &Attrs) {

(

().DeclSpecKeyword && Tok.is(tok::kw___declspec)) {

ParseMicrosoftDeclSpecs(Attrs);

ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs);

ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs);

ParseMicrosoftTypeAttributes(ParsedAttributes &attrs);

ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &Attrs);

DiagnoseAndSkipExtendedMicrosoftTypeAttributes();

SourceLocation SkipExtendedMicrosoftTypeAttributes();

ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs);

ParseNullabilityClassAttributes(ParsedAttributes &attrs);

ParseBorlandTypeAttributes(ParsedAttributes &attrs);

ParseOpenCLKernelAttributes(ParsedAttributes &attrs);

ParseOpenCLQualifiers(ParsedAttributes &Attrs);

ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);

ParseCUDAFunctionAttributes(ParsedAttributes &attrs);

isHLSLQualifier(

Token &Tok)

;

ParseHLSLQualifiers(ParsedAttributes &Attrs);

VersionTuple ParseVersionTuple(SourceRange &

);

ParseAvailabilityAttribute(IdentifierInfo &Availability,

SourceLocation AvailabilityLoc,

ParsedAttributes &attrs,

SourceLocation *endLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

std::optional<AvailabilitySpec> ParseAvailabilitySpec();

ParseAvailabilityCheckExpr(SourceLocation StartLoc);

ParseExternalSourceSymbolAttribute(IdentifierInfo &ExternalSourceSymbol,

SourceLocation

,

ParsedAttributes &Attrs,

SourceLocation *EndLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,

SourceLocation ObjCBridgeRelatedLoc,

ParsedAttributes &Attrs,

SourceLocation *EndLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseSwiftNewTypeAttribute(IdentifierInfo &AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs,

SourceLocation *EndLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs,

SourceLocation *EndLoc,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseAttributeWithTypeArg(IdentifierInfo &AttrName,

SourceLocation AttrNameLoc,

ParsedAttributes &Attrs,

IdentifierInfo *ScopeName,

SourceLocation ScopeLoc,

ParsedAttr::Form Form);

DistributeCLateParsedAttrs(Decl *Dcl, LateParsedAttrList *LateAttrs);

ParseBoundsAttribute(IdentifierInfo &AttrName,

SourceLocation AttrNameLoc, ParsedAttributes &Attrs,

IdentifierInfo *ScopeName, SourceLocation ScopeLoc,

ParsedAttr::Form Form);

ParseTypeofSpecifier(DeclSpec &DS);

SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);

AnnotateExistingDecltypeSpecifier(

DeclSpec &DS,

SourceLocation StartLoc,

SourceLocation EndLoc);

ParseAtomicSpecifier(DeclSpec &DS);

ParseAlignArgument(StringRef KWName, SourceLocation Start,

SourceLocation &EllipsisLoc,

&IsType,

ParseAlignmentSpecifier(ParsedAttributes &Attrs,

SourceLocation *endLoc =

);

isCXX11VirtSpecifier(Tok);

ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS,

IsInterface,

SourceLocation FriendLoc);

isCXX11FinalKeyword()

;

isClassCompatibleKeyword()

;

DeclaratorScopeObj {

DeclaratorScopeObj(Parser &p, CXXScopeSpec &ss)

:

(p), SS(ss), EnteredScope(

), CreatedScope(

) {}

EnterDeclaratorScope() {

assert(!EnteredScope &&

);

assert(SS.isSet() &&

);

CreatedScope =

;

(!

.Actions.ActOnCXXEnterDeclaratorScope(

.getCurScope(), SS))

EnteredScope =

;

~DeclaratorScopeObj() {

assert(SS.isSet() &&

);

.Actions.ActOnCXXExitDeclaratorScope(

.getCurScope(), SS);

ParseDeclarator(Declarator &

);

void (Parser::*DirectDeclParseFunction)(

&);

ParseDeclaratorInternal(Declarator &

,

DirectDeclParseFunction DirectDeclParser);

AttrRequirements {

AR_NoAttributesParsed = 0,

AR_GNUAttributesParsedAndRejected = 1 << 0,

AR_GNUAttributesParsed = 1 << 1,

AR_CXX11AttributesParsed = 1 << 2,

AR_DeclspecAttributesParsed = 1 << 3,

AR_AllAttributesParsed = AR_GNUAttributesParsed |

AR_CXX11AttributesParsed |

AR_DeclspecAttributesParsed,

AR_VendorAttributesParsed = AR_GNUAttributesParsed |

AR_DeclspecAttributesParsed

ParseTypeQualifierListOpt(

DeclSpec &DS,

AttrReqs = AR_AllAttributesParsed,

AtomicAllowed =

,

IdentifierRequired =

,

std::optional<llvm::function_ref<

()>> CodeCompletionHandler =

ParseDirectDeclarator(Declarator &

);

ParseDecompositionDeclarator(Declarator &

);

ParseParenDeclarator(Declarator &

);

ParseFunctionDeclarator(Declarator &

, ParsedAttributes &FirstArgAttrs,

IsAmbiguous,

RequiresArg =

);

InitCXXThisScopeForDeclaratorIfRelevant(

Declarator &

,

DeclSpec &DS,

std::optional<Sema::CXXThisScopeRAII> &ThisScope);

ParseRefQualifier(

&RefQualifierIsLValueRef,

SourceLocation &RefQualifierLoc);

isFunctionDeclaratorIdentifierList();

ParseFunctionDeclaratorIdentifierList(

SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);

ParseParameterDeclarationClause(

Declarator &

, ParsedAttributes &attrs,

SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,

SourceLocation &EllipsisLoc) {

ParseParameterDeclarationClause(

.getContext(), attrs, ParamInfo, EllipsisLoc,

.getCXXScopeSpec().isSet() &&

.isFunctionDeclaratorAFunctionDeclaration());

ParseParameterDeclarationClause(

SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,

SourceLocation &EllipsisLoc,

IsACXXFunctionDeclaration =

);

ParseBracketDeclarator(Declarator &

);

ParseMisplacedBracketDeclarator(Declarator &

);

MaybeParseTypeTransformTypeSpecifier(DeclSpec &DS);

CXX11AttributeKind {

CAK_NotAttributeSpecifier,

CAK_AttributeSpecifier,

CAK_InvalidAttributeSpecifier

isCXX11AttributeSpecifier(

Disambiguate =

,

OuterMightBeMessageSend =

);

DiagnoseUnexpectedNamespace(NamedDecl *Context);

SourceLocation &DeclEnd,

SourceLocation InlineLoc = SourceLocation());

InnerNamespaceInfo {

SourceLocation NamespaceLoc;

SourceLocation InlineLoc;

SourceLocation IdentLoc;

IdentifierInfo *Ident;

ParseInnerNamespace(

InnerNamespaceInfoList &InnerNSs,

index, SourceLocation &InlineLoc,

ParsedAttributes &attrs,

*ParseExportDeclaration();

SourceLocation &DeclEnd, ParsedAttributes &Attrs);

SourceLocation UsingLoc,

SourceLocation &DeclEnd,

ParsedAttributes &attrs);

UsingDeclarator {

SourceLocation TypenameLoc;

SourceLocation EllipsisLoc;

TypenameLoc = EllipsisLoc = SourceLocation();

ParsedTemplateInfo &TemplateInfo,

SourceLocation UsingLoc,

SourceLocation &DeclEnd,

ParsedAttributes &Attrs,

*ParseAliasDeclarationAfterDeclarator(

ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,

ParsedAttributes &Attrs, Decl **OwnedType =

);

*ParseStaticAssertDeclaration(SourceLocation &DeclEnd);

*ParseNamespaceAlias(SourceLocation NamespaceLoc,

SourceLocation AliasLoc, IdentifierInfo *Alias,

SourceLocation &DeclEnd);

isValidAfterTypeSpecifier(

CouldBeBitfield);

ParseClassSpecifier(

TagTokKind, SourceLocation TagLoc,

DeclSpec &DS, ParsedTemplateInfo &TemplateInfo,

DeclSpecContext DSC, ParsedAttributes &Attributes);

SkipCXXMemberSpecification(SourceLocation StartLoc,

SourceLocation AttrFixitLoc,

ParseCXXMemberSpecification(SourceLocation StartLoc,

SourceLocation AttrFixitLoc,

ParsedAttributes &Attrs,

TagType,

ParseCXXMemberInitializer(Decl *

,

IsFunction,

SourceLocation &EqualLoc);

ParseCXXMemberDeclaratorBeforeInitializer(Declarator &DeclaratorInfo,

LateParsedAttrList &LateAttrs);

MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &

,

VirtSpecifiers &VS);

ParsedTemplateInfo &TemplateInfo,

ParsingDeclRAIIObject *DiagsFromTParams =

);

ParsedAttributes &AccessAttrs,

ParseConstructorInitializer(Decl *ConstructorDecl);

HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,

ParseBaseTypeSpecifier(SourceLocation &BaseLoc,

SourceLocation &EndLocation);

ParseBaseClause(Decl *ClassDecl);

ParseBaseSpecifier(Decl *ClassDecl);

ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,

ObjectHadErrors,

SourceLocation TemplateKWLoc,

IdentifierInfo *Name,

SourceLocation NameLoc,

EnteringContext,

UnqualifiedId &

,

AssumeTemplateId);

ParseUnqualifiedIdOperator(CXXScopeSpec &SS,

EnteringContext,

UnqualifiedId &

);

SourceLocation

);

parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty,

llvm::omp::TraitSet

,

llvm::omp::TraitSelector Selector,

llvm::StringMap<SourceLocation> &Seen);

parseOMPTraitSelectorKind(OMPTraitSelector &TISelector,

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &Seen);

parseOMPTraitSetKind(OMPTraitSet &TISet,

llvm::StringMap<SourceLocation> &Seen);

parseOMPContextProperty(OMPTraitSelector &TISelector,

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &Seen);

parseOMPContextSelector(OMPTraitSelector &TISelector,

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &SeenSelectors);

parseOMPContextSelectorSet(OMPTraitSet &TISet,

llvm::StringMap<SourceLocation> &SeenSets);

parseOMPContextSelectors(SourceLocation

, OMPTraitInfo &TI);

parseOpenMPAppendArgs(SmallVectorImpl<OMPInteropInfo> &InteropInfos);

parseOMPDeclareVariantMatchClause(SourceLocation

, OMPTraitInfo &TI,

OMPTraitInfo *ParentTI);

SourceLocation

);

SourceLocation

);

ParseOpenMPEndAssumesDirective(SourceLocation

);

SmallVectorImpl<clang::OMPClause *> &Clauses,

SourceLocation

);

ParseOMPDeclareTargetClauses(SemaOpenMP::DeclareTargetContextInfo &DTCI);

SourceLocation

);

SourceLocation MatchingLoc,

SourceLocation FoundLoc,

SkipUntilOpenMPEnd);

Decl *TagDecl =

);

ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm);

DeclarationName &Name,

tryParseOpenMPArrayShapingCastPart();

ParseOpenMPSimpleVarList(

llvm::function_ref<

(CXXScopeSpec &, DeclarationNameInfo)> &

AllowScopeSpecifier);

ParseOpenMPDeclarativeOrExecutableDirective(

ParsedStmtContext StmtCtx,

ReadDirectiveWithinMetadirective =

);

ParseOpenMPExecutableDirective(ParsedStmtContext StmtCtx,

ReadDirectiveWithinMetadirective);

ParseOpenMPInformationalDirective(

ReadDirectiveWithinMetadirective);

OMPClause *ParseOpenMPSimpleClause(

Kind,

ParseOnly);

ParseOpenMPIndirectClause(SemaOpenMP::DeclareTargetContextInfo &DTCI,

OMPClause *ParseOpenMPSizesClause();

OMPClause *ParseOpenMPPermutationClause();

OMPClause *ParseOpenMPClause(

Kind,

ParseOnly =

);

SourceLocation &ClauseNameLoc,

SourceLocation &OpenLoc,

SourceLocation &CloseLoc,

SmallVectorImpl<Expr *> &Exprs,

ReqIntConst =

);

ParseOMPInteropInfo(OMPInteropInfo &InteropInfo,

Kind);

OMPClause *ParseOpenMPInteropClause(

Kind,

ParseOnly);

OMPClause *ParseOpenMPOMPXAttributesClause(

ParseOnly);

IsAddressOfOperand =

);

SemaOpenMP::OpenMPVarListDataTy &

,

LangOptions &LangOpts);

SmallVectorImpl<Expr *> &Vars,

SemaOpenMP::OpenMPVarListDataTy &

);

ObjectHadErrors,

EnteringContext,

AllowDestructorName,

AllowConstructorName,

AllowDeductionGuide,

SourceLocation *TemplateKWLoc, UnqualifiedId &

);

OpenACCDirectiveParseInfo {

SourceLocation StartLoc;

SourceLocation DirLoc;

SourceLocation LParenLoc;

SourceLocation RParenLoc;

SourceLocation EndLoc;

SourceLocation MiscLoc;

SmallVector<Expr *> Exprs;

SmallVector<OpenACCClause *> Clauses;

OpenACCWaitParseInfo {

Failed =

;

Expr *DevNumExpr =

;

SourceLocation QueuesLoc;

SmallVector<Expr *> QueueIdExprs;

SmallVector<Expr *> getAllExprs() {

SmallVector<Expr *> Out;

Out.push_back(DevNumExpr);

Out.insert(Out.end(), QueueIdExprs.begin(), QueueIdExprs.end());

OpenACCParseCanContinue { Cannot = 0, Can = 1 };

OpenACCClauseParseResult =

llvm::PointerIntPair<OpenACCClause *, 1, OpenACCParseCanContinue>;

OpenACCClauseParseResult OpenACCCanContinue();

OpenACCClauseParseResult OpenACCCannotContinue();

OpenACCClauseParseResult OpenACCSuccess(OpenACCClause *Clause);

OpenACCDirectiveParseInfo ParseOpenACCDirective();

ParseOpenACCCacheVarList();

OpenACCVarParseResult = std::pair<ExprResult, OpenACCParseCanContinue>;

OpenACCClauseParseResult

ParseOpenACCClauseParams(ArrayRef<const OpenACCClause *> ExistingClauses,

SourceLocation ClauseLoc);

OpenACCClauseParseResult

ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,

SmallVector<OpenACCClause *>

OpenACCWaitParseInfo ParseOpenACCWaitArgument(SourceLocation

,

OpenACCIntExprParseResult =

std::pair<ExprResult, OpenACCParseCanContinue>;

SourceLocation

);

SourceLocation

,

ParseOpenACCDeviceTypeList(

SourceLocation

);

ParseOpenACCGangArgList(SourceLocation GangLoc,

OpenACCGangArgRes = std::pair<OpenACCGangKind, ExprResult>;

OpenACCGangArgRes ParseOpenACCGangArg(SourceLocation GangLoc);

SourceLocation &DeclEnd,

ParsedAttributes &AccessAttrs);

ParsingDeclRAIIObject &DiagsFromParams, SourceLocation &DeclEnd,

ParseTemplateParameters(MultiParseScope &TemplateScopes,

Depth,

SmallVectorImpl<NamedDecl *> &TemplateParams,

SourceLocation &LAngleLoc,

SourceLocation &RAngleLoc);

ParseTemplateParameterList(

Depth,

SmallVectorImpl<NamedDecl*> &TemplateParams);

TPResult isStartOfTemplateTypeParameter();

NamedDecl *ParseTemplateParameter(

Depth,

Position);

NamedDecl *ParseTypeParameter(

Depth,

Position);

NamedDecl *ParseTemplateTemplateParameter(

Depth,

Position);

NamedDecl *ParseNonTypeTemplateParameter(

Depth,

Position);

isTypeConstraintAnnotation();

TryAnnotateTypeConstraint();

DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,

SourceLocation CorrectLoc,

AlreadyHasEllipsis,

IdentifierHasName);

DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,

SmallVector<ParsedTemplateArgument, 16> TemplateArgList;

ParseGreaterThanInTemplateList(SourceLocation LAngleLoc,

SourceLocation &RAngleLoc,

ConsumeLastToken,

ObjCGenericList);

ParseTemplateIdAfterTemplateName(

ConsumeLastToken,

SourceLocation &LAngleLoc,

TemplateArgList &TemplateArgs,

SourceLocation &RAngleLoc,

SourceLocation TemplateKWLoc,

UnqualifiedId &TemplateName,

AllowTypeAnnotation =

,

TypeConstraint =

);

AnnotateTemplateIdTokenAsType(CXXScopeSpec &SS,

IsClassName =

);

ParseTemplateArgumentList(TemplateArgList &TemplateArgs,

Template, SourceLocation OpenLoc);

ParsedTemplateArgument ParseTemplateTemplateArgument();

ParsedTemplateArgument ParseTemplateArgument();

SourceLocation ExternLoc,

SourceLocation TemplateLoc,

SourceLocation &DeclEnd,

ParsedAttributes &AccessAttrs,

ParseConceptDefinition(

ParsedTemplateInfo &TemplateInfo,

SourceLocation &DeclEnd);

ParseTypeFromString(StringRef TypeStr, StringRef Context,

SourceLocation IncludeLoc);

*ParseModuleImport(SourceLocation AtLoc,

parseMisplacedModuleImport();

tryParseMisplacedModuleImport() {

(Kind == tok::annot_module_begin || Kind == tok::annot_module_end ||

Kind == tok::annot_module_include)

parseMisplacedModuleImport();

ParseModuleName(

SourceLocation UseLoc,

SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>> &

,

ParseBuiltinPtrauthTypeDiscriminator();

CodeCompleteDirective(

InConditional)

;

CodeCompleteInConditionalExclusion()

;

CodeCompleteMacroName(

IsDefinition)

;

CodeCompletePreprocessorExpression()

;

CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,

ArgumentIndex)

;

CodeCompleteIncludedFile(llvm::StringRef Dir,

IsAngled)

;

CodeCompleteNaturalLanguage()

;

GNUAsmQualifiers {

Qualifiers = AQ_unspecified;

*getQualifierName(AQ Qualifier);

setAsmQualifier(AQ Qualifier);

isVolatile()

{

Qualifiers & AQ_volatile; };

isInline()

{

Qualifiers & AQ_inline; };

isGoto()

{

Qualifiers & AQ_goto; }

isGCCAsmStatement(

Token &TokAfterAsm)

;

isGNUAsmQualifier(

Token &TokAfterAsm)

;

GNUAsmQualifiers::AQ getGNUAsmQualifier(

Token &Tok)

;

parseGNUAsmQualifierListOpt(GNUAsmQualifiers &AQ);

enum clang::sema::@1704::IndirectLocalPathEntry::EntryKind Kind

@ LLVM_MARK_AS_BITMASK_ENUM

Defines some OpenACC-specific enums and functions.

Defines and computes precedence levels for binary/ternary operators.

Defines the clang::Preprocessor interface.

This file declares facilities that support code completion.

This file declares semantic analysis for Objective-C.

This file declares semantic analysis for OpenMP constructs and clauses.

static bool isInvalid(LocType Loc, bool *Invalid)

The result of parsing/analyzing an expression, statement etc.

A factory, from which one makes pools, from which one creates individual attributes which are dealloc...

RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....

Callback handler that receives notifications when performing code completion within the preprocessor.

ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed.

static const TST TST_unspecified

Decl - This represents one declaration (or definition), e.g.

A little helper class used to produce diagnostics.

Concrete class used by the front-end to report problems and issues.

This represents one expression.

One of these records is kept for each identifier that is lexed.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

ObjCContainerDecl - Represents a container for method declarations.

Wrapper for void* pointer.

static OpaquePtr getFromOpaquePtr(void *P)

RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing,...

Introduces zero or more scopes for parsing.

MultiParseScope(Parser &Self)

void Enter(unsigned ScopeFlags)

ParseScope - Introduces a new scope for parsing.

ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope=true, bool BeforeCompoundStmt=false)

Parser - This implements a parser for the C family of languages.

bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind, SmallVectorImpl< Expr * > &Vars, SemaOpenMP::OpenMPVarListDataTy &Data)

Parses clauses with list.

TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeName, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)

ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)

bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, bool IsNewScope, ImplicitTypenameContext AllowImplicitTypename)

Try to annotate a type or scope token, having already parsed an optional scope specifier.

Preprocessor & getPreprocessor() const

bool parseMapTypeModifiers(SemaOpenMP::OpenMPVarListDataTy &Data)

Parses map-type-modifiers in map clause.

Sema::FullExprArg FullExprArg

SourceLocation ConsumeToken()

ConsumeToken - Consume the current 'peek token' and lex the next one.

DeclGroupPtrTy ParseOpenACCDirectiveDecl()

Placeholder for now, should just ignore the directives after emitting a diagnostic.

Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)

AttributeFactory & getAttrFactory()

void incrementMSManglingNumber() const

Sema & getActions() const

static TypeResult getTypeAnnotation(const Token &Tok)

getTypeAnnotation - Read a parsed type out of an annotation token.

ExprResult ParseCaseExpression(SourceLocation CaseLoc)

void EnterScope(unsigned ScopeFlags)

EnterScope - Start a new scope.

bool parseMapperModifier(SemaOpenMP::OpenMPVarListDataTy &Data)

Parses the mapper modifier in map, to, and from clauses.

ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause)

Parse a constraint-logical-or-expression.

ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl< Token > &LineToks, unsigned &NumLineToksConsumed, bool IsUnevaluated)

Parse an identifier in an MS-style inline assembly block.

bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)

Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.

bool TryAnnotateOptionalCXXScopeToken(bool EnteringContext=false)

friend class ColonProtectionRAIIObject

bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))

SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)

ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.

ExprResult ParseConstantExpression()

StmtResult ParseOpenACCDirectiveStmt()

ExprResult ParseConditionalExpression()

bool TryConsumeToken(tok::TokenKind Expected)

friend constexpr SkipUntilFlags operator|(SkipUntilFlags L, SkipUntilFlags R)

OpaquePtr< DeclGroupRef > DeclGroupPtrTy

Scope * getCurScope() const

SourceLocation getEndOfPreviousToken()

ExprResult ParseArrayBoundExpression()

ExprResult ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause)

Parse a constraint-logical-and-expression.

const TargetInfo & getTargetInfo() const

OpaquePtr< TemplateName > TemplateTy

bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))

SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...

void SkipMalformedDecl()

SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...

const Token & getCurToken() const

IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)

Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds to the given nullability kind...

friend class ObjCDeclContextSwitch

bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))

void ExitScope()

ExitScope - Pop a scope off the scope stack.

ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)

Parse an expr that doesn't include (top-level) commas.

ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc, bool IsAddressOfOperand=false)

Parses simple expression in parens for single-expression clauses of OpenMP constructs.

ExprResult ParseConstantExpressionInExprEvalContext(TypeCastState isTypeCast=NotTypeCast)

SourceLocation MisleadingIndentationElseLoc

The location of the first statement inside an else that might have a missleading indentation.

const LangOptions & getLangOpts() const

ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)

Simple precedence-based parser for binary/ternary operators.

bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result, Sema::ModuleImportState &ImportState)

Parse the first top-level declaration in a translation unit.

DiagnosticBuilder Diag(unsigned DiagID)

SmallVector< Stmt *, 32 > StmtVector

A SmallVector of statements.

SkipUntilFlags

Control flags for SkipUntil functions.

@ StopBeforeMatch

Stop skipping at specified token, but don't skip the token itself.

@ StopAtCodeCompletion

Stop at code completion.

@ StopAtSemi

Stop skipping at semicolon.

bool TryAnnotateTypeOrScopeToken(ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)

TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...

bool MightBeCXXScopeToken()

TypeCastState

TypeCastState - State whether an expression is or may be a type cast.

ExprResult ParseUnevaluatedStringLiteralExpression()

ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral=false)

bool ParseOpenMPReservedLocator(OpenMPClauseKind Kind, SemaOpenMP::OpenMPVarListDataTy &Data, const LangOptions &LangOpts)

Parses a reserved locator like 'omp_all_memory'.

ObjCContainerDecl * getObjCDeclContext() const

const Token & NextToken()

NextToken - This peeks ahead one token and returns it without consuming it.

friend class BalancedDelimiterTracker

bool TryConsumeToken(tok::TokenKind Expected, SourceLocation &Loc)

ExprResult ParseConstraintExpression()

Parse a constraint-expression.

SmallVector< TemplateParameterList *, 4 > TemplateParameterLists

void Initialize()

Initialize - Warm up the parser.

unsigned ReenterTemplateScopes(MultiParseScope &S, Decl *D)

Re-enter the template scopes for a declaration that might be a template.

bool TryAnnotateCXXScopeToken(bool EnteringContext=false)

TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...

Activates OpenACC parsing mode to preseve OpenACC specific annotation tokens.

Activates OpenMP parsing mode to preseve OpenMP specific annotation tokens.

Tracks expected type during expression parsing, for use in code completion.

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

void EnterToken(const Token &Tok, bool IsReinject)

Enters a token in the token stream to be lexed next.

void setCodeCompletionReached()

Note that we hit the code-completion point.

bool mightHavePendingAnnotationTokens()

Determine whether it's possible for a future call to Lex to produce an annotation token created by a ...

void Lex(Token &Result)

Lex the next token for this preprocessor.

const Token & LookAhead(unsigned N)

Peeks ahead N tokens and returns that token without consuming any tokens.

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

const TargetInfo & getTargetInfo() const

bool isCodeCompletionEnabled() const

Determine if we are performing code completion.

const LangOptions & getLangOpts() const

SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)

Computes the source location just past the end of the token at this source location.

Scope - A scope is a transient data structure that is used while parsing the program.

ObjCContainerDecl * getObjCDeclContext() const

void startOpenMPLoop()

If the current region is a loop-based region, mark the start of the loop construct.

Sema - This implements semantic analysis and AST building for C.

Scope * getCurScope() const

Retrieve the parser's current scope.

ProcessingContextState ParsingClassState

IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)

Retrieve the keyword associated.

ModuleImportState

An enumeration to represent the transition of states in parsing module fragments and imports.

@ NotACXX20Module

Not a C++20 TU, or an invalid state was found.

void incrementMSManglingNumber() const

Encodes a location in the source.

A trivial tuple used to represent a source range.

Exposes information about the current target.

Represents a C++ template name within the type system.

Token - This structure provides full information about a lexed token.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

void setKind(tok::TokenKind K)

SourceLocation getAnnotationEndLoc() const

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

void * getAnnotationValue() const

tok::TokenKind getKind() const

bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const

bool isNot(tok::TokenKind K) const

bool isAnnotation() const

Return true if this is any of tok::annot_* kind tokens.

void setAnnotationValue(void *val)

@ Decl

The l-value was an access to a declared entity or something equivalently strong, like the address of ...

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

llvm::DenseMap< int, SourceRange > ParsedSubjectMatchRuleSet

bool Pop(InterpState &S, CodePtr OpPC)

bool isStringLiteral(TokenKind K)

Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.

ObjCKeywordKind

Provides a namespace for Objective-C keywords which start with an '@'.

TokenKind

Provides a simple uniform namespace for tokens from all C languages.

The JSON file list parser is used to communicate input to InstallAPI.

llvm::omp::Directive OpenMPDirectiveKind

OpenMP directives.

NullabilityKind

Describes the nullability of a particular type.

OpenACCClauseKind

Represents the kind of an OpenACC clause.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

llvm::omp::Clause OpenMPClauseKind

OpenMP clauses.

ActionResult< CXXCtorInitializer * > MemInitResult

@ Result

The result type of a method or function.

ActionResult< Expr * > ExprResult

ActionResult< Stmt * > StmtResult

TemplateNameKind

Specifies the kind of template name that an identifier refers to.

ActionResult< ParsedType > TypeResult

OpaquePtr< QualType > ParsedType

An opaque type for threading parsed type information through the parser.

const FunctionProtoType * T

@ Incomplete

Template argument deduction did not deduce a value for every template parameter.

SmallVector< Token, 4 > CachedTokens

A set of tokens that has been cached for later parsing.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

ExceptionSpecificationType

The various types of exception specifications that exist in C++11.

ActionResult< CXXBaseSpecifier * > BaseResult

AccessSpecifier

A C++ access specifier (public, private, protected), plus the special value "none" which means differ...

unsigned short BracketCount

unsigned short BraceCount

AngleBracketTracker::Priority Priority

bool isActive(Parser &P) const

unsigned short ParenCount

bool isActiveOrNested(Parser &P) const

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4