23 #include "llvm/Support/ErrorHandling.h" 26 using namespace clang;
31 case tok::unknown:
return 0;
33 case tok::kw_const_cast:
return 1;
34 case tok::kw_dynamic_cast:
return 2;
35 case tok::kw_reinterpret_cast:
return 3;
36 case tok::kw_static_cast:
return 4;
38 llvm_unreachable(
"Unknown type for digraph error message.");
43 bool Parser::areTokensAdjacent(
const Token &First,
const Token &Second) {
61 P.
Diag(DigraphToken.
getLocation(), diag::err_missing_whitespace_digraph)
66 ColonToken.
setKind(tok::coloncolon);
69 DigraphToken.
setKind(tok::less);
80 void Parser::CheckForTemplateAndDigraph(
Token &Next,
ParsedType ObjectType,
83 if (!Next.
is(tok::l_square) || Next.
getLength() != 2)
86 Token SecondToken = GetLookAheadToken(2);
87 if (!SecondToken.
is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
93 bool MemberOfUnknownSpecialization;
95 TemplateName, ObjectType, EnteringContext,
96 Template, MemberOfUnknownSpecialization))
99 FixDigraph(*
this, PP, Next, SecondToken, tok::unknown,
147 bool Parser::ParseOptionalCXXScopeSpecifier(
CXXScopeSpec &SS,
149 bool EnteringContext,
150 bool *MayBePseudoDestructor,
153 bool OnlyNamespace) {
155 "Call sites of this function should be guarded by checking for C++");
157 if (Tok.
is(tok::annot_cxxscope)) {
158 assert(!LastII &&
"want last identifier but have already annotated scope");
159 assert(!MayBePseudoDestructor &&
"unexpected annot_cxxscope");
163 ConsumeAnnotationToken();
167 if (Tok.
is(tok::annot_template_id)) {
175 bool CheckForDestructor =
false;
176 if (MayBePseudoDestructor && *MayBePseudoDestructor) {
177 CheckForDestructor =
true;
178 *MayBePseudoDestructor =
false;
184 bool HasScopeSpecifier =
false;
186 if (Tok.
is(tok::coloncolon)) {
189 if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
192 if (NextKind == tok::l_brace) {
201 HasScopeSpecifier =
true;
205 if (Tok.
is(tok::kw___super)) {
207 if (!Tok.
is(tok::coloncolon)) {
215 if (!HasScopeSpecifier &&
216 Tok.
isOneOf(tok::kw_decltype, tok::annot_decltype)) {
226 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
233 HasScopeSpecifier =
true;
237 if (HasScopeSpecifier) {
248 ObjectType =
nullptr;
250 if (Tok.
is(tok::code_completion)) {
269 if (Tok.
is(tok::kw_template)) {
273 if (!HasScopeSpecifier && !ObjectType)
276 TentativeParsingAction TPA(*
this);
280 if (Tok.
is(tok::identifier)) {
284 }
else if (Tok.
is(tok::kw_operator)) {
289 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
298 diag::err_id_after_template_in_nested_name_spec)
311 if (Tok.
isNot(tok::less)) {
320 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
321 EnteringContext, Template,
true)) {
322 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
323 TemplateName,
false))
331 if (Tok.
is(tok::annot_template_id) &&
NextToken().
is(tok::coloncolon)) {
340 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
341 *MayBePseudoDestructor =
true;
346 *LastII = TemplateId->
Name;
349 ConsumeAnnotationToken();
351 assert(Tok.
is(tok::coloncolon) &&
"NextToken() not working properly!");
354 HasScopeSpecifier =
true;
380 if (Tok.
isNot(tok::identifier))
395 if (Next.
is(tok::colon) && !ColonIsSacred) {
402 Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
409 if (Next.
is(tok::coloncolon) && GetLookAheadToken(2).
is(tok::l_brace)) {
412 Token Identifier = Tok;
416 UnconsumeToken(Identifier);
420 if (Next.
is(tok::coloncolon)) {
421 if (CheckForDestructor && GetLookAheadToken(2).
is(tok::tilde) &&
423 *MayBePseudoDestructor =
true;
428 const Token &Next2 = GetLookAheadToken(2);
429 if (Next2.
is(tok::kw_private) || Next2.
is(tok::kw_protected) ||
430 Next2.
is(tok::kw_public) || Next2.
is(tok::kw_virtual)) {
431 Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
436 ColonColon.setKind(tok::colon);
447 Token Identifier = Tok;
449 assert(Tok.
isOneOf(tok::coloncolon, tok::colon) &&
450 "NextToken() not working properly!");
451 Token ColonColon = Tok;
454 bool IsCorrectedToColon =
false;
455 bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon :
nullptr;
458 CorrectionFlagPtr, OnlyNamespace)) {
461 if (CorrectionFlagPtr && IsCorrectedToColon) {
462 ColonColon.setKind(tok::colon);
470 HasScopeSpecifier =
true;
474 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
478 if (Next.
is(tok::less)) {
482 bool MemberOfUnknownSpecialization;
489 MemberOfUnknownSpecialization)) {
498 TemplateName,
false))
503 if (MemberOfUnknownSpecialization && (ObjectType || SS.
isSet()) &&
504 (IsTypename || IsTemplateArgumentList(1))) {
509 unsigned DiagID = diag::err_missing_dependent_template_keyword;
511 DiagID = diag::warn_missing_dependent_template_keyword;
519 EnteringContext, Template,
true)) {
523 TemplateName,
false))
541 if (CheckForDestructor && Tok.
is(tok::tilde))
542 *MayBePseudoDestructor =
true;
556 nullptr, TemplateKWLoc, Name))
561 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
562 isAddressOfOperand =
false;
565 Tok.
is(tok::l_paren), isAddressOfOperand,
612 ExprResult Parser::ParseCXXIdExpression(
bool isAddressOfOperand) {
618 ParseOptionalCXXScopeSpecifier(SS,
nullptr,
false);
622 tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
626 UnconsumeToken(Replacement);
627 Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
629 assert(!Result.
isUnset() &&
"Typo correction suggested a keyword replacement " 630 "for a previous keyword suggestion");
676 Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
678 Diag(Tok, DiagID.getValue());
685 return ParseLambdaExpressionAfterIntroducer(Intro);
693 ExprResult Parser::TryParseLambdaExpression() {
695 && Tok.
is(tok::l_square)
696 &&
"Not at the start of a possible lambda expression.");
704 if (Next.is(tok::r_square) ||
705 Next.is(tok::equal) ||
706 (Next.is(tok::amp) &&
707 (After.
is(tok::r_square) ||
708 After.
is(tok::comma))) ||
709 (Next.is(tok::identifier) &&
710 After.
is(tok::r_square))) {
711 return ParseLambdaExpression();
716 if (Next.is(tok::identifier) && After.
is(tok::identifier)) {
727 if (TryParseLambdaIntroducer(Intro))
730 return ParseLambdaExpressionAfterIntroducer(Intro);
743 bool *SkippedInits) {
744 typedef Optional<unsigned> DiagResult;
746 assert(Tok.
is(tok::l_square) &&
"Lambda expressions begin with '['.");
755 if (Tok.
is(tok::amp) &&
760 }
else if (Tok.
is(tok::equal)) {
766 while (Tok.
isNot(tok::r_square)) {
768 if (Tok.
isNot(tok::comma)) {
773 if (Tok.
is(tok::code_completion) &&
782 return DiagResult(diag::err_expected_comma_or_rsquare);
787 if (Tok.
is(tok::code_completion)) {
809 if (Tok.
is(tok::star)) {
811 if (Tok.
is(tok::kw_this)) {
815 return DiagResult(diag::err_expected_star_this_capture);
817 }
else if (Tok.
is(tok::kw_this)) {
821 if (Tok.
is(tok::amp)) {
825 if (Tok.
is(tok::code_completion)) {
833 if (Tok.
is(tok::identifier)) {
836 }
else if (Tok.
is(tok::kw_this)) {
840 return DiagResult(diag::err_this_captured_by_reference);
842 return DiagResult(diag::err_expected_capture);
845 if (Tok.
is(tok::l_paren)) {
855 *SkippedInits =
true;
856 }
else if (ParseExpressionList(Exprs, Commas)) {
865 }
else if (Tok.
isOneOf(tok::l_brace, tok::equal)) {
878 Init = ParseInitializer();
879 }
else if (Tok.
is(tok::l_brace)) {
883 *SkippedInits =
true;
907 Init = ParseInitializer();
917 Tok.
setKind(tok::annot_primary_expr);
918 setExprAnnotation(Tok, Init);
923 ConsumeAnnotationToken();
978 Loc, Kind ==
LCK_ByRef, Id, InitKind, InitExpr);
981 Intro.
addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
995 bool SkippedInits =
false;
996 TentativeParsingAction PA1(*
this);
998 if (ParseLambdaIntroducer(Intro, &SkippedInits)) {
1003 if (!SkippedInits) {
1013 TentativeParsingAction PA2(*
this);
1015 if (!ParseLambdaIntroducer(Intro)) {
1036 case tok::kw_mutable: {
1039 diag::err_lambda_decl_specifier_repeated)
1043 DeclEndLoc = MutableLoc;
1046 case tok::kw_constexpr:
1049 diag::err_lambda_decl_specifier_repeated)
1053 DeclEndLoc = ConstexprLoc;
1066 ? diag::ext_constexpr_on_lambda_cxx17
1067 : diag::warn_cxx14_compat_constexpr_on_lambda);
1068 const char *PrevSpec =
nullptr;
1069 unsigned DiagID = 0;
1071 assert(PrevSpec ==
nullptr && DiagID == 0 &&
1072 "Constexpr cannot have been set previously!");
1078 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1081 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1084 "lambda expression parsing");
1094 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1102 MaybeParseGNUAttributes(D);
1107 auto WarnIfHasCUDATargetAttr = [&] {
1110 if (A->getKind() == AttributeList::AT_CUDADevice ||
1111 A->getKind() == AttributeList::AT_CUDAHost ||
1112 A->getKind() == AttributeList::AT_CUDAGlobal)
1113 Diag(A->getLoc(), diag::warn_cuda_attr_lambda_position)
1114 << A->getName()->getName();
1118 if (Tok.
is(tok::l_paren)) {
1119 ParseScope PrototypeScope(
this,
1132 if (Tok.
isNot(tok::r_paren)) {
1134 ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
1138 ++CurTemplateDepthTracker;
1146 MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1150 MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
1167 ESpecType = tryParseExceptionSpecification(
false,
1170 DynamicExceptionRanges,
1172 ExceptionSpecTokens);
1175 DeclEndLoc = ESpecRange.
getEnd();
1178 MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1183 if (Tok.
is(tok::arrow)) {
1186 TrailingReturnType = ParseTrailingReturnType(Range);
1188 DeclEndLoc = Range.
getEnd();
1191 PrototypeScope.Exit();
1193 WarnIfHasCUDATargetAttr();
1199 ParamInfo.data(), ParamInfo.size(),
1200 EllipsisLoc, RParenLoc,
1201 DS.getTypeQualifiers(),
1208 ESpecType, ESpecRange,
1209 DynamicExceptions.data(),
1210 DynamicExceptionRanges.data(),
1211 DynamicExceptions.size(),
1213 NoexceptExpr.
get() :
nullptr,
1216 LParenLoc, FunLocalRangeEnd, D,
1217 TrailingReturnType),
1219 }
else if (Tok.
isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1220 tok::kw_constexpr) ||
1224 unsigned TokKind = 0;
1226 case tok::kw_mutable: TokKind = 0;
break;
1227 case tok::arrow: TokKind = 1;
break;
1228 case tok::kw___attribute:
1229 case tok::l_square: TokKind = 2;
break;
1230 case tok::kw_constexpr: TokKind = 3;
break;
1231 default: llvm_unreachable(
"Unknown token kind");
1234 Diag(Tok, diag::err_lambda_missing_parens)
1241 MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1245 if (Tok.
is(tok::kw_mutable)) {
1247 DeclEndLoc = MutableLoc;
1251 MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1254 if (Tok.
is(tok::arrow)) {
1256 TrailingReturnType = ParseTrailingReturnType(Range);
1258 DeclEndLoc = Range.
getEnd();
1261 WarnIfHasCUDATargetAttr();
1286 DeclLoc, DeclEndLoc, D,
1287 TrailingReturnType),
1295 ParseScope BodyScope(
this, ScopeFlags);
1300 if (!Tok.
is(tok::l_brace)) {
1301 Diag(Tok, diag::err_expected_lambda_body);
1309 if (!Stmt.isInvalid() && !TrailingReturnType.
isInvalid())
1327 const char *CastName =
nullptr;
1330 default: llvm_unreachable(
"Unknown C++ cast!");
1331 case tok::kw_const_cast: CastName =
"const_cast";
break;
1332 case tok::kw_dynamic_cast: CastName =
"dynamic_cast";
break;
1333 case tok::kw_reinterpret_cast: CastName =
"reinterpret_cast";
break;
1334 case tok::kw_static_cast: CastName =
"static_cast";
break;
1342 if (Tok.
is(tok::l_square) && Tok.
getLength() == 2) {
1344 if (Next.
is(tok::colon) && areTokensAdjacent(Tok, Next))
1345 FixDigraph(*
this, PP, Tok, Next, Kind,
true);
1348 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1353 ParseSpecifierQualifierList(DS);
1357 ParseDeclarator(DeclaratorInfo);
1361 if (ExpectAndConsume(tok::greater))
1362 return ExprError(
Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1376 LAngleBracketLoc, DeclaratorInfo,
1391 assert(Tok.
is(tok::kw_typeid) &&
"Not 'typeid'!");
1421 if (isTypeIdInParens()) {
1431 Ty.
get().getAsOpaquePtr(), RParenLoc);
1445 Result.
get(), RParenLoc);
1458 assert(Tok.
is(tok::kw___uuidof) &&
"Not '__uuidof'!");
1469 if (isTypeIdInParens()) {
1479 Ty.
get().getAsOpaquePtr(),
1530 if (Tok.
is(tok::identifier)) {
1533 assert(Tok.
is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail");
1535 }
else if (Tok.
is(tok::annot_template_id)) {
1540 ConsumeAnnotationToken();
1541 assert(Tok.
is(tok::coloncolon) &&
"ParseOptionalCXXScopeSpecifier fail");
1548 assert(Tok.
is(tok::tilde) &&
"ParseOptionalCXXScopeSpecifier fail");
1551 if (Tok.
is(tok::kw_decltype) && !FirstTypeName.
isValid() && SS.
isEmpty()) {
1553 ParseDecltypeSpecifier(DS);
1560 if (!Tok.
is(tok::identifier)) {
1561 Diag(Tok, diag::err_destructor_tilde_identifier);
1573 if (Tok.
is(tok::less) &&
1576 false, ObjectType, SecondTypeName,
1581 SS, FirstTypeName, CCLoc, TildeLoc,
1600 assert(Tok.
is(tok::kw_throw) &&
"Not throw!");
1626 ExprResult Parser::ParseCoyieldExpression() {
1627 assert(Tok.
is(tok::kw_co_yield) &&
"Not co_yield!");
1643 assert(Tok.
is(tok::kw_this) &&
"Not 'this'!");
1662 Parser::ParseCXXTypeConstructExpression(
const DeclSpec &DS) {
1666 assert((Tok.
is(tok::l_paren) ||
1668 &&
"Expected '(' or '{'!");
1670 if (Tok.
is(tok::l_brace)) {
1683 CommaLocsTy CommaLocs;
1685 if (Tok.
isNot(tok::r_paren)) {
1686 if (ParseExpressionList(Exprs, CommaLocs, [&] {
1703 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1704 "Unexpected number of commas!");
1736 if (Tok.
is(tok::code_completion)) {
1742 ParsedAttributesWithRange attrs(AttrFactory);
1743 MaybeParseCXX11Attributes(attrs);
1746 switch (isCXXConditionDeclarationOrInitStatement(InitStmt)) {
1747 case ConditionOrInitStatement::Expression: {
1748 ProhibitAttributes(attrs);
1755 if (InitStmt && Tok.
is(tok::semi)) {
1758 return ParseCXXCondition(
nullptr, Loc, CK);
1764 case ConditionOrInitStatement::InitStmtDecl: {
1766 ? diag::warn_cxx14_compat_init_statement
1767 : diag::ext_init_statement)
1774 return ParseCXXCondition(
nullptr, Loc, CK);
1777 case ConditionOrInitStatement::ConditionDecl:
1778 case ConditionOrInitStatement::Error:
1785 ParseSpecifierQualifierList(DS,
AS_none, DeclSpecContext::DSC_condition);
1789 ParseDeclarator(DeclaratorInfo);
1792 if (Tok.
is(tok::kw_asm)) {
1804 MaybeParseGNUAttributes(DeclaratorInfo);
1815 bool CopyInitialization = isTokenEqualOrEqualTypo();
1816 if (CopyInitialization)
1822 diag::warn_cxx98_compat_generalized_initializer_lists);
1823 InitExpr = ParseBraceInitializer();
1824 }
else if (CopyInitialization) {
1826 }
else if (Tok.
is(tok::l_paren)) {
1830 RParen = ConsumeParen();
1832 diag::err_expected_init_in_condition_lparen)
1873 void Parser::ParseCXXSimpleTypeSpecifier(
DeclSpec &DS) {
1875 const char *PrevSpec;
1882 case tok::identifier:
1883 case tok::coloncolon:
1884 llvm_unreachable(
"Annotation token should already be formed!");
1886 llvm_unreachable(
"Not a simple-type-specifier token!");
1889 case tok::annot_typename: {
1897 ConsumeAnnotationToken();
1899 DS.
Finish(Actions, Policy);
1910 case tok::kw___int64:
1913 case tok::kw_signed:
1916 case tok::kw_unsigned:
1928 case tok::kw___int128:
1937 case tok::kw_double:
1940 case tok::kw__Float16:
1943 case tok::kw___float128:
1946 case tok::kw_wchar_t:
1949 case tok::kw_char16_t:
1952 case tok::kw_char32_t:
1958 case tok::annot_decltype:
1959 case tok::kw_decltype:
1961 return DS.
Finish(Actions, Policy);
1964 case tok::kw_typeof:
1965 ParseTypeofSpecifier(DS);
1966 DS.
Finish(Actions, Policy);
1971 DS.
Finish(Actions, Policy);
1985 bool Parser::ParseCXXTypeSpecifierSeq(
DeclSpec &DS) {
1986 ParseSpecifierQualifierList(DS,
AS_none, DeclSpecContext::DSC_type_specifier);
2023 bool Parser::ParseUnqualifiedIdTemplateId(
CXXScopeSpec &SS,
2027 bool EnteringContext,
2030 bool AssumeTemplateId) {
2031 assert((AssumeTemplateId || Tok.
is(tok::less)) &&
2032 "Expected '<' to finish parsing a template-id");
2040 if (AssumeTemplateId) {
2044 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2049 bool MemberOfUnknownSpecialization;
2052 ObjectType, EnteringContext, Template,
2053 MemberOfUnknownSpecialization);
2056 ObjectType && IsTemplateArgumentList()) {
2075 getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2085 bool MemberOfUnknownSpecialization;
2088 TemplateName, ObjectType,
2089 EnteringContext, Template,
2090 MemberOfUnknownSpecialization);
2096 bool MemberOfUnknownSpecialization;
2100 getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2101 EnteringContext, Template,
true);
2106 TemplateName, ObjectType,
2107 EnteringContext, Template,
2108 MemberOfUnknownSpecialization);
2111 Diag(NameLoc, diag::err_destructor_template_id)
2128 TemplateArgList TemplateArgs;
2129 if (Tok.
is(tok::less) && ParseTemplateIdAfterTemplateName(
2130 true, LAngleLoc, TemplateArgs, RAngleLoc))
2149 SS, TemplateKWLoc, Id.
StartLocation, TemplateII, OpKind, Template, TNK,
2150 LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);
2162 Template, Name, NameLoc,
2163 LAngleLoc, TemplateArgsPtr, RAngleLoc,
2216 bool Parser::ParseUnqualifiedIdOperator(
CXXScopeSpec &SS,
bool EnteringContext,
2219 assert(Tok.
is(tok::kw_operator) &&
"Expected 'operator' keyword");
2225 unsigned SymbolIdx = 0;
2230 case tok::kw_delete: {
2231 bool isNew = Tok.
getKind() == tok::kw_new;
2235 if (Tok.
is(tok::l_square) &&
2246 Op = isNew? OO_Array_New : OO_Array_Delete;
2248 Op = isNew? OO_New : OO_Delete;
2253 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 2255 SymbolLocations[SymbolIdx++] = ConsumeToken(); \ 2258 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly) 2259 #include "clang/Basic/OperatorKinds.def" 2261 case tok::l_paren: {
2275 case tok::l_square: {
2289 case tok::code_completion: {
2317 unsigned DiagId = 0;
2323 while (isTokenStringLiteral()) {
2324 if (!Tok.
is(tok::string_literal) && !DiagId) {
2329 DiagId = diag::err_literal_operator_string_prefix;
2331 Toks.push_back(Tok);
2332 TokLocs.push_back(ConsumeStringToken());
2349 }
else if (Tok.
is(tok::identifier)) {
2352 TokLocs.push_back(SuffixLoc);
2364 DiagLoc = TokLocs.front();
2365 DiagId = diag::err_literal_operator_string_not_empty;
2375 SourceRange(TokLocs.front(), TokLocs.back()), Str);
2396 if (ParseCXXTypeSpecifierSeq(DS))
2402 ParseDeclaratorInternal(D,
nullptr);
2448 bool AllowDestructorName,
2449 bool AllowConstructorName,
2450 bool AllowDeductionGuide,
2457 bool TemplateSpecified =
false;
2459 (ObjectType || SS.
isSet())) {
2460 TemplateSpecified =
true;
2467 if (Tok.
is(tok::identifier)) {
2480 if (AllowConstructorName &&
2489 AllowDeductionGuide && SS.
isEmpty() &&
2500 if (TemplateSpecified || Tok.
is(tok::less))
2501 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2502 EnteringContext, ObjectType,
2503 Result, TemplateSpecified);
2510 if (Tok.
is(tok::annot_template_id)) {
2514 if (AllowConstructorName && TemplateId->
Name &&
2522 diag::err_out_of_line_constructor_template_id)
2533 ConsumeAnnotationToken();
2538 ConsumeAnnotationToken();
2546 ConsumeAnnotationToken();
2553 if (Tok.
is(tok::kw_operator)) {
2554 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2564 (TemplateSpecified || Tok.
is(tok::less)))
2565 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2567 EnteringContext, ObjectType,
2568 Result, TemplateSpecified);
2574 (AllowDestructorName || SS.
isSet()) && Tok.
is(tok::tilde)) {
2583 if (SS.
isEmpty() && Tok.
is(tok::kw_decltype)) {
2595 if (Tok.
isNot(tok::identifier)) {
2596 Diag(Tok, diag::err_destructor_tilde_identifier);
2601 DeclaratorScopeObj DeclScopeObj(*
this, SS);
2602 if (!TemplateSpecified &&
NextToken().is(tok::coloncolon)) {
2609 AnnotateScopeToken(SS,
true);
2612 if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2615 ObjectType =
nullptr;
2618 Diag(TildeLoc, diag::err_destructor_tilde_scope);
2623 Diag(TildeLoc, diag::err_destructor_tilde_scope)
2629 DeclScopeObj.EnterDeclaratorScope();
2636 if (TemplateSpecified || Tok.
is(tok::less)) {
2638 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2639 ClassName, ClassNameLoc,
2640 EnteringContext, ObjectType,
2641 Result, TemplateSpecified);
2656 Diag(Tok, diag::err_expected_unqualified_id)
2690 Parser::ParseCXXNewExpression(
bool UseGlobal,
SourceLocation Start) {
2691 assert(Tok.
is(tok::kw_new) &&
"expected 'new' token");
2703 if (Tok.
is(tok::l_paren)) {
2708 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2720 if (PlacementArgs.empty()) {
2726 if (Tok.
is(tok::l_paren)) {
2729 MaybeParseGNUAttributes(DeclaratorInfo);
2730 ParseSpecifierQualifierList(DS);
2732 ParseDeclarator(DeclaratorInfo);
2736 MaybeParseGNUAttributes(DeclaratorInfo);
2737 if (ParseCXXTypeSpecifierSeq(DS))
2741 ParseDeclaratorInternal(DeclaratorInfo,
2742 &Parser::ParseDirectNewDeclarator);
2749 MaybeParseGNUAttributes(DeclaratorInfo);
2750 if (ParseCXXTypeSpecifierSeq(DS))
2754 ParseDeclaratorInternal(DeclaratorInfo,
2755 &Parser::ParseDirectNewDeclarator);
2765 if (Tok.
is(tok::l_paren)) {
2771 if (Tok.
isNot(tok::r_paren)) {
2773 if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2775 DeclaratorInfo).
get();
2794 }
else if (Tok.
is(tok::l_brace) &&
getLangOpts().CPlusPlus11) {
2796 diag::warn_cxx98_compat_generalized_initializer_lists);
2797 Initializer = ParseBraceInitializer();
2802 return Actions.
ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2803 PlacementArgs, PlacementRParen,
2804 TypeIdParens, DeclaratorInfo, Initializer.
get());
2814 void Parser::ParseDirectNewDeclarator(
Declarator &D) {
2817 while (Tok.
is(tok::l_square)) {
2819 if (CheckProhibitedCXX11Attribute())
2838 MaybeParseCXX11Attributes(Attrs);
2862 bool Parser::ParseExpressionListOrTypeId(
2866 if (isTypeIdInParens()) {
2876 return ParseExpressionList(PlacementArgs, CommaLocs);
2891 Parser::ParseCXXDeleteExpression(
bool UseGlobal,
SourceLocation Start) {
2892 assert(Tok.
is(tok::kw_delete) &&
"Expected 'delete' keyword");
2896 bool ArrayDelete =
false;
2897 if (Tok.
is(tok::l_square) &&
NextToken().
is(tok::r_square)) {
2915 ExprResult Operand(ParseCastExpression(
false));
2924 default: llvm_unreachable(
"Not a known type trait");
2925 #define TYPE_TRAIT_1(Spelling, Name, Key) \ 2926 case tok::kw_ ## Spelling: return UTT_ ## Name; 2927 #define TYPE_TRAIT_2(Spelling, Name, Key) \ 2928 case tok::kw_ ## Spelling: return BTT_ ## Name; 2929 #include "clang/Basic/TokenKinds.def" 2930 #define TYPE_TRAIT_N(Spelling, Name, Key) \ 2931 case tok::kw_ ## Spelling: return TT_ ## Name; 2932 #include "clang/Basic/TokenKinds.def" 2938 default: llvm_unreachable(
"Not a known binary type trait");
2946 default: llvm_unreachable(
"Not a known unary expression trait.");
2954 default: llvm_unreachable(
"Not a known type trait");
2955 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N; 2956 #include "clang/Basic/TokenKinds.def" 2991 if (Tok.
is(tok::ellipsis)) {
3000 Args.push_back(Ty.
get());
3008 if (Arity && Args.size() != Arity) {
3009 Diag(EndLoc, diag::err_type_trait_arity)
3010 << Arity << 0 << (Arity > 1) << (
int)Args.size() <<
SourceRange(Loc);
3014 if (!Arity && Args.empty()) {
3015 Diag(EndLoc, diag::err_type_trait_arity)
3016 << 1 << 1 << 1 << (int)Args.size() <<
SourceRange(Loc);
3052 if (ExpectAndConsume(tok::comma)) {
3064 llvm_unreachable(
"Invalid ArrayTypeTrait!");
3094 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3099 assert(ExprType ==
CastExpr &&
"Compound literals are not ambiguous!");
3100 assert(isTypeIdInParens() &&
"Not a type-id!");
3124 ParenParseOption ParseAs;
3129 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3135 if (Tok.
is(tok::l_brace)) {
3136 ParseAs = CompoundLiteral;
3146 Result = ParseCastExpression(
false,
3155 ParseAs = NotCastExpr ? SimpleExpr :
CastExpr;
3164 Toks.push_back(AttrEnd);
3167 Toks.push_back(Tok);
3170 PP.EnterTokenStream(Toks,
true );
3175 if (ParseAs >= CompoundLiteral) {
3181 ParseSpecifierQualifierList(DS);
3182 ParseDeclarator(DeclaratorInfo);
3193 if (ParseAs == CompoundLiteral) {
3194 ExprType = CompoundLiteral;
3199 return ParseCompoundLiteralExpression(Ty.
get(),
3213 DeclaratorInfo, CastTy,
3219 assert(ParseAs == SimpleExpr);
3221 ExprType = SimpleExpr;
static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind)
Defines the clang::ASTContext interface.
void setConstructorName(ParsedType ClassType, SourceLocation ClassNameLoc, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a constructor name.
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
StringRef getUDSuffix() const
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
no exception specification
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
void restore()
restore - This can be used to restore the state early, before the dtor is run.
Keeps information about an identifier in a nested-name-spec.
This is a scope that corresponds to the parameters within a function prototype.
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id)
AttributeList * getNext() const
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
static const TSS TSS_unsigned
bool ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, bool ErrorRecoveryLookup=false, bool *IsCorrectedToColon=nullptr, bool OnlyNamespace=false)
The parser has parsed a nested-name-specifier 'identifier::'.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
static const TST TST_wchar
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
Stmt - This represents one statement.
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
StmtResult ActOnExprStmt(ExprResult Arg)
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)) {...
bool isEmpty() const
No scope specifier.
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void setEndLoc(SourceLocation Loc)
static const TST TST_char16
Decl - This represents one declaration (or definition), e.g.
Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...
bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Defines the C++ template declaration subclasses.
The base class of the type hierarchy.
SourceLocation getCloseLocation() const
This indicates that the scope corresponds to a function, which means that labels are set here...
void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext)
Parser - This implements a parser for the C family of languages.
An overloaded operator name, e.g., operator+.
bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo, bool EnteringContext)
IsInvalidUnlessNestedName - This method is used for error recovery purposes to determine whether the ...
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
static TemplateIdAnnotation * Create(CXXScopeSpec SS, SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, IdentifierInfo *Name, OverloadedOperatorKind OperatorKind, ParsedTemplateTy OpaqueTemplateName, TemplateNameKind TemplateKind, SourceLocation LAngleLoc, SourceLocation RAngleLoc, ArrayRef< ParsedTemplateArgument > TemplateArgs, SmallVectorImpl< TemplateIdAnnotation *> &CleanupList)
Creates a new TemplateIdAnnotation with NumArgs arguments and appends it to List. ...
void CodeCompleteObjCMessageReceiver(Scope *S)
RAII object that enters a new expression evaluation context.
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
Information about one declarator, including the parsed type information and the identifier.
static const TST TST_char
Like System, but searched after the system directories.
void setBegin(SourceLocation b)
Describes how types, statements, expressions, and declarations should be printed. ...
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
AttributeList * getList() const
tok::TokenKind getKind() const
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 ...
Information about a template-id annotation token.
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)
One of these records is kept for each identifier that is lexed.
void setConstructorTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id that names a constructor.
SourceLocation getAnnotationEndLoc() const
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
void setConversionFunctionId(SourceLocation OperatorLoc, ParsedType Ty, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a conversion-function-id.
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr *> Args)
LambdaCaptureKind
The different capture forms in a lambda introducer.
The current expression is potentially evaluated at run time, which means that code may be generated t...
bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
OverloadedOperatorKind Operator
The kind of overloaded operator.
static const TST TST_double
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
Token - This structure provides full information about a lexed token.
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, ParsedType ObjectType, SourceLocation &TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
void setKind(tok::TokenKind K)
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
A user-defined literal name, e.g., operator "" _i.
void SetSourceRange(SourceRange R)
bool isInvalidType() const
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
This is a scope that corresponds to a block/closure object.
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
static ParsedType getTypeAnnotation(const Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
< Capturing the *this object by copy
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, 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...
SourceRange getRange() const
const clang::PrintingPolicy & getPrintingPolicy() const
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
If a crash happens while one of these objects are live, the message is printed out along with the spe...
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
ArrayTypeTrait
Names for the array type traits.
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type...
void setTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id.
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Character, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token...
SourceRange getSourceRange() const LLVM_READONLY
const char * getName() const
bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo)
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
static const TST TST_float
TypeTrait
Names for traits that operate specifically on types.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
static const TSW TSW_long
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
void SetRangeStart(SourceLocation Loc)
SourceRange getRange() const
SmallVector< LambdaCapture, 4 > Captures
TST getTypeSpecType() const
ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, Scope *CurScope)
ActOnLambdaExpr - This is called when the body of a lambda expression was successfully completed...
Expr - This represents one expression.
bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS)
The parser has parsed a global nested-name-specifier '::'.
void setDeductionGuideName(ParsedTemplateTy Template, SourceLocation TemplateLoc)
Specify that this unqualified-id was parsed as a template-name for a deduction-guide.
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, 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())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
void AnnotateCachedTokens(const Token &Tok)
We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...
const FunctionProtoType * T
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
OpaquePtr< T > get() const
void setEofData(const void *D)
void RevertCachedTokens(unsigned N)
When backtracking is enabled and tokens are cached, this allows to revert a specific number of tokens...
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
const Token & getCurToken() const
OpaquePtr< TemplateName > TemplateTy
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
void setAsmLabel(Expr *E)
SourceLocation getBeginLoc() const
Represents a C++ template name within the type system.
This is a compound statement scope.
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, SourceLocation IdLoc)
Specific that this unqualified-id was parsed as a literal-operator-id.
TemplateNameKind ActOnDependentTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a dependent template name.
SourceLocation getEnd() const
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
SourceLocation getOpenLocation() const
static const TST TST_half
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization)
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression.
sema::LambdaScopeInfo * PushLambdaScope()
The result type of a method or function.
static const TSW TSW_short
StringRef GetString() const
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion...
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
const LangOptions & getLangOpts() const
bool SetTypeSpecWidth(TSW 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 ...
This is a scope that corresponds to the parameters within a function prototype for a function declara...
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
SourceManager & getSourceManager() const
static const TST TST_char32
unsigned getUDSuffixOffset() const
Get the spelling offset of the first byte of the ud-suffix.
SourceLocation DefaultLoc
Stop skipping at semicolon.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
unsigned getUDSuffixToken() const
Get the index of a token containing a ud-suffix.
ASTContext & getASTContext() const
static const TST TST_float16
Encodes a location in the source.
void addCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType)
Append a capture in a lambda introducer.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setLength(unsigned Len)
static void addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc, DeclSpec &DS)
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration...
IdentifierInfo * getIdentifierInfo() const
void setAnnotationEndLoc(SourceLocation L)
IdentifierTable & getIdentifierTable()
static const TSS TSS_signed
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}_cast's.
void CodeCompleteOperatorName(Scope *S)
void Lex(Token &Result)
Lex the next token for this preprocessor.
const void * getEofData() const
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Scope * getCurScope() const
static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)
Return a DeclaratorChunk for an array.
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ 'new' expression.
MutableArrayRef< Expr * > MultiExprArg
static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, Token &ColonToken, tok::TokenKind Kind, bool AtDigraph)
StringRef getName() const
Return the actual identifier string.
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
bool isNot(tok::TokenKind K) const
static const TST TST_decltype_auto
The name does not refer to a template.
Dataflow Directional Tag Classes.
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...
bool isValid() const
Return true if this is a valid SourceLocation object.
LambdaCaptureDefault Default
bool expectAndConsume(unsigned DiagID=diag::err_expected, const char *Msg="", tok::TokenKind SkipToTok=tok::unknown)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
static const TST TST_void
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
static const TST TST_int128
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
SourceLocation getLocEnd() const LLVM_READONLY
SourceLocation getLastCachedTokenLocation() const
Get the location of the last cached token, suitable for setting the end location of an annotation tok...
bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, SourceLocation ColonColonLoc, CXXScopeSpec &SS)
The parser has parsed a '__super' nested-name-specifier.
unsigned getLength() const
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
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...
Not an overloaded operator.
void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, Declarator &ParamInfo, Scope *CurScope)
ActOnStartOfLambdaDefinition - This is called just before we start parsing the body of a lambda; it a...
QualType getCanonicalTypeInternal() const
void takeAttributesFrom(ParsedAttributes &attrs)
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
static void tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc, SourceLocation &ConstexprLoc, SourceLocation &DeclEndLoc)
void RestoreNestedNameSpecifierAnnotation(void *Annotation, SourceRange AnnotationRange, CXXScopeSpec &SS)
Given an annotation pointer for a nested-name-specifier, restore the nested-name-specifier structure...
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
static const TST TST_typename
ActionResult< Stmt * > StmtResult
void SetRangeEnd(SourceLocation Loc)
SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn't include (top-level) commas.
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
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.
ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E)
Capturing the *this object by reference.
This is a scope that can contain a declaration.
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
bool isSet() const
Deprecated.
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
void setInvalidType(bool Val=true)
An integral condition for a 'switch' statement.
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
Captures information about "declaration specifiers".
void setEnd(SourceLocation e)
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind)
static int SelectDigraphErrorMessage(tok::TokenKind Kind)
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
static const TST TST_float128
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
static const TST TST_bool
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
unsigned kind
All of the diagnostics that can be emitted by the frontend.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
void Finish(Sema &S, const PrintingPolicy &Policy)
Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Imaginary" (...
Represents a complete lambda introducer.
static const TSW TSW_longlong
Code completion occurs within the condition of an if, while, switch, or for statement.
static unsigned TypeTraitArity(tok::TokenKind kind)
void setLocation(SourceLocation L)
A trivial tuple used to represent a source range.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
unsigned NumArgs
NumArgs - The number of template arguments.
void * getAnnotationValue() const
void setDestructorName(SourceLocation TildeLoc, ParsedType ClassType, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a destructor name.
SourceLocation getLocEnd() const LLVM_READONLY
void SetRangeEnd(SourceLocation Loc)
SourceLocation getBegin() const
ParsedAttributes - A collection of parsed attributes.
This class handles loading and caching of source files into memory.
TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind)
Attr - This represents one attribute.
SourceLocation getLocation() const
void startToken()
Reset all flags to cleared.
ParsedType actOnLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init)
Perform initialization analysis of the init-capture and perform any implicit conversions such as an l...
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Stop skipping at specified token, but don't skip the token itself.