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

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

clang: lib/Parse/ParseExprCXX.cpp Source File

;

tok::unknown:

0;

tok::kw_addrspace_cast:

1;

tok::kw_const_cast:

2;

tok::kw_dynamic_cast:

3;

tok::kw_reinterpret_cast:

4;

tok::kw_static_cast:

5;

llvm_unreachable(

);

Parser::areTokensAdjacent(

&

,

&Second) {

FirstEnd ==

.getSpellingLoc(Second.

());

PP.

(DigraphToken);

.Diag(DigraphToken.

(), diag::err_missing_whitespace_digraph)

ColonToken.

(tok::coloncolon);

DigraphToken.

(tok::less);

Parser::CheckForTemplateAndDigraph(

&Next,

ObjectType,

(!Next.is(tok::l_square) || Next.getLength() != 2)

SecondToken = GetLookAheadToken(2);

(!SecondToken.

(tok::colon) || !areTokensAdjacent(Next, SecondToken))

MemberOfUnknownSpecialization;

Template, MemberOfUnknownSpecialization))

(*

, PP, Next, SecondToken, tok::unknown,

Parser::ParseOptionalCXXScopeSpecifier(

EnteringContext,

*MayBePseudoDestructor,

IsTypename,

**LastII,

OnlyNamespace,

InUsingDeclaration,

Disambiguation) {

);

(Tok.

(tok::annot_cxxscope)) {

assert(!LastII &&

);

assert(!MayBePseudoDestructor &&

);

ConsumeAnnotationToken();

CheckForDestructor =

;

(MayBePseudoDestructor && *MayBePseudoDestructor) {

CheckForDestructor =

;

*MayBePseudoDestructor =

;

HasScopeSpecifier =

;

(Tok.

(tok::coloncolon)) {

(NextKind == tok::kw_new || NextKind == tok::kw_delete)

(NextKind == tok::l_brace) {

HasScopeSpecifier =

;

(Tok.

(tok::kw___super)) {

(!Tok.

(tok::coloncolon)) {

(!HasScopeSpecifier &&

Tok.

(tok::kw_decltype, tok::annot_decltype)) {

AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);

HasScopeSpecifier =

;

(!HasScopeSpecifier && Tok.

(tok::identifier) &&

GetLookAheadToken(1).is(tok::ellipsis) &&

GetLookAheadToken(2).is(tok::l_square) &&

!GetLookAheadToken(3).is(tok::r_square)) {

DS.getRepAsType().get(), DS.getPackIndexingExpr(), DS.getBeginLoc(),

DS.getEllipsisLoc());

(Start, diag::warn_pre_cxx26_ambiguous_pack_indexing_type) <<

;

HasScopeSpecifier =

;

SavedType = PreferredType;

(HasScopeSpecifier) {

(Tok.

(tok::code_completion)) {

(), SS, EnteringContext, InUsingDeclaration,

ObjectType =

;

(Tok.

(tok::kw_template)) {

(!HasScopeSpecifier && !ObjectType)

TentativeParsingAction TPA(*

);

(Tok.

(tok::identifier)) {

}

(Tok.

(tok::kw_operator)) {

(ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,

diag::err_id_after_template_in_nested_name_spec)

(Tok.

(tok::less)) {

EnteringContext, Template,

);

(AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,

(Tok.

(tok::annot_template_id) &&

().is(tok::coloncolon)) {

(CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {

*MayBePseudoDestructor =

;

*LastII = TemplateId->

;

ConsumeAnnotationToken();

assert(Tok.

(tok::coloncolon) &&

);

HasScopeSpecifier =

;

Tok.

(tok::identifier);

(Tok, diag::ext_keyword_as_ident)

(Tok.

(tok::identifier))

(Next.is(tok::colon) && !ColonIsSacred) {

(Next, diag::err_unexpected_colon_in_nested_name_spec)

Next.setKind(tok::coloncolon);

(Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {

(Next.is(tok::coloncolon)) {

(CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {

*MayBePseudoDestructor =

;

&Next2 = GetLookAheadToken(2);

(Next2.

(tok::kw_private) || Next2.

(tok::kw_protected) ||

Next2.

(tok::kw_public) || Next2.

(tok::kw_virtual)) {

(Next2, diag::err_unexpected_token_in_nested_name_spec)

PP.

(ColonColon);

ColonColon.

(tok::colon);

assert(Tok.

(tok::coloncolon, tok::colon) &&

);

ColonColon = Tok;

IsCorrectedToColon =

;

*CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon :

;

(), IdInfo, EnteringContext, SS, CorrectionFlagPtr,

(CorrectionFlagPtr && IsCorrectedToColon) {

ColonColon.

(tok::colon);

HasScopeSpecifier =

;

CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);

(Next.is(tok::less)) {

MemberOfUnknownSpecialization;

EnteringContext, Template, MemberOfUnknownSpecialization,

isTemplateArgumentList(1) == TPResult::False)

(MemberOfUnknownSpecialization && !Disambiguation &&

(ObjectType || SS.

()) &&

(IsTypename || isTemplateArgumentList(1) == TPResult::True)) {

(!ObjectHadErrors) {

DiagID = diag::err_missing_dependent_template_keyword;

DiagID = diag::warn_missing_dependent_template_keyword;

EnteringContext, Template,

);

(CheckForDestructor && !HasScopeSpecifier && Tok.

(tok::tilde))

*MayBePseudoDestructor =

;

isAddressOfOperand,

&Replacement) {

tok::annot_non_type: {

*ND = getNonTypeAnnotation(Tok);

tok::annot_non_type_dependent: {

(isAddressOfOperand && isPostfixExpressionSuffixStart())

isAddressOfOperand =

;

tok::annot_non_type_undeclared: {

);

, &TemplateKWLoc, Name))

(isAddressOfOperand && isPostfixExpressionSuffixStart())

isAddressOfOperand =

;

(), SS, TemplateKWLoc, Name, Tok.

(tok::l_paren),

isAddressOfOperand,

,

,

= tryParseCXXPackIndexingExpression(

);

(!

.isInvalid() && !

.isUnset() && Tok.

(tok::less))

checkPotentialAngleBracket(

);

assert(Tok.

(tok::ellipsis) &&

().is(tok::l_square) &&

(

.consumeClose() || IndexExpr.

())

EllipsisLoc,

.getOpenLocation(),

IndexExpr.

(),

.getCloseLocation());

Parser::tryParseCXXPackIndexingExpression(

PackIdExpression) {

Tok.

(tok::ellipsis) &&

().is(tok::l_square)) {

= ParseCXXPackIndexingExpression(

);

Parser::ParseCXXIdExpression(

isAddressOfOperand) {

ParseOptionalCXXScopeSpecifier(SS,

,

tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);

UnconsumeToken(Replacement);

= tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);

assert(!

.isUnset() &&

);

(ParseLambdaIntroducer(Intro)) {

ParseLambdaExpressionAfterIntroducer(Intro);

Parser::TryParseLambdaExpression() {

);

(Next.is(tok::eof))

(Next.is(tok::r_square) ||

Next.is(tok::equal) ||

(Next.is(tok::amp) &&

.isOneOf(tok::r_square, tok::comma)) ||

(Next.is(tok::identifier) &&

.is(tok::r_square)) ||

Next.is(tok::ellipsis)) {

ParseLambdaExpression();

(Next.is(tok::identifier) &&

.is(tok::identifier))

TentativeParsingAction TPA(*

);

LambdaIntroducerTentativeParse Tentative;

(ParseLambdaIntroducer(Intro, &Tentative)) {

LambdaIntroducerTentativeParse::Success:

LambdaIntroducerTentativeParse::Incomplete:

(ParseLambdaIntroducer(Intro))

LambdaIntroducerTentativeParse::MessageSend:

LambdaIntroducerTentativeParse::Invalid:

ParseLambdaExpressionAfterIntroducer(Intro);

LambdaIntroducerTentativeParse *Tentative) {

*Tentative = LambdaIntroducerTentativeParse::Success;

assert(Tok.

(tok::l_square) &&

);

= [&](llvm::function_ref<void()> Action) {

*Tentative = LambdaIntroducerTentativeParse::Invalid;

NonTentativeAction = [&](llvm::function_ref<void()> Action) {

*Tentative = LambdaIntroducerTentativeParse::Incomplete;

(Tok.

(tok::amp) &&

Tentative =

;

}

(Tok.

(tok::equal)) {

Tentative =

;

(Tok.

(tok::r_square)) {

(Tok.

(tok::comma)) {

(Tok.

(tok::code_completion) &&

(Tok.

(tok::code_completion)) {

(Tok.

(tok::star)) {

(Tok.

(tok::kw_this)) {

}

(Tok.

(tok::kw_this)) {

}

(Tok.

(tok::amp, tok::equal) &&

[&] {

(Tok.

(), diag::err_capture_default_first); });

(Tok.

(tok::amp)) {

(Tok.

(tok::code_completion)) {

(Tok.

(tok::identifier)) {

}

(Tok.

(tok::kw_this)) {

(Tok.

(tok::l_paren)) {

*Tentative = LambdaIntroducerTentativeParse::Incomplete;

}

(ParseExpressionList(Exprs)) {

.getCloseLocation(),

}

(Tok.

(tok::l_brace, tok::equal)) {

= ParseInitializer();

}

(Tok.

(tok::l_brace)) {

*Tentative = LambdaIntroducerTentativeParse::Incomplete;

= ParseInitializer();

(!

.isInvalid())

Tok.

(tok::annot_primary_expr);

setExprAnnotation(Tok,

);

ConsumeAnnotationToken();

(Tentative && Tok.

(tok::identifier) &&

*Tentative = LambdaIntroducerTentativeParse::MessageSend;

(llvm::any_of(EllipsisLocs,

!InitCapture ? &EllipsisLocs[2] :

EllipsisLoc = *ExpectedEllipsisLoc;

DiagID = 0;

DiagID = diag::err_lambda_capture_misplaced_ellipsis;

NumEllipses = std::accumulate(

std::begin(EllipsisLocs), std::end(EllipsisLocs), 0,

(NumEllipses > 1)

DiagID = diag::err_lambda_capture_multiple_ellipses;

NonTentativeAction([&] {

assert(DiagLoc.

() &&

);

&&

=

(DiagLoc, DiagID);

(DiagID == diag::err_lambda_capture_misplaced_ellipsis) {

(

.isUsable())

(

.isUsable()) {

NonTentativeAction([&] {

ConsumeLocation = [&

, &DeclEndLoc](

&SpecifierLoc,

(SpecifierLoc.isValid()) {

.Diag(

.getCurToken().getLocation(),

diag::err_lambda_decl_specifier_repeated)

SpecifierLoc =

.ConsumeToken();

DeclEndLoc = SpecifierLoc;

(

.getCurToken().getKind()) {

tok::kw_mutable:

ConsumeLocation(MutableLoc, 0);

tok::kw_static:

ConsumeLocation(StaticLoc, 1);

tok::kw_constexpr:

ConsumeLocation(ConstexprLoc, 2);

tok::kw_consteval:

ConsumeLocation(ConstevalLoc, 3);

.Diag(StaticLoc, !

.getLangOpts().CPlusPlus23

? diag::err_static_lambda

: diag::warn_cxx20_compat_static_lambda);

*PrevSpec =

;

DiagID = 0;

.getActions().getASTContext().getPrintingPolicy());

assert(PrevSpec ==

&& DiagID == 0 &&

);

(ConstexprLoc.

()) {

.Diag(ConstexprLoc, !

.getLangOpts().CPlusPlus17

? diag::ext_constexpr_on_lambda_cxx17

: diag::warn_cxx14_compat_constexpr_on_lambda);

*PrevSpec =

;

DiagID = 0;

assert(PrevSpec ==

&& DiagID == 0 &&

);

(ConstevalLoc.

()) {

.Diag(ConstevalLoc, diag::warn_cxx20_compat_consteval);

*PrevSpec =

;

DiagID = 0;

.Diag(ConstevalLoc, DiagID) << PrevSpec;

.Diag(StaticLoc, diag::err_static_mutable_lambda);

.Diag(StaticLoc, diag::err_static_lambda_captures);

Parser::ParseLambdaExpressionAfterIntroducer(

(LambdaBeginLoc, diag::ext_hlsl_lambda) <<

1;

? diag::warn_cxx98_compat_lambda

);

TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);

(Tok.

(tok::kw___noinline__)) {

Attributes.addNew(AttrName, AttrNameLoc,

,

AttrNameLoc,

,

0, tok::kw___noinline__);

}

(Tok.

(tok::kw___attribute))

ParseGNUAttributes(Attributes,

, &

);

.takeAttributes(Attributes);

MultiParseScope TemplateParamScope(*

);

(Tok.

(tok::less)) {

? diag::warn_cxx17_compat_lambda_template_parameter_list

: diag::ext_lambda_template_parameter_list);

(ParseTemplateParameters(TemplateParamScope,

CurTemplateDepthTracker.getDepth(),

TemplateParams, LAngleLoc, RAngleLoc)) {

(TemplateParams.empty()) {

diag::err_lambda_template_parameter_list_empty);

++CurTemplateDepthTracker;

Intro, LAngleLoc, TemplateParams, RAngleLoc, RequiresClause);

(isCXX11AttributeSpecifier()) {

? diag::warn_cxx20_compat_decl_attrs_on_lambda

: diag::ext_decl_attrs_on_lambda)

MaybeParseCXX11Attributes(

);

HasParentheses =

;

HasSpecifiers =

;

(Tok.

(tok::l_paren)) {

LParenLoc =

.getOpenLocation();

(Tok.

(tok::r_paren)) {

CurTemplateDepthTracker.getOriginalDepth());

ParseParameterDeclarationClause(

, Attributes, ParamInfo, EllipsisLoc);

CurTemplateDepthTracker.setAddedDepth(1);

DeclEndLoc = RParenLoc =

.getCloseLocation();

HasParentheses =

;

Tok.

(tok::kw_mutable, tok::arrow, tok::kw___attribute,

tok::kw_constexpr, tok::kw_consteval, tok::kw_static,

tok::kw___private, tok::kw___global, tok::kw___local,

tok::kw___constant, tok::kw___generic, tok::kw_groupshared,

tok::kw_requires, tok::kw_noexcept) ||

(Tok.

(tok::l_square) &&

().

(tok::l_square));

(HasSpecifiers && !HasParentheses && !

().CPlusPlus23) {

(Tok, diag::ext_lambda_missing_parens)

(HasParentheses || HasSpecifiers) {

MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attributes);

ConstevalLoc, DeclEndLoc);

(!HasParentheses)

(HasSpecifiers || HasParentheses) {

ESpecType = tryParseExceptionSpecification(

, ESpecRange, DynamicExceptions,

DynamicExceptionRanges, NoexceptExpr, ExceptionSpecTokens);

DeclEndLoc = ESpecRange.

();

(MaybeParseCXX11Attributes(Attributes))

DeclEndLoc = Attributes.Range.getEnd();

(Tok.

(tok::kw___private, tok::kw___global, tok::kw___local,

tok::kw___constant, tok::kw___generic)) {

ParseOpenCLQualifiers(DS.getAttributes());

(Tok.

(tok::arrow)) {

TrailingReturnType =

ParseTrailingReturnType(

,

);

, LParenLoc, ParamInfo.data(),

ParamInfo.size(), EllipsisLoc, RParenLoc,

NoLoc, MutableLoc, ESpecType,

ESpecRange, DynamicExceptions.data(),

DynamicExceptionRanges.data(), DynamicExceptions.size(),

NoexceptExpr.

() ? NoexceptExpr.

() :

,

{}, LParenLoc, FunLocalRangeEnd,

,

TrailingReturnType, TrailingReturnTypeLoc, &DS),

std::move(Attributes), DeclEndLoc);

(HasParentheses && Tok.

(tok::kw_requires))

ParseTrailingRequiresClause(

);

(A.getKind() == ParsedAttr::AT_CUDADevice ||

A.getKind() == ParsedAttr::AT_CUDAHost ||

A.getKind() == ParsedAttr::AT_CUDAGlobal)

(A.getLoc(), diag::warn_cuda_attr_lambda_position)

<< A.getAttrName()->getName();

ParseScope BodyScope(

, ScopeFlags);

(!Tok.

(tok::l_brace)) {

(Tok, diag::err_expected_lambda_body);

TemplateParamScope.Exit();

(!

.isInvalid() && !TrailingReturnType.

() &&

!

.isInvalidType())

*CastName =

;

: llvm_unreachable(

);

tok::kw_addrspace_cast: CastName =

;

;

tok::kw_const_cast: CastName =

;

;

tok::kw_dynamic_cast: CastName =

;

;

tok::kw_reinterpret_cast: CastName =

;

;

tok::kw_static_cast: CastName =

;

;

(Tok.

(tok::l_square) && Tok.

() == 2) {

(Next.is(tok::colon) && areTokensAdjacent(Tok, Next))

(*

, PP, Tok, Next, Kind,

);

(ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))

ParseSpecifierQualifierList(DS,

,

DeclSpecContext::DSC_type_specifier);

ParseDeclarator(DeclaratorInfo);

(ExpectAndConsume(tok::greater))

(

(LAngleBracketLoc, diag::note_matching) << tok::less);

(

.expectAndConsume(diag::err_expected_lparen_after, CastName))

(!

.isInvalid() && !DeclaratorInfo.isInvalidType())

LAngleBracketLoc, DeclaratorInfo,

.getOpenLocation(),

.get(),

.getCloseLocation());

assert(Tok.

(tok::kw_typeid) &&

);

(

.expectAndConsume(diag::err_expected_lparen_after,

))

LParenLoc =

.getOpenLocation();

(isTypeIdInParens()) {

RParenLoc =

.getCloseLocation();

Ty.

().getAsOpaquePtr(), RParenLoc);

(

.isInvalid())

RParenLoc =

.getCloseLocation();

.get(), RParenLoc);

assert(Tok.

(tok::kw___uuidof) &&

);

(

.expectAndConsume(diag::err_expected_lparen_after,

))

(isTypeIdInParens()) {

Ty.

().getAsOpaquePtr(),

.getCloseLocation());

(

.isInvalid())

.get(),

.getCloseLocation());

(Tok.

(tok::identifier)) {

assert(Tok.

(tok::coloncolon) &&

);

}

(Tok.

(tok::annot_template_id)) {

ConsumeAnnotationToken();

assert(Tok.

(tok::coloncolon) &&

);

assert(SS.

() &&

);

assert(Tok.

(tok::tilde) &&

);

(Tok.

(tok::kw_decltype) && !FirstTypeName.

()) {

ParseDecltypeSpecifier(DS);

(!Tok.

(tok::identifier)) {

(Tok, diag::err_destructor_tilde_identifier);

(GetLookAheadToken(1).is(tok::ellipsis) &&

GetLookAheadToken(2).is(tok::l_square)) {

ParsePackIndexingType(DS);

(Tok.

(tok::less) &&

ParseUnqualifiedIdTemplateId(

Name, NameLoc,

, SecondTypeName,

SS, FirstTypeName, CCLoc, TildeLoc,

assert(Tok.

(tok::kw_throw) &&

);

(

.isInvalid())

;

assert(Tok.

(tok::kw_co_yield) &&

);

(!

.isInvalid())

assert(Tok.

(tok::kw_this) &&

);

Parser::ParseCXXTypeConstructExpression(

&DS) {

assert((Tok.

(tok::l_paren) ||

&&

);

(Tok.

(tok::l_brace)) {

(

.isInvalid())

RunSignatureHelp = [&]() {

Exprs,

.getOpenLocation(),

);

CalledSignatureHelp =

;

PreferredType;

(Tok.

(tok::r_paren)) {

(ParseExpressionList(Exprs, [&] {

PreferredType.enterFunctionArgument(Tok.

(),

Exprs,

.getCloseLocation(),

assert(Tok.

(tok::kw_using) &&

);

);

DG = ParseUsingDeclaration(Context, {}, DeclStart, DeclEnd, Attrs,

);

? diag::ext_alias_in_init_statement

: diag::warn_cxx20_alias_in_init_statement)

ForRangeInfo *FRI,

EnterForConditionScope) {

ForConditionScopeRAII {

enter(

IsConditionVariable) {

S->setIsConditionVarScope(IsConditionVariable);

~ForConditionScopeRAII() {

S->setIsConditionVarScope(

);

} ForConditionScope{EnterForConditionScope ?

() : nullptr};

PreferredType.enterCondition(Actions, Tok.

());

(Tok.

(tok::code_completion)) {

MaybeParseCXX11Attributes(attrs);

WarnOnInit = [

, &CK] {

? diag::warn_cxx14_compat_init_statement

: diag::ext_init_statement)

(isCXXConditionDeclarationOrInitStatement(InitStmt, FRI)) {

ConditionOrInitStatement::Expression: {

ForConditionScope.enter(

);

ProhibitAttributes(attrs);

(InitStmt && Tok.

(tok::semi)) {

(SemiLoc, diag::warn_empty_init_statement)

ParseCXXCondition(

,

, CK, MissingOK);

(

.isInvalid())

(InitStmt && Tok.

(tok::semi)) {

ParseCXXCondition(

,

, CK, MissingOK);

ConditionOrInitStatement::InitStmtDecl: {

(Tok.

(tok::kw_using))

DG = ParseAliasDeclarationInInitStatement(

attrs, DeclSpecAttrs,

);

*InitStmt = Actions.

(DG, DeclStart, DeclEnd);

ParseCXXCondition(

,

, CK, MissingOK);

ConditionOrInitStatement::ForRangeDecl: {

assert(FRI &&

);

ConditionOrInitStatement::ConditionDecl:

ConditionOrInitStatement::Error:

ForConditionScope.enter(

);

ParseSpecifierQualifierList(DS,

, DeclSpecContext::DSC_condition);

ParseDeclarator(DeclaratorInfo);

(Tok.

(tok::kw_asm)) {

(AsmLabel.isInvalid()) {

DeclaratorInfo.setAsmLabel(AsmLabel.get());

DeclaratorInfo.SetRangeEnd(

);

MaybeParseGNUAttributes(DeclaratorInfo);

CopyInitialization = isTokenEqualOrEqualTypo();

(CopyInitialization)

diag::warn_cxx98_compat_generalized_initializer_lists);

InitExpr = ParseBraceInitializer();

}

(CopyInitialization) {

PreferredType.enterVariableInit(Tok.

(), DeclOut);

}

(Tok.

(tok::l_paren)) {

RParen = ConsumeParen();

diag::err_expected_init_in_condition_lparen)

(DeclOut->

(), diag::err_expected_init_in_condition);

Parser::ParseCXXSimpleTypeSpecifier(

&DS) {

*PrevSpec;

tok::identifier:

tok::coloncolon:

llvm_unreachable(

);

llvm_unreachable(

);

tok::annot_typename: {

ConsumeAnnotationToken();

DS.

(Actions, Policy);

tok::kw__ExtInt:

tok::kw__BitInt: {

DiagnoseBitIntUse(Tok);

DS.

(Actions, Policy);

tok::kw___int64:

tok::kw_signed:

tok::kw_unsigned:

tok::kw___int128:

tok::kw___bf16:

tok::kw_double:

tok::kw__Float16:

tok::kw___float128:

tok::kw___ibm128:

tok::kw_wchar_t:

tok::kw_char8_t:

tok::kw_char16_t:

tok::kw_char32_t:

tok::kw__Accum:

tok::kw__Fract:

tok::annot_decltype:

tok::kw_decltype:

DS.

(Actions, Policy);

tok::annot_pack_indexing_type:

DS.

(Actions, Policy);

tok::kw_typeof:

ParseTypeofSpecifier(DS);

DS.

(Actions, Policy);

DS.

(Actions, Policy);

ParseSpecifierQualifierList(DS,

,

getDeclSpecContextFromDeclaratorContext(Context));

Parser::ParseUnqualifiedIdTemplateId(

assert(Tok.

(tok::less) &&

);

(

.getKind()) {

(AssumeTemplateId) {

ObjectType, EnteringContext, Template,

MemberOfUnknownSpecialization;

ObjectType, EnteringContext, Template,

MemberOfUnknownSpecialization);

isTemplateArgumentList(0) == TPResult::False)

ObjectType && isTemplateArgumentList(0) == TPResult::True) {

(!ObjectHadErrors) {

Name = std::string(

.Identifier->getName());

Name =

;

Name +=

.Identifier->getName();

(

.StartLocation, diag::err_missing_dependent_template_keyword)

(), SS, TemplateKWLoc,

, ObjectType, EnteringContext,

MemberOfUnknownSpecialization;

EnteringContext, Template,

MemberOfUnknownSpecialization);

MemberOfUnknownSpecialization;

EnteringContext, Template,

);

EnteringContext, Template,

MemberOfUnknownSpecialization);

(NameLoc, diag::err_destructor_template_id)

TemplateArgList TemplateArgs;

(ParseTemplateIdAfterTemplateName(

, LAngleLoc, TemplateArgs, RAngleLoc,

:

.OperatorFunctionId.Operator;

TemplateKWLoc,

.StartLocation, TemplateII, OpKind, Template, TNK,

LAngleLoc, RAngleLoc, TemplateArgs,

, TemplateIds);

.setTemplateId(TemplateId);

(), SS, TemplateKWLoc, Template, Name, NameLoc, LAngleLoc,

TemplateArgsPtr, RAngleLoc,

);

(

.isInvalid())

.setConstructorName(

.get(), NameLoc, RAngleLoc);

.setDestructorName(

.StartLocation,

.get(), RAngleLoc);

Parser::ParseUnqualifiedIdOperator(

&SS,

EnteringContext,

assert(Tok.

(tok::kw_operator) &&

);

SymbolIdx = 0;

tok::kw_delete: {

isNew = Tok.

() == tok::kw_new;

(Tok.

(tok::l_square) &&

(

.getCloseLocation().isInvalid())

SymbolLocations[SymbolIdx++] =

.getOpenLocation();

SymbolLocations[SymbolIdx++] =

.getCloseLocation();

Op = isNew? OO_Array_New : OO_Array_Delete;

Op = isNew? OO_New : OO_Delete;

tok::l_paren: {

(

.getCloseLocation().isInvalid())

SymbolLocations[SymbolIdx++] =

.getOpenLocation();

SymbolLocations[SymbolIdx++] =

.getCloseLocation();

tok::l_square: {

(

.getCloseLocation().isInvalid())

SymbolLocations[SymbolIdx++] =

.getOpenLocation();

SymbolLocations[SymbolIdx++] =

.getCloseLocation();

tok::code_completion: {

.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);

DiagId = 0;

(isTokenStringLiteral()) {

(!Tok.

(tok::string_literal) && !DiagId) {

DiagId = diag::err_literal_operator_string_prefix;

Toks.push_back(Tok);

TokLocs.push_back(ConsumeStringToken());

IsUDSuffix = !

.getUDSuffix().empty();

}

(Tok.

(tok::identifier)) {

TokLocs.push_back(SuffixLoc);

DiagLoc = TokLocs.front();

DiagId = diag::err_literal_operator_string_not_empty;

(TokLocs.front(), TokLocs.back()), Str);

.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);

(ParseCXXTypeSpecifierSeq(

ParseDeclaratorInternal(

,

);

.setConversionFunctionId(KeywordLoc, Ty.

(),

ObjectHadErrors,

EnteringContext,

AllowDestructorName,

AllowConstructorName,

AllowDeductionGuide,

TemplateSpecified =

;

(Tok.

(tok::kw_template)) {

(TemplateKWLoc && (ObjectType || SS.

())) {

TemplateSpecified =

;

(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)

(Tok.

(tok::identifier)) {

.setIdentifier(

, IdLoc);

(AllowConstructorName &&

.setConstructorName(Ty, IdLoc, IdLoc);

.setIdentifier(

, IdLoc);

(Tok.

(tok::less))

ParseUnqualifiedIdTemplateId(

SS, ObjectType, ObjectHadErrors,

EnteringContext,

, TemplateSpecified);

(TemplateSpecified) {

ObjectType, EnteringContext, Template,

!Tok.

(tok::less))

(IdLoc, diag::missing_template_arg_list_after_template_kw);

(Tok.

(tok::annot_template_id)) {

ConsumeAnnotationToken();

(AllowConstructorName && TemplateId->

&&

diag::err_out_of_line_constructor_template_id)

<< TemplateId->

ConsumeAnnotationToken();

.setConstructorTemplateId(TemplateId);

ConsumeAnnotationToken();

.setTemplateId(TemplateId);

(TemplateLoc.

()) {

(TemplateKWLoc && (ObjectType || SS.

()))

*TemplateKWLoc = TemplateLoc;

(TemplateLoc, diag::err_unexpected_template_in_unqualified_id)

ConsumeAnnotationToken();

(Tok.

(tok::kw_operator)) {

(ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,

))

Tok.

(tok::less))

ParseUnqualifiedIdTemplateId(

SS, ObjectType, ObjectHadErrors,

(TemplateSpecified &&

EnteringContext, Template,

(AllowDestructorName || SS.

()) && Tok.

(tok::tilde)) {

(TemplateSpecified) {

(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name)

(SS.

() && Tok.

(tok::kw_decltype)) {

.setDestructorName(TildeLoc,

, EndLoc);

(Tok.

(tok::identifier)) {

(Tok, diag::err_destructor_tilde_identifier);

DeclaratorScopeObj DeclScopeObj(*

, SS);

(

().is(tok::coloncolon)) {

AnnotateScopeToken(SS,

);

(ParseOptionalCXXScopeSpecifier(SS, ObjectType, ObjectHadErrors,

ObjectType =

;

(Tok.

(tok::identifier) ||

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

(TildeLoc, diag::err_destructor_tilde_scope);

(TildeLoc, diag::err_destructor_tilde_scope)

DeclScopeObj.EnterDeclaratorScope();

(Tok.

(tok::less)) {

.setDestructorName(TildeLoc,

, ClassNameLoc);

ParseUnqualifiedIdTemplateId(

SS, ObjectType, ObjectHadErrors,

ClassNameLoc, EnteringContext,

, TemplateSpecified);

ObjectType, EnteringContext);

.setDestructorName(TildeLoc, Ty, ClassNameLoc);

Tok.

(tok::identifier);

(Tok, diag::ext_keyword_as_ident)

ParseIdentifier;

(Tok, diag::err_expected_unqualified_id) <<

().CPlusPlus;

Parser::ParseCXXNewExpression(

UseGlobal,

Start) {

assert(Tok.

(tok::kw_new) &&

);

ExprVector PlacementArgs;

(Tok.

(tok::l_paren)) {

PlacementLParen =

.getOpenLocation();

(ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {

PlacementRParen =

.getCloseLocation();

(PlacementArgs.empty()) {

TypeIdParens =

.getRange();

(Tok.

(tok::l_paren)) {

MaybeParseGNUAttributes(DeclaratorInfo);

ParseSpecifierQualifierList(DS);

ParseDeclarator(DeclaratorInfo);

TypeIdParens =

.getRange();

MaybeParseGNUAttributes(DeclaratorInfo);

(ParseCXXTypeSpecifierSeq(DS))

DeclaratorInfo.setInvalidType(

);

ParseDeclaratorInternal(DeclaratorInfo,

&Parser::ParseDirectNewDeclarator);

MaybeParseGNUAttributes(DeclaratorInfo);

DeclaratorInfo.setInvalidType(

);

ParseDeclaratorInternal(DeclaratorInfo,

&Parser::ParseDirectNewDeclarator);

(DeclaratorInfo.isInvalidType()) {

(Tok.

(tok::l_paren)) {

ExprVector ConstructorArgs;

ConstructorLParen =

.getOpenLocation();

(Tok.

(tok::r_paren)) {

RunSignatureHelp = [&]() {

DeclaratorInfo.getEndLoc(), ConstructorArgs,

CalledSignatureHelp =

;

PreferredType;

(ParseExpressionList(ConstructorArgs, [&] {

PreferredType.enterFunctionArgument(Tok.

(),

ConstructorRParen =

.getCloseLocation();

diag::warn_cxx98_compat_generalized_initializer_lists);

Actions.

(Start, UseGlobal, PlacementLParen,

PlacementArgs, PlacementRParen,

TypeIdParens, DeclaratorInfo,

.get());

Parser::ParseDirectNewDeclarator(

&

) {

(Tok.

(tok::l_square)) {

(CheckProhibitedCXX11Attribute())

(

.isInvalid()) {

MaybeParseCXX11Attributes(Attrs);

.get(),

.getOpenLocation(),

.getCloseLocation()),

std::move(Attrs),

.getCloseLocation());

(

.getCloseLocation().isInvalid())

Parser::ParseExpressionListOrTypeId(

(isTypeIdInParens()) {

ParseSpecifierQualifierList(

.getMutableDeclSpec());

ParseDeclarator(

);

.isInvalidType();

ParseExpressionList(PlacementArgs);

Parser::ParseCXXDeleteExpression(

UseGlobal,

Start) {

assert(Tok.

(tok::kw_delete) &&

);

ArrayDelete =

;

(Tok.

(tok::l_square) &&

().is(tok::r_square)) {

Next = GetLookAheadToken(2);

(Next.isOneOf(tok::l_brace, tok::less) ||

(Next.is(tok::l_paren) &&

(GetLookAheadToken(3).is(tok::r_paren) ||

(GetLookAheadToken(3).is(tok::identifier) &&

GetLookAheadToken(4).is(tok::identifier))))) {

TentativeParsingAction TPA(*

);

EmitFixIt =

;

(Tok.

(tok::l_brace)) {

(Start, diag::err_lambda_after_delete)

(Start, diag::err_lambda_after_delete)

Lambda = ParsePostfixExpressionSuffix(Lambda);

ArrayDelete =

;

(

.getCloseLocation().isInvalid())

Parser::ParseRequiresExpression() {

assert(Tok.

(tok::kw_requires) &&

);

(Tok.

(tok::l_paren)) {

(!Tok.

(tok::r_paren)) {

FirstArgAttrs, LocalParameters,

(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);

(

&ParamInfo : LocalParameters)

LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));

(

.expectAndConsume())

RequiresKWLoc, LocalParameterDecls,

());

(Tok.

(tok::r_brace)) {

(Tok, diag::err_empty_requires_expr);

(!Tok.

(tok::r_brace)) {

tok::l_brace: {

ExprBraces.consumeOpen();

ExprBraces.skipToEnd();

(ExprBraces.consumeClose())

ExprBraces.skipToEnd();

(Tok.

(tok::semi)) {

Requirements.push_back(Req);

(Tok, diag::err_requires_expr_missing_arrow)

(TryAnnotateTypeConstraint()) {

(!isTypeConstraintAnnotation()) {

(Tok, diag::err_requires_expr_expected_type_constraint);

(Tok.

(tok::annot_cxxscope)) {

ConsumeAnnotationToken();

.get(), NoexceptLoc, SS, takeTemplateIdAnnotation(Tok),

TemplateParameterDepth);

ConsumeAnnotationToken();

Requirements.push_back(Req);

PossibleRequiresExprInSimpleRequirement =

;

(Tok.

(tok::kw_requires)) {

IsNestedRequirement = [&] {

RevertingTentativeParsingAction TPA(*

);

(Tok.

(tok::l_brace))

(Tok.

(tok::l_paren)) {

Res = TryParseParameterDeclarationClause();

(Res != TPResult::False) {

(Depth != 0) {

FoundParen =

(tok::l_paren, tok::r_paren,

(Tok.

(tok::l_paren))

(Tok.

(tok::r_paren))

(Tok.

(tok::l_brace))

(IsNestedRequirement()) {

Requirements.push_back(Req);

PossibleRequiresExprInSimpleRequirement =

;

}

(Tok.

(tok::kw_typename)) {

TentativeParsingAction TPA(*

);

(Tok.

(tok::annot_cxxscope)) {

ConsumeAnnotationToken();

(Tok.

(tok::identifier, tok::annot_template_id) &&

(Tok.

(tok::identifier)) {

TemplateId = takeTemplateIdAnnotation(Tok);

ConsumeAnnotationToken();

Requirements.push_back(Req);

(!

.isInvalid() && PossibleRequiresExprInSimpleRequirement)

(StartLoc, diag::err_requires_expr_in_simple_requirement)

Requirements.push_back(Req);

(Tok.

(tok::kw_noexcept)) {

(Tok, diag::err_requires_expr_simple_requirement_noexcept)

(ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) {

(Requirements.empty()) {

ParsingBodyDecl.complete(Body);

RequiresKWLoc, Body,

.getOpenLocation(), LocalParameterDecls,

.getCloseLocation(), Requirements,

.getCloseLocation());

: llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

(

.expectAndConsume())

(Tok.

(tok::ellipsis)) {

Args.push_back(Ty.

());

(

.consumeClose())

(

.expectAndConsume())

ATT_ArrayRank: {

.getCloseLocation());

ATT_ArrayExtent: {

(ExpectAndConsume(tok::comma)) {

.getCloseLocation());

llvm_unreachable(

);

(

.expectAndConsume())

.getCloseLocation());

Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,

assert(ExprType ==

&&

);

assert(isTypeIdInParens() &&

);

ParenParseOption ParseAs;

(!ConsumeAndStoreUntil(tok::r_paren, Toks)) {

(Tok.

(tok::l_brace)) {

ParseAs = CompoundLiteral;

(Tok.

(tok::l_paren) &&

().is(tok::r_paren)) {

NotCastExpr =

;

= ParseCastExpression(AnyCastExpr,

ParseAs = NotCastExpr ? SimpleExpr :

;

Toks.push_back(AttrEnd);

Toks.push_back(Tok);

PP.EnterTokenStream(Toks,

,

(ParseAs >= CompoundLiteral) {

ParseSpecifierQualifierList(DS);

ParseDeclarator(DeclaratorInfo);

(ParseAs == CompoundLiteral) {

ExprType = CompoundLiteral;

(DeclaratorInfo.isInvalidType())

ParseCompoundLiteralExpression(Ty.

(),

(DeclaratorInfo.isInvalidType())

(!

.isInvalid())

DeclaratorInfo, CastTy,

assert(ParseAs == SimpleExpr);

ExprType = SimpleExpr;

(!

.isInvalid() && Tok.

(tok::r_paren))

(

.isInvalid()) {

(Tok.

(tok::eof))

(

.expectAndConsume(diag::err_expected_lparen_after,

))

ParseSpecifierQualifierList(DS);

ParseDeclarator(DeclaratorInfo);

(ExpectAndConsume(tok::comma)) {

(

.consumeClose())

(

.isInvalid() || DeclaratorInfo.isInvalidType())

.getCloseLocation());

Defines the clang::ASTContext interface.

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

static void addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc, DeclSpec &DS)

static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, Token &ColonToken, tok::TokenKind Kind, bool AtDigraph)

static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind)

static void tryConsumeLambdaSpecifierToken(Parser &P, SourceLocation &MutableLoc, SourceLocation &StaticLoc, SourceLocation &ConstexprLoc, SourceLocation &ConstevalLoc, SourceLocation &DeclEndLoc)

static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind)

static void addConstevalToLambdaDeclSpecifier(Parser &P, SourceLocation ConstevalLoc, DeclSpec &DS)

static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind)

static void DiagnoseStaticSpecifierRestrictions(Parser &P, SourceLocation StaticLoc, SourceLocation MutableLoc, const LambdaIntroducer &Intro)

static int SelectDigraphErrorMessage(tok::TokenKind Kind)

static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc, DeclSpec &DS)

Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...

static constexpr bool isOneOf()

This file declares facilities that support code completion.

Defines the clang::TemplateNameKind enum.

Defines the clang::TokenKind enum and support functions.

const clang::PrintingPolicy & getPrintingPolicy() const

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

SourceLocation getOpenLocation() const

SourceLocation getCloseLocation() const

Represents a C++ nested-name-specifier or a global scope specifier.

bool isNotEmpty() const

A scope specifier is present, but may be valid or invalid.

SourceRange getRange() const

SourceLocation getBeginLoc() const

bool isSet() const

Deprecated.

void setEndLoc(SourceLocation Loc)

void SetInvalid(SourceRange R)

Indicate that this nested-name-specifier is invalid.

bool isEmpty() const

No scope specifier.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

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

void restore()

restore - This can be used to restore the state early, before the dtor is run.

Captures information about "declaration specifiers".

static const TST TST_typename

SourceLocation getEndLoc() const LLVM_READONLY

bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)

These methods set the specified attribute of the DeclSpec and return false if there was no error.

static const TST TST_char8

static const TST TST_BFloat16

bool SetConstexprSpec(ConstexprSpecKind ConstexprKind, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)

bool SetTypeSpecWidth(TypeSpecifierWidth W, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)

These methods set the specified attribute of the DeclSpec, but return true and ignore the request if ...

bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)

bool SetTypeSpecSat(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)

SourceRange getSourceRange() const LLVM_READONLY

void SetRangeEnd(SourceLocation Loc)

bool SetBitIntType(SourceLocation KWLoc, Expr *BitWidth, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)

static const TST TST_double

void SetRangeStart(SourceLocation Loc)

static const TST TST_char

static const TST TST_bool

static const TST TST_char16

static const TST TST_accum

static const TST TST_half

static const TST TST_ibm128

static const TST TST_float128

void Finish(Sema &S, const PrintingPolicy &Policy)

Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Complex" (la...

static const TST TST_wchar

static const TST TST_void

static const TST TST_float

static const TST TST_fract

static const TST TST_float16

static const TST TST_decltype_auto

static const TST TST_error

static const TST TST_char32

static const TST TST_int128

bool SetTypeSpecSign(TypeSpecifierSign S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)

static const TST TST_auto

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

SourceLocation getLocation() const

virtual SourceRange getSourceRange() const LLVM_READONLY

Source range that this declaration covers.

Information about one declarator, including the parsed type information and the identifier.

RAII object that enters a new expression evaluation context.

This represents one expression.

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

static FixItHint CreateRemoval(CharSourceRange RemoveRange)

Create a code modification hint that removes the given source range.

static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)

Create a code modification hint that inserts the given code string at a specific location.

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

StringRef getName() const

Return the actual identifier string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)

AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...

static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)

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

This represents a decl that may have a name.

static OpaquePtr make(QualType P)

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

ParsedAttr - Represents a syntactic attribute.

static const ParsedAttributesView & none()

ParsedAttributes - A collection of parsed attributes.

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

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)

SourceLocation ConsumeToken()

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

AttributeFactory & getAttrFactory()

static TypeResult getTypeAnnotation(const Token &Tok)

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

ExprResult ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause)

Parse a constraint-logical-or-expression.

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)

SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)

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

ExprResult ParseConstantExpression()

bool TryConsumeToken(tok::TokenKind Expected)

OpaquePtr< DeclGroupRef > DeclGroupPtrTy

Scope * getCurScope() 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 ...

ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)

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

const LangOptions & getLangOpts() const

ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)

Simple precedence-based parser for binary/ternary operators.

@ StopBeforeMatch

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

@ StopAtSemi

Stop skipping at semicolon.

const Token & NextToken()

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

ExprResult ParseConstraintExpression()

Parse a constraint-expression.

RAII object used to inform the actions that we're currently parsing a declaration.

void enterTypeCast(SourceLocation Tok, QualType CastType)

Handles all type casts, including C-style cast, C++ casts, etc.

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 AnnotateCachedTokens(const Token &Tok)

We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...

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.

SourceManager & getSourceManager() const

void RevertCachedTokens(unsigned N)

When backtracking is enabled and tokens are cached, this allows to revert a specific number of tokens...

IdentifierTable & getIdentifierTable()

bool isCodeCompletionReached() const

Returns true if code-completion is enabled and we have hit the code-completion point.

SourceLocation getLastCachedTokenLocation() const

Get the location of the last cached token, suitable for setting the end location of an annotation tok...

SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)

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

If a crash happens while one of these objects are live, the message is printed out along with the spe...

A (possibly-)qualified type.

Represents the body of a requires-expression.

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

@ FunctionPrototypeScope

This is a scope that corresponds to the parameters within a function prototype.

@ LambdaScope

This is the scope for a lambda, after the lambda introducer.

@ BlockScope

This is a scope that corresponds to a block/closure object.

@ ContinueScope

This is a while, do, for, which can have continue statements embedded into it.

@ BreakScope

This is a while, do, switch, for, etc that can have break statements embedded into it.

@ CompoundStmtScope

This is a compound statement scope.

@ FunctionDeclarationScope

This is a scope that corresponds to the parameters within a function prototype for a function declara...

@ FnScope

This indicates that the scope corresponds to a function, which means that labels are set here.

@ DeclScope

This is a scope that can contain a declaration.

void CodeCompleteObjCMessageReceiver(Scope *S)

void CodeCompleteOperatorName(Scope *S)

@ PCC_Condition

Code completion occurs within the condition of an if, while, switch, or for statement.

void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)

QualType ProduceConstructorSignatureHelp(QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args, SourceLocation OpenParLoc, bool Braced)

void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext, bool IsUsingDeclaration, QualType BaseType, QualType PreferredType)

void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)

ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)

ActOnCXXTypeid - Parse typeid( something ).

ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)

ActOnCXXUuidof - Parse __uuidof( something ).

ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body)

ActOnLambdaExpr - This is called when the body of a lambda expression was successfully completed.

TypeResult ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, const IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)

DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)

ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...

ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)

ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.

@ Switch

An integral condition for a 'switch' statement.

ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)

void ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurContext)

Once the Lambdas capture are known, we can start to create the closure, call operator method,...

concepts::Requirement * ActOnSimpleRequirement(Expr *E)

StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)

concepts::Requirement * ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc)

bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)

ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)

ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in:

TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)

void FinalizeDeclaration(Decl *D)

FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...

ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E)

ParsedType getDestructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)

ASTContext & getASTContext() const

bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)

isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...

ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)

ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)

ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)

ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.

void ActOnFinishRequiresExpr()

ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)

sema::LambdaScopeInfo * getCurGenericLambda()

Retrieve the current generic lambda info, if any.

ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken)

Act on the result of classifying a name as a specific non-type declaration.

ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl, ExprResult Operand, SourceLocation RParenLoc)

bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS)

The parser has parsed a global nested-name-specifier '::'.

bool ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, bool *IsCorrectedToColon=nullptr, bool OnlyNamespace=false)

The parser has parsed a nested-name-specifier 'identifier::'.

bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id, bool IsUDSuffix)

ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)

sema::LambdaScopeInfo * PushLambdaScope()

SemaCodeCompletion & CodeCompletion()

void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, Declarator &ParamInfo, const DeclSpec &DS)

ActOnStartOfLambdaDefinition - This is called just before we start parsing the body of a lambda; it a...

void ActOnLambdaClosureParameters(Scope *LambdaScope, MutableArrayRef< DeclaratorChunk::ParamInfo > ParamInfo)

ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)

ActOnCXXBoolLiteral - Parse {true,false} literals.

bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS)

ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization)

ActOnCXXTypeConstructExpr - Parse construction of a specified type.

ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)

bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, SourceLocation ColonColonLoc, CXXScopeSpec &SS)

The parser has parsed a '__super' nested-name-specifier.

ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, SourceLocation LParenLoc, ArrayRef< ParmVarDecl * > LocalParameters, SourceLocation RParenLoc, ArrayRef< concepts::Requirement * > Requirements, SourceLocation ClosingBraceLoc)

StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro=false)

ExprResult ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, SourceLocation LAngleBracketLoc, Declarator &D, SourceLocation RAngleBracketLoc, SourceLocation LParenLoc, Expr *E, SourceLocation RParenLoc)

ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const,addrspace}_cast's.

ExprResult ActOnPackIndexingExpr(Scope *S, Expr *PackExpression, SourceLocation EllipsisLoc, SourceLocation LSquareLoc, Expr *IndexExpr, SourceLocation RSquareLoc)

ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)

ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)

Parsed a C++ 'new' expression (C++ 5.3.4).

void RestoreNestedNameSpecifierAnnotation(void *Annotation, SourceRange AnnotationRange, CXXScopeSpec &SS)

Given an annotation pointer for a nested-name-specifier, restore the nested-name-specifier structure.

TemplateNameKind ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)

Form a template name from a name that is syntactically required to name a template,...

ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)

SourceManager & getSourceManager() const

void ActOnLambdaExplicitTemplateParameterList(LambdaIntroducer &Intro, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > TParams, SourceLocation RAngleLoc, ExprResult RequiresClause)

This is called after parsing the explicit template parameter list on a lambda (if it exists) in C++2a...

bool ActOnCXXNestedNameSpecifierIndexedPack(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc, QualType Type)

ParsedType actOnLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init)

Perform initialization analysis of the init-capture and perform any implicit conversions such as an l...

void ActOnInitializerError(Decl *Dcl)

ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...

ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc)

Act on the result of classifying a name as an undeclared (ADL-only) non-type declaration.

TypeResult ActOnTypeName(Declarator &D)

void ActOnLambdaClosureQualifiers(LambdaIntroducer &Intro, SourceLocation MutableLoc)

void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, bool IsInstantiation=false)

ActOnLambdaError - If there is an error parsing a lambda, this callback is invoked to pop the informa...

concepts::Requirement * ActOnTypeRequirement(SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc, const IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId)

ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)

Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion.

ExprResult ActOnRequiresClause(ExprResult ConstraintExpr)

RequiresExprBodyDecl * ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, ArrayRef< ParmVarDecl * > LocalParameters, Scope *BodyScope)

@ PotentiallyEvaluated

The current expression is potentially evaluated at run time, which means that code may be generated t...

@ Unevaluated

The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...

void RecordParsingTemplateParameterDepth(unsigned Depth)

This is used to inform Sema what the current TemplateParameterDepth is during Parsing.

StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)

ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)

bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, CXXScopeSpec &SS, ParsedTemplateTy *Template=nullptr)

Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration.

ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)

Parsed one of the type trait support pseudo-functions.

QualType ActOnPackIndexingType(QualType Pattern, Expr *IndexExpr, SourceLocation Loc, SourceLocation EllipsisLoc)

void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)

AddInitializerToDecl - Adds the initializer Init to the declaration dcl.

ParsedType getConstructorName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, bool EnteringContext)

ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand)

Act on the result of classifying a name as an undeclared member of a dependent base class.

concepts::Requirement * ActOnNestedRequirement(Expr *Constraint)

static ConditionResult ConditionError()

bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo, bool EnteringContext)

IsInvalidUnlessNestedName - This method is used for error recovery purposes to determine whether the ...

ExprResult ActOnCXXThis(SourceLocation Loc)

ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})

Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

This class handles loading and caching of source files into memory.

A trivial tuple used to represent a source range.

void setBegin(SourceLocation b)

SourceLocation getEnd() const

SourceLocation getBegin() const

void setEnd(SourceLocation e)

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...

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

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

IdentifierInfo * getIdentifierInfo() const

void setAnnotationEndLoc(SourceLocation L)

SourceLocation getLocation() const

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

const char * getName() const

unsigned getLength() const

void setLength(unsigned Len)

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 isRegularKeywordAttribute() const

Return true if the token is a keyword that is parsed in the same position as a standard attribute,...

void setEofData(const void *D)

SourceRange getAnnotationRange() const

SourceRange of the group of tokens that this annotation token represents.

void setLocation(SourceLocation L)

bool hasLeadingEmptyMacro() const

Return true if this token has an empty macro before it.

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

bool isNot(tok::TokenKind K) const

const void * getEofData() const

void startToken()

Reset all flags to cleared.

The base class of the type hierarchy.

QualType getCanonicalTypeInternal() const

Represents a C++ unqualified-id that has been parsed.

void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)

Specify that this unqualified-id was parsed as an identifier.

bool isValid() const

Determine whether this unqualified-id refers to a valid name.

void setTemplateId(TemplateIdAnnotation *TemplateId)

Specify that this unqualified-id was parsed as a template-id.

A static requirement that can be used in a requires-expression to check properties of types and expre...

uint32_t Literal

Literals are represented as positive integers.

@ After

Like System, but searched after the system directories.

TokenKind

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

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

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ OO_None

Not an overloaded operator.

ArrayTypeTrait

Names for the array type traits.

LambdaCaptureKind

The different capture forms in a lambda introducer.

@ LCK_ByCopy

Capturing by copy (a.k.a., by value)

@ LCK_ByRef

Capturing by reference.

@ LCK_StarThis

Capturing the *this object by copy.

@ LCK_This

Capturing the *this object by reference.

@ IK_ConstructorName

A constructor name.

@ IK_LiteralOperatorId

A user-defined literal name, e.g., operator "" _i.

@ IK_Identifier

An identifier.

@ IK_DestructorName

A destructor name.

@ IK_OperatorFunctionId

An overloaded operator name, e.g., operator+.

@ CopyInit

[a = b], [a = {b}]

@ Result

The result type of a method or function.

ActionResult< Expr * > ExprResult

TemplateNameKind

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

@ TNK_Var_template

The name refers to a variable template whose specialization produces a variable.

@ TNK_Dependent_template_name

The name refers to a dependent template name:

@ TNK_Function_template

The name refers to a function template or a set of overloaded functions that includes at least one fu...

@ TNK_Non_template

The name does not refer to a template.

@ TNK_Undeclared_template

Lookup for the name failed, but we're assuming it was a template name anyway.

const FunctionProtoType * T

const char * getOperatorSpelling(OverloadedOperatorKind Operator)

Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword.

TypeTrait

Names for traits that operate specifically on types.

@ Parens

New-expression has a C++98 paren-delimited initializer.

@ Braces

New-expression has a C++11 list-initializer.

ExceptionSpecificationType

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

@ EST_None

no exception specification

static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult(), SourceLocation TrailingReturnTypeLoc=SourceLocation(), DeclSpec *MethodQualifiers=nullptr)

DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.

static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)

Return a DeclaratorChunk for an array.

Represents a complete lambda introducer.

bool hasLambdaCapture() const

void addCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType, SourceRange ExplicitRange)

Append a capture in a lambda introducer.

SourceLocation DefaultLoc

LambdaCaptureDefault Default

Describes how types, statements, expressions, and declarations should be printed.

Keeps information about an identifier in a nested-name-spec.

Information about a template-id annotation token.

const IdentifierInfo * Name

FIXME: Temporarily stores the name of a specialization.

unsigned NumArgs

NumArgs - The number of template arguments.

SourceLocation TemplateNameLoc

TemplateNameLoc - The location of the template name within the source.

ParsedTemplateArgument * getTemplateArgs()

Retrieves a pointer to the template arguments.

SourceLocation RAngleLoc

The location of the '>' after the template argument list.

SourceLocation LAngleLoc

The location of the '<' before the template argument list.

SourceLocation TemplateKWLoc

TemplateKWLoc - The location of the template keyword.

ParsedTemplateTy Template

The declaration of the template corresponding to the template-name.

static TemplateIdAnnotation * Create(SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, const IdentifierInfo *Name, OverloadedOperatorKind OperatorKind, ParsedTemplateTy OpaqueTemplateName, TemplateNameKind TemplateKind, SourceLocation LAngleLoc, SourceLocation RAngleLoc, ArrayRef< ParsedTemplateArgument > TemplateArgs, bool ArgsInvalid, SmallVectorImpl< TemplateIdAnnotation * > &CleanupList)

Creates a new TemplateIdAnnotation with NumArgs arguments and appends it to List.

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