25#include "llvm/Support/Path.h"
26#include "llvm/Support/TimeProfiler.h"
37 explicit ActionCommentHandler(
Sema &S) : S(S) { }
55 : PP(pp), PreferredType(pp.isCodeCompletionEnabled()), Actions(actions),
56 Diags(PP.getDiagnostics()), GreaterThanIsOperator(
true),
57 ColonIsSacred(
false), InMessageExpression(
false),
58 TemplateParameterDepth(0), ParsingInObjCContainer(
false) {
62 Actions.CurScope =
nullptr;
64 CurParsedObjCImpl =
nullptr;
68 initializePragmaHandlers();
70 CommentSemaHandler.reset(
new ActionCommentHandler(actions));
76 [
this](StringRef TypeStr, StringRef Context,
SourceLocation IncludeLoc) {
77 return this->ParseTypeFromString(TypeStr, Context, IncludeLoc);
111 switch (ExpectedTok) {
113 return Tok.
is(tok::colon) || Tok.
is(tok::comma);
114 default:
return false;
118bool Parser::ExpectAndConsume(
tok::TokenKind ExpectedTok,
unsigned DiagID,
120 if (Tok.
is(ExpectedTok) || Tok.
is(tok::code_completion)) {
132 if (DiagID == diag::err_expected)
134 else if (DiagID == diag::err_expected_after)
135 DB << Msg << ExpectedTok;
146 const char *Spelling =
nullptr;
154 if (DiagID == diag::err_expected)
156 else if (DiagID == diag::err_expected_after)
157 DB << Msg << ExpectedTok;
164bool Parser::ExpectAndConsumeSemi(
unsigned DiagID, StringRef TokenUsed) {
168 if (Tok.
is(tok::code_completion)) {
169 handleUnexpectedCodeCompletionToken();
173 if ((Tok.
is(tok::r_paren) || Tok.
is(tok::r_square)) &&
175 Diag(Tok, diag::err_extraneous_token_before_semi)
183 return ExpectAndConsume(tok::semi, DiagID , TokenUsed);
186void Parser::ConsumeExtraSemi(ExtraSemiKind Kind,
DeclSpec::TST TST) {
187 if (!Tok.
is(tok::semi))
return;
189 bool HadMultipleSemis =
false;
195 HadMultipleSemis =
true;
204 Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi)
207 Diag(StartLoc, diag::ext_extra_semi_cxx11)
212 if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis)
213 Diag(StartLoc, diag::ext_extra_semi)
219 Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def)
223bool Parser::expectIdentifier() {
224 if (Tok.
is(tok::identifier))
228 Diag(Tok, diag::err_expected_token_instead_of_objcxx_keyword)
234 Diag(Tok, diag::err_expected) << tok::identifier;
249 Diag(FirstTokLoc, diag::warn_compound_token_split_by_macro)
250 << (FirstTokKind == Tok.
getKind()) << FirstTokKind << Tok.
getKind()
251 <<
static_cast<int>(Op) <<
SourceRange(FirstTokLoc);
252 Diag(SecondTokLoc, diag::note_compound_token_split_second_token_here)
262 SpaceLoc = FirstTokLoc;
263 Diag(SpaceLoc, diag::warn_compound_token_split_by_whitespace)
264 << (FirstTokKind == Tok.
getKind()) << FirstTokKind << Tok.
getKind()
265 <<
static_cast<int>(Op) <<
SourceRange(FirstTokLoc, SecondTokLoc);
275 return (
static_cast<unsigned>(L) &
static_cast<unsigned>(R)) != 0;
289 bool isFirstTokenSkipped =
true;
292 for (
unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) {
293 if (Tok.
is(Toks[i])) {
306 if (Toks.size() == 1 && Toks[0] == tok::eof &&
309 while (Tok.
isNot(tok::eof))
319 case tok::annot_pragma_openmp:
320 case tok::annot_attr_openmp:
321 case tok::annot_pragma_openmp_end:
323 if (OpenMPDirectiveParsing)
325 ConsumeAnnotationToken();
327 case tok::annot_pragma_openacc:
328 case tok::annot_pragma_openacc_end:
330 if (OpenACCDirectiveParsing)
332 ConsumeAnnotationToken();
334 case tok::annot_module_begin:
335 case tok::annot_module_end:
336 case tok::annot_module_include:
337 case tok::annot_repl_input_end:
343 case tok::code_completion:
345 handleUnexpectedCodeCompletionToken();
387 if (ParenCount && !isFirstTokenSkipped)
392 if (BracketCount && !isFirstTokenSkipped)
397 if (BraceCount && !isFirstTokenSkipped)
411 isFirstTokenSkipped =
false;
421 if (NumCachedScopes) {
422 Scope *N = ScopeCache[--NumCachedScopes];
424 Actions.CurScope = N;
439 Actions.CurScope = OldScope->
getParent();
441 if (NumCachedScopes == ScopeCacheSize)
444 ScopeCache[NumCachedScopes++] = OldScope;
449Parser::ParseScopeFlags::ParseScopeFlags(
Parser *
Self,
unsigned ScopeFlags,
451 : CurScope(ManageFlags ?
Self->getCurScope() : nullptr) {
453 OldFlags = CurScope->getFlags();
454 CurScope->setFlags(ScopeFlags);
460Parser::ParseScopeFlags::~ParseScopeFlags() {
462 CurScope->setFlags(OldFlags);
473 Actions.CurScope =
nullptr;
476 for (
unsigned i = 0, e = NumCachedScopes; i != e; ++i)
477 delete ScopeCache[i];
479 resetPragmaHandlers();
485 DestroyTemplateIds();
492 assert(
getCurScope() ==
nullptr &&
"A scope is already active?");
507 ObjCTypeQuals[objc_null_unspecified]
511 Ident_instancetype =
nullptr;
512 Ident_final =
nullptr;
513 Ident_sealed =
nullptr;
514 Ident_abstract =
nullptr;
515 Ident_override =
nullptr;
516 Ident_GNU_final =
nullptr;
517 Ident_import =
nullptr;
518 Ident_module =
nullptr;
522 Ident_vector =
nullptr;
523 Ident_bool =
nullptr;
524 Ident_Bool =
nullptr;
525 Ident_pixel =
nullptr;
534 Ident_introduced =
nullptr;
535 Ident_deprecated =
nullptr;
536 Ident_obsoleted =
nullptr;
537 Ident_unavailable =
nullptr;
538 Ident_strict =
nullptr;
539 Ident_replacement =
nullptr;
541 Ident_language = Ident_defined_in = Ident_generated_declaration = Ident_USR =
544 Ident__except =
nullptr;
546 Ident__exception_code = Ident__exception_info =
nullptr;
547 Ident__abnormal_termination = Ident___exception_code =
nullptr;
548 Ident___exception_info = Ident___abnormal_termination =
nullptr;
549 Ident_GetExceptionCode = Ident_GetExceptionInfo =
nullptr;
550 Ident_AbnormalTermination =
nullptr;
563 PP.
SetPoisonReason(Ident__exception_code,diag::err_seh___except_block);
564 PP.
SetPoisonReason(Ident___exception_code,diag::err_seh___except_block);
565 PP.
SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block);
566 PP.
SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter);
567 PP.
SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter);
568 PP.
SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter);
569 PP.
SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block);
570 PP.
SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block);
571 PP.
SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block);
585void Parser::DestroyTemplateIds() {
617 Diag(diag::ext_empty_translation_unit);
619 return NoTopLevelDecls;
630 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*
this);
639 case tok::annot_pragma_unused:
640 HandlePragmaUnused();
654 case tok::identifier: {
656 if ((II == Ident_module || II == Ident_import) &&
657 GetLookAheadToken(2).isNot(tok::coloncolon)) {
658 if (II == Ident_module)
673 Result = ParseModuleDecl(ImportState);
683 case tok::annot_module_include: {
696 ConsumeAnnotationToken();
700 case tok::annot_module_begin:
704 ConsumeAnnotationToken();
708 case tok::annot_module_end:
712 ConsumeAnnotationToken();
717 case tok::annot_repl_input_end:
724 PP.
Diag(OverrideLoc, diag::note_max_tokens_total_override);
734 case tok::identifier:
759 while (MaybeParseCXX11Attributes(DeclAttrs) ||
760 MaybeParseGNUAttributes(DeclSpecAttrs))
763 Result = ParseExternalDeclaration(DeclAttrs, DeclSpecAttrs);
773 else if (ImportState ==
814 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*
this);
822 Decl *SingleDecl =
nullptr;
824 case tok::annot_pragma_vis:
825 HandlePragmaVisibility();
827 case tok::annot_pragma_pack:
830 case tok::annot_pragma_msstruct:
831 HandlePragmaMSStruct();
833 case tok::annot_pragma_align:
836 case tok::annot_pragma_weak:
839 case tok::annot_pragma_weakalias:
840 HandlePragmaWeakAlias();
842 case tok::annot_pragma_redefine_extname:
843 HandlePragmaRedefineExtname();
845 case tok::annot_pragma_fp_contract:
846 HandlePragmaFPContract();
848 case tok::annot_pragma_fenv_access:
849 case tok::annot_pragma_fenv_access_ms:
850 HandlePragmaFEnvAccess();
852 case tok::annot_pragma_fenv_round:
853 HandlePragmaFEnvRound();
855 case tok::annot_pragma_cx_limited_range:
856 HandlePragmaCXLimitedRange();
858 case tok::annot_pragma_float_control:
859 HandlePragmaFloatControl();
861 case tok::annot_pragma_fp:
864 case tok::annot_pragma_opencl_extension:
865 HandlePragmaOpenCLExtension();
867 case tok::annot_attr_openmp:
868 case tok::annot_pragma_openmp: {
870 return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
872 case tok::annot_pragma_openacc:
874 case tok::annot_pragma_ms_pointers_to_members:
875 HandlePragmaMSPointersToMembers();
877 case tok::annot_pragma_ms_vtordisp:
878 HandlePragmaMSVtorDisp();
880 case tok::annot_pragma_ms_pragma:
881 HandlePragmaMSPragma();
883 case tok::annot_pragma_dump:
886 case tok::annot_pragma_attribute:
887 HandlePragmaAttribute();
893 ConsumeExtraSemi(OutsideFunction);
896 Diag(Tok, diag::err_extraneous_closing_brace);
900 Diag(Tok, diag::err_expected_external_declaration);
902 case tok::kw___extension__: {
906 return ParseExternalDeclaration(Attrs, DeclSpecAttrs);
909 ProhibitAttributes(Attrs);
920 const auto *SL = cast<StringLiteral>(
Result.get());
921 if (!SL->getString().trim().empty())
922 Diag(StartLoc, diag::err_gnu_inline_asm_disabled);
925 ExpectAndConsume(tok::semi, diag::err_expected_after,
926 "top-level asm block");
934 return ParseObjCAtDirectives(Attrs, DeclSpecAttrs);
938 Diag(Tok, diag::err_expected_external_declaration);
942 SingleDecl = ParseObjCMethodDefinition();
944 case tok::code_completion:
946 if (CurParsedObjCImpl) {
955 if (CurParsedObjCImpl) {
964 case tok::kw_import: {
967 llvm_unreachable(
"not expecting a c++20 import here");
968 ProhibitAttributes(Attrs);
974 ProhibitAttributes(Attrs);
975 SingleDecl = ParseExportDeclaration();
982 case tok::kw_namespace:
983 case tok::kw_typedef:
984 case tok::kw_template:
985 case tok::kw_static_assert:
986 case tok::kw__Static_assert:
994 case tok::kw_cbuffer:
995 case tok::kw_tbuffer:
1003 case tok::kw_static:
1015 case tok::kw_inline:
1020 if (NextKind == tok::kw_namespace) {
1028 if (NextKind == tok::kw_template) {
1038 case tok::kw_extern:
1044 diag::warn_cxx98_compat_extern_template :
1045 diag::ext_extern_template) <<
SourceRange(ExternLoc, TemplateLoc);
1048 TemplateLoc, DeclEnd, Attrs);
1052 case tok::kw___if_exists:
1053 case tok::kw___if_not_exists:
1054 ParseMicrosoftIfExistsExternalDeclaration();
1057 case tok::kw_module:
1058 Diag(Tok, diag::err_unexpected_module_decl);
1069 !isDeclarationStatement(
true))
1070 return ParseTopLevelStmtDecl();
1074 return ParseDeclarationOrFunctionDefinition(Attrs, DeclSpecAttrs, DS);
1084bool Parser::isDeclarationAfterDeclarator() {
1088 if (KW.
is(tok::kw_default) || KW.
is(tok::kw_delete))
1092 return Tok.
is(tok::equal) ||
1093 Tok.
is(tok::comma) ||
1094 Tok.
is(tok::semi) ||
1095 Tok.
is(tok::kw_asm) ||
1096 Tok.
is(tok::kw___attribute) ||
1098 Tok.
is(tok::l_paren));
1105 if (Tok.
is(tok::l_brace))
1115 return KW.
is(tok::kw_default) || KW.
is(tok::kw_delete);
1118 return Tok.
is(tok::colon) ||
1119 Tok.
is(tok::kw_try);
1145 "expected uninitialised source range");
1150 ParsedTemplateInfo TemplateInfo;
1153 ParseDeclarationSpecifiers(DS, TemplateInfo, AS,
1154 DeclSpecContext::DSC_top_level);
1159 DS, AS, DeclSpecContext::DSC_top_level))
1164 if (Tok.
is(tok::semi)) {
1179 llvm_unreachable(
"we only expect to get the length of the class/struct/union/enum");
1189 ProhibitAttributes(Attrs, CorrectLocationForAttributes);
1197 Decl* decls[] = {AnonRecord, TheDecl};
1214 Diag(Tok, diag::err_objc_unexpected_attr);
1222 const char *PrevSpec =
nullptr;
1226 Diag(AtLoc, DiagID) << PrevSpec;
1229 return ParseObjCAtProtocolDeclaration(AtLoc, DS.
getAttributes());
1232 return ParseObjCAtImplementationDeclaration(AtLoc, DS.
getAttributes());
1235 ParseObjCAtInterfaceDeclaration(AtLoc, DS.
getAttributes()));
1244 ProhibitAttributes(Attrs);
1257 llvm::TimeTraceScope TimeScope(
"ParseDeclarationOrFunctionDefinition", [&]() {
1263 return ParseDeclOrFunctionDefInternal(Attrs, DeclSpecAttrs, *DS, AS);
1271 return ParseDeclOrFunctionDefInternal(Attrs, DeclSpecAttrs, PDS, AS);
1290 const ParsedTemplateInfo &TemplateInfo,
1291 LateParsedAttrList *LateParsedAttrs) {
1292 llvm::TimeTraceScope TimeScope(
"ParseFunctionDefinition", [&]() {
1299 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1304 if (
getLangOpts().isImplicitIntRequired() &&
D.getDeclSpec().isEmpty()) {
1305 Diag(
D.getIdentifierLoc(), diag::warn_missing_type_specifier)
1307 const char *PrevSpec;
1311 D.getIdentifierLoc(),
1321 ParseKNRParamDeclarations(
D);
1325 if (Tok.
isNot(tok::l_brace) &&
1327 (Tok.
isNot(tok::colon) && Tok.
isNot(tok::kw_try) &&
1328 Tok.
isNot(tok::equal)))) {
1329 Diag(Tok, diag::err_expected_fn_body);
1335 if (Tok.
isNot(tok::l_brace))
1341 if (Tok.
isNot(tok::equal)) {
1343 if (AL.isKnownToGCC() && !AL.isStandardAttributeSyntax())
1344 Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL;
1350 TemplateInfo.Kind == ParsedTemplateInfo::Template &&
1362 D.getMutableDeclSpec().abort();
1365 trySkippingFunctionBody()) {
1371 LexTemplateFunctionForLateParsing(Toks);
1380 else if (CurParsedObjCImpl &&
1381 !TemplateInfo.TemplateParams &&
1382 (Tok.
is(tok::l_brace) || Tok.
is(tok::kw_try) ||
1383 Tok.
is(tok::colon)) &&
1392 D.complete(FuncDecl);
1393 D.getMutableDeclSpec().abort();
1396 StashAwayMethodOrFunctionBodyTokens(FuncDecl);
1397 CurParsedObjCImpl->HasCFunction =
true;
1417 ? diag::warn_cxx98_compat_defaulted_deleted_function
1418 : diag::ext_defaulted_deleted_function)
1421 DeletedMessage = ParseCXXDeletedFunctionMessage();
1424 ? diag::warn_cxx98_compat_defaulted_deleted_function
1425 : diag::ext_defaulted_deleted_function)
1429 llvm_unreachable(
"function definition after = not 'delete' or 'default'");
1432 if (Tok.
is(tok::comma)) {
1433 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration)
1436 }
else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
1450 TemplateInfo.TemplateParams
1451 ? *TemplateInfo.TemplateParams
1453 &SkipBody, BodyKind);
1479 D.getMutableDeclSpec().abort();
1483 Stmt *GeneratedBody = Res ? Res->
getBody() :
nullptr;
1490 if (
const auto *Template = dyn_cast_if_present<FunctionTemplateDecl>(Res);
1491 Template && Template->isAbbreviated() &&
1492 Template->getTemplateParameters()->getParam(0)->isImplicit())
1495 CurTemplateDepthTracker.addDepth(1);
1498 trySkippingFunctionBody()) {
1504 if (Tok.
is(tok::kw_try))
1505 return ParseFunctionTryBlock(Res, BodyScope);
1509 if (Tok.
is(tok::colon)) {
1510 ParseConstructorInitializer(Res);
1513 if (!Tok.
is(tok::l_brace)) {
1522 if (LateParsedAttrs)
1523 ParseLexedAttributeList(*LateParsedAttrs, Res,
false,
true);
1525 return ParseFunctionStatementBody(Res, BodyScope);
1528void Parser::SkipFunctionBody() {
1529 if (Tok.
is(tok::equal)) {
1534 bool IsFunctionTryBlock = Tok.
is(tok::kw_try);
1535 if (IsFunctionTryBlock)
1539 if (ConsumeAndStoreFunctionPrologue(Skipped))
1543 while (IsFunctionTryBlock && Tok.
is(tok::kw_catch)) {
1552void Parser::ParseKNRParamDeclarations(
Declarator &
D) {
1567 ParsedTemplateInfo TemplateInfo;
1568 ParseDeclarationSpecifiers(DS, TemplateInfo);
1576 Diag(DSStart, diag::err_declaration_does_not_declare_param);
1585 diag::err_invalid_storage_class_in_func_decl);
1590 diag::err_invalid_storage_class_in_func_decl);
1597 ParseDeclarator(ParmDeclarator);
1602 MaybeParseGNUAttributes(ParmDeclarator);
1610 ParmDeclarator.getIdentifier()) {
1614 for (
unsigned i = 0; ; ++i) {
1618 Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param)
1619 << ParmDeclarator.getIdentifier();
1623 if (FTI.
Params[i].
Ident == ParmDeclarator.getIdentifier()) {
1626 Diag(ParmDeclarator.getIdentifierLoc(),
1627 diag::err_param_redefinition)
1628 << ParmDeclarator.getIdentifier();
1639 if (Tok.
isNot(tok::comma))
1642 ParmDeclarator.clear();
1648 ParseDeclarator(ParmDeclarator);
1652 if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration))
1675ExprResult Parser::ParseAsmStringLiteral(
bool ForAsmLabel) {
1676 if (!isTokenStringLiteral()) {
1677 Diag(Tok, diag::err_expected_string_literal)
1683 if (!AsmString.isInvalid()) {
1684 const auto *SL = cast<StringLiteral>(AsmString.get());
1685 if (!SL->isOrdinary()) {
1686 Diag(Tok, diag::err_asm_operand_wide_string_literal)
1688 << SL->getSourceRange();
1691 if (ForAsmLabel && SL->getString().empty()) {
1692 Diag(Tok, diag::err_asm_operand_wide_string_literal)
1693 << 2 << SL->getSourceRange();
1706 assert(Tok.
is(tok::kw_asm) &&
"Not an asm!");
1709 if (isGNUAsmQualifier(Tok)) {
1713 Diag(Tok, diag::err_global_asm_qualifier_ignored)
1714 << GNUAsmQualifiers::getQualifierName(getGNUAsmQualifier(Tok))
1720 if (
T.consumeOpen()) {
1721 Diag(Tok, diag::err_expected_lparen_after) <<
"asm";
1727 if (!
Result.isInvalid()) {
1731 *EndLoc =
T.getCloseLocation();
1745 assert(tok.
is(tok::annot_template_id) &&
"Expected template-id token");
1751void Parser::AnnotateScopeToken(
CXXScopeSpec &SS,
bool IsNewAnnotation) {
1758 Tok.
setKind(tok::annot_cxxscope);
1765 if (IsNewAnnotation)
1779Parser::AnnotatedNameKind
1782 assert(Tok.
is(tok::identifier) || Tok.
is(tok::annot_cxxscope));
1784 const bool EnteringContext =
false;
1785 const bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
1789 ParseOptionalCXXScopeSpecifier(SS,
nullptr,
1796 AllowImplicitTypename))
1798 return ANK_Unresolved;
1806 if (isTentativelyDeclared(Name) && SS.
isEmpty()) {
1810 AllowImplicitTypename))
1812 return Tok.
is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl;
1829 isTemplateArgumentList(1) == TPResult::False) {
1831 Token FakeNext = Next;
1832 FakeNext.
setKind(tok::unknown);
1835 SS.
isEmpty() ? CCC :
nullptr);
1838 switch (Classification.
getKind()) {
1845 Tok.
setKind(Name->getTokenID());
1848 AnnotateScopeToken(SS, !WasScopeAnnotation);
1857 if (TryAltiVecVectorToken())
1881 else if (Tok.
is(tok::eof))
1885 Tok.
setKind(tok::annot_typename);
1886 setTypeAnnotation(Tok, Ty);
1894 Tok.
setKind(tok::annot_overload_set);
1903 if (TryAltiVecVectorToken())
1908 Tok.
setKind(tok::annot_non_type);
1914 AnnotateScopeToken(SS, !WasScopeAnnotation);
1920 ? tok::annot_non_type_undeclared
1921 : tok::annot_non_type_dependent);
1922 setIdentifierAnnotation(Tok, Name);
1927 AnnotateScopeToken(SS, !WasScopeAnnotation);
1931 if (Next.isNot(tok::less)) {
1934 AnnotateScopeToken(SS, !WasScopeAnnotation);
1935 return ANK_TemplateName;
1945 if (Next.is(tok::less))
1948 Id.setIdentifier(Name, NameLoc);
1949 if (AnnotateTemplateIdToken(
1956 AnnotateScopeToken(SS, !WasScopeAnnotation);
1963 AnnotateScopeToken(SS, !WasScopeAnnotation);
1964 return ANK_Unresolved;
1967bool Parser::TryKeywordIdentFallback(
bool DisableKeyword) {
1968 assert(Tok.
isNot(tok::identifier));
1969 Diag(Tok, diag::ext_keyword_as_ident)
2002 assert((Tok.
is(tok::identifier) || Tok.
is(tok::coloncolon) ||
2003 Tok.
is(tok::kw_typename) || Tok.
is(tok::annot_cxxscope) ||
2004 Tok.
is(tok::kw_decltype) || Tok.
is(tok::annot_template_id) ||
2005 Tok.
is(tok::kw___super) || Tok.
is(tok::kw_auto) ||
2006 Tok.
is(tok::annot_pack_indexing_type)) &&
2007 "Cannot be a type or scope token!");
2009 if (Tok.
is(tok::kw_typename)) {
2018 PP.
Lex(TypedefToken);
2023 Diag(Tok.
getLocation(), diag::warn_expected_qualified_after_typename);
2035 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2041 if (Tok.
is(tok::identifier) || Tok.
is(tok::annot_template_id) ||
2042 Tok.
is(tok::annot_decltype)) {
2044 if (Tok.
is(tok::annot_decltype) ||
2047 unsigned DiagID = diag::err_expected_qualified_after_typename;
2051 DiagID = diag::warn_expected_qualified_after_typename;
2063 bool TemplateKWPresent =
false;
2064 if (Tok.
is(tok::kw_template)) {
2066 TemplateKWPresent =
true;
2070 if (Tok.
is(tok::identifier)) {
2071 if (TemplateKWPresent &&
NextToken().isNot(tok::less)) {
2073 diag::missing_template_arg_list_after_template_kw);
2079 }
else if (Tok.
is(tok::annot_template_id)) {
2082 Diag(Tok, diag::err_typename_refers_to_non_type_template)
2096 TemplateArgsPtr, TemplateId->
RAngleLoc);
2098 Diag(Tok, diag::err_expected_type_name_after_typename)
2104 Tok.
setKind(tok::annot_typename);
2105 setTypeAnnotation(Tok, Ty);
2113 bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
2117 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2123 AllowImplicitTypename);
2132 if (Tok.
is(tok::identifier)) {
2136 false,
NextToken().is(tok::period),
nullptr,
2139 true, AllowImplicitTypename)) {
2158 else if (Tok.
is(tok::eof))
2164 Tok.
setKind(tok::annot_typename);
2165 setTypeAnnotation(Tok, Ty);
2189 bool MemberOfUnknownSpecialization;
2193 nullptr,
false, Template,
2194 MemberOfUnknownSpecialization)) {
2198 isTemplateArgumentList(1) != TPResult::False) {
2218 if (Tok.
is(tok::annot_template_id)) {
2225 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
2234 AnnotateScopeToken(SS, IsNewScope);
2246 "Call sites of this function should be guarded by checking for C++");
2250 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2257 AnnotateScopeToken(SS,
true);
2261bool Parser::isTokenEqualOrEqualTypo() {
2267 case tok::starequal:
2268 case tok::plusequal:
2269 case tok::minusequal:
2270 case tok::exclaimequal:
2271 case tok::slashequal:
2272 case tok::percentequal:
2273 case tok::lessequal:
2274 case tok::lesslessequal:
2275 case tok::greaterequal:
2276 case tok::greatergreaterequal:
2277 case tok::caretequal:
2278 case tok::pipeequal:
2279 case tok::equalequal:
2280 Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal)
2290 assert(Tok.
is(tok::code_completion));
2294 if (S->isFunctionScope()) {
2298 return PrevTokLocation;
2301 if (S->isClassScope()) {
2305 return PrevTokLocation;
2312 return PrevTokLocation;
2317void Parser::CodeCompleteDirective(
bool InConditional) {
2321void Parser::CodeCompleteInConditionalExclusion() {
2326void Parser::CodeCompleteMacroName(
bool IsDefinition) {
2330void Parser::CodeCompletePreprocessorExpression() {
2336 unsigned ArgumentIndex) {
2341void Parser::CodeCompleteIncludedFile(llvm::StringRef Dir,
bool IsAngled) {
2345void Parser::CodeCompleteNaturalLanguage() {
2349bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition&
Result) {
2350 assert((Tok.
is(tok::kw___if_exists) || Tok.
is(tok::kw___if_not_exists)) &&
2351 "Expected '__if_exists' or '__if_not_exists'");
2352 Result.IsIfExists = Tok.
is(tok::kw___if_exists);
2356 if (
T.consumeOpen()) {
2357 Diag(Tok, diag::err_expected_lparen_after)
2358 << (
Result.IsIfExists?
"__if_exists" :
"__if_not_exists");
2364 ParseOptionalCXXScopeSpecifier(
Result.SS,
nullptr,
2369 if (
Result.SS.isInvalid()) {
2380 false, &TemplateKWLoc,
2386 if (
T.consumeClose())
2394 Result.Behavior =
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2398 Result.Behavior = !
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2402 Result.Behavior = IEB_Dependent;
2412void Parser::ParseMicrosoftIfExistsExternalDeclaration() {
2413 IfExistsCondition
Result;
2414 if (ParseMicrosoftIfExistsCondition(
Result))
2418 if (
Braces.consumeOpen()) {
2419 Diag(Tok, diag::err_expected) << tok::l_brace;
2423 switch (
Result.Behavior) {
2429 llvm_unreachable(
"Cannot have a dependent external declaration");
2438 while (Tok.
isNot(tok::r_brace) && !isEofOrEom()) {
2440 MaybeParseCXX11Attributes(Attrs);
2471 (Tok.
is(tok::kw_module) ||
2473 "not a module declaration");
2478 DiagnoseAndSkipCXX11Attributes();
2484 Diag(StartLoc, diag::err_global_module_introducer_not_at_start)
2489 Diag(StartLoc, diag::err_module_fragment_exported)
2500 Diag(StartLoc, diag::err_module_fragment_exported)
2505 DiagnoseAndSkipCXX11Attributes();
2506 ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);
2514 if (ParseModuleName(ModuleLoc,
Path,
false))
2519 if (Tok.
is(tok::colon)) {
2522 Diag(ColonLoc, diag::err_unsupported_module_partition)
2523 <<
SourceRange(ColonLoc, Partition.back().second);
2525 else if (ParseModuleName(ModuleLoc, Partition,
false))
2531 MaybeParseCXX11Attributes(Attrs);
2532 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr,
2533 diag::err_keyword_not_module_attr,
2537 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2567 "Improper start to module import");
2573 bool IsPartition =
false;
2574 Module *HeaderUnit =
nullptr;
2575 if (Tok.
is(tok::header_name)) {
2580 }
else if (Tok.
is(tok::annot_header_unit)) {
2583 ConsumeAnnotationToken();
2584 }
else if (Tok.
is(tok::colon)) {
2587 Diag(ColonLoc, diag::err_unsupported_module_partition)
2590 else if (ParseModuleName(ColonLoc,
Path,
true))
2595 if (ParseModuleName(ImportLoc,
Path,
true))
2600 MaybeParseCXX11Attributes(Attrs);
2602 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr,
2603 diag::err_keyword_not_import_attr,
2614 bool SeenError =
true;
2615 switch (ImportState) {
2627 Diag(ImportLoc, diag::err_partition_import_outside_module);
2639 if (IsPartition || (HeaderUnit && HeaderUnit->
Kind !=
2641 Diag(ImportLoc, diag::err_import_in_wrong_fragment)
2650 Diag(ImportLoc, diag::err_import_not_allowed_here);
2656 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2664 else if (!
Path.empty())
2667 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2673 if (IsObjCAtImport && AtLoc.
isValid()) {
2676 if (FE && llvm::sys::path::parent_path(FE->getDir().getName())
2677 .ends_with(
".framework"))
2678 Diags.
Report(AtLoc, diag::warn_atimport_in_framework_header);
2691bool Parser::ParseModuleName(
2697 if (!Tok.
is(tok::identifier)) {
2698 if (Tok.
is(tok::code_completion)) {
2704 Diag(Tok, diag::err_module_expected_ident) << IsImport;
2713 if (Tok.
isNot(tok::period))
2724bool Parser::parseMisplacedModuleImport() {
2727 case tok::annot_module_end:
2731 if (MisplacedModuleBeginCount) {
2732 --MisplacedModuleBeginCount;
2736 ConsumeAnnotationToken();
2743 case tok::annot_module_begin:
2748 ConsumeAnnotationToken();
2749 ++MisplacedModuleBeginCount;
2751 case tok::annot_module_include:
2757 ConsumeAnnotationToken();
2767void Parser::diagnoseUseOfC11Keyword(
const Token &Tok) {
2772 : diag::ext_c11_feature)
2776bool BalancedDelimiterTracker::diagnoseOverflow() {
2777 P.
Diag(P.Tok, diag::err_bracket_depth_exceeded)
2779 P.
Diag(P.Tok, diag::note_bracket_depth);
2788 if (P.ExpectAndConsume(Kind, DiagID, Msg)) {
2789 if (SkipToTok != tok::unknown)
2797 return diagnoseOverflow();
2800bool BalancedDelimiterTracker::diagnoseMissingClose() {
2801 assert(!P.Tok.
is(Close) &&
"Should have consumed closing delimiter");
2803 if (P.Tok.
is(tok::annot_module_end))
2804 P.
Diag(P.Tok, diag::err_missing_before_module_end) << Close;
2806 P.
Diag(P.Tok, diag::err_expected) << Close;
2807 P.
Diag(LOpen, diag::note_matching) << Kind;
2811 if (P.Tok.
isNot(tok::r_paren) && P.Tok.
isNot(tok::r_brace) &&
2812 P.Tok.
isNot(tok::r_square) &&
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
static Decl::Kind getKind(const Decl *D)
Defines the C++ template declaration subclasses.
Defines the clang::FileManager interface and associated types.
static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok)
static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R)
static std::string getName(const CallEvent &Call)
This file declares facilities that support code completion.
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
SourceManager & getSourceManager()
const clang::PrintingPolicy & getPrintingPolicy() const
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
The result of parsing/analyzing an expression, statement etc.
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....
bool expectAndConsume(unsigned DiagID=diag::err_expected, const char *Msg="", tok::TokenKind SkipToTok=tok::unknown)
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 isInvalid() const
An error occurred during parsing of the scope specifier.
bool isEmpty() const
No scope specifier.
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool isTranslationUnit() const
Captures information about "declaration specifiers".
void ClearStorageClassSpecs()
TST getTypeSpecType() const
SourceLocation getStorageClassSpecLoc() const
SCS getStorageClassSpec() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
SourceRange getSourceRange() const LLVM_READONLY
void SetRangeEnd(SourceLocation Loc)
static const TST TST_interface
void SetRangeStart(SourceLocation Loc)
static const TST TST_union
TSCS getThreadStorageClassSpec() const
ParsedAttributes & getAttributes()
static const TST TST_enum
static bool isDeclRep(TST T)
static const TST TST_class
bool hasTagDefinition() const
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
static const TSCS TSCS_unspecified
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
SourceLocation getThreadStorageClassSpecLoc() const
Decl * getRepAsDecl() const
static const TST TST_unspecified
SourceLocation getTypeSpecTypeLoc() const
void takeAttributesFrom(ParsedAttributes &attrs)
@ PQ_StorageClassSpecifier
static const TST TST_struct
Decl - This represents one declaration (or definition), e.g.
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Information about one declarator, including the parsed type information and the identifier.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
A little helper class used to produce diagnostics.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them.
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.
Represents a function declaration or definition.
One of these records is kept for each identifier that is lexed.
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Encapsulates the data about a macro definition (e.g.
Describes a module or submodule.
ModuleKind Kind
The kind of this module.
bool isHeaderUnit() const
Is this module a header unit.
@ ModuleHeaderUnit
This is a C++20 header unit.
Wrapper for void* pointer.
static OpaquePtr make(TemplateName 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.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, bool IsNewScope, ImplicitTypenameContext AllowImplicitTypename)
Try to annotate a type or scope token, having already parsed an optional scope specifier.
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
DeclGroupPtrTy ParseOpenACCDirectiveDecl()
Placeholder for now, should just ignore the directives after emitting a diagnostic.
Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)
void EnterScope(unsigned ScopeFlags)
EnterScope - Start a new scope.
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.
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.
bool TryConsumeToken(tok::TokenKind Expected)
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Scope * getCurScope() 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 ...
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
friend class ObjCDeclContextSwitch
void ExitScope()
ExitScope - Pop a scope off the scope stack.
const LangOptions & getLangOpts() const
bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result, Sema::ModuleImportState &ImportState)
Parse the first top-level declaration in a translation unit.
SkipUntilFlags
Control flags for SkipUntil functions.
@ StopBeforeMatch
Stop skipping at specified token, but don't skip the token itself.
@ StopAtCodeCompletion
Stop at code completion.
@ StopAtSemi
Stop skipping at semicolon.
bool TryAnnotateTypeOrScopeToken(ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No)
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
bool MightBeCXXScopeToken()
ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral=false)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
SmallVector< TemplateParameterList *, 4 > TemplateParameterLists
void Initialize()
Initialize - Warm up the parser.
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...
A class for parsing a DeclSpec.
A class for parsing a declarator.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
void setCodeCompletionHandler(CodeCompletionHandler &Handler)
Set the code completion handler to the given object.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
void EnterToken(const Token &Tok, bool IsReinject)
Enters a token in the token stream to be lexed next.
void TypoCorrectToken(const Token &Tok)
Update the current token to represent the provided identifier, in order to cache an action performed ...
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.
void addCommentHandler(CommentHandler *Handler)
Add the specified comment handler to the preprocessor.
void removeCommentHandler(CommentHandler *Handler)
Remove the specified comment handler.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
bool isBacktrackEnabled() const
True if EnableBacktrackAtThisPos() was called and caching of tokens is on.
void SetPoisonReason(IdentifierInfo *II, unsigned DiagID)
Specifies the reason for poisoning an identifier.
void RevertCachedTokens(unsigned N)
When backtracking is enabled and tokens are cached, this allows to revert a specific number of tokens...
unsigned getTokenCount() const
Get the number of tokens processed so far.
unsigned getMaxTokens() const
Get the max number of tokens before issuing a -Wmax-tokens warning.
SourceLocation getMaxTokensOverrideLoc() const
bool hadModuleLoaderFatalFailure() const
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
IdentifierTable & getIdentifierTable()
void clearCodeCompletionHandler()
Clear out the code completion handler.
bool isCodeCompletionReached() const
Returns true if code-completion is enabled and we have hit the code-completion point.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
Represents a struct/union/class.
Scope - A scope is a transient data structure that is used while parsing the program.
void Init(Scope *parent, unsigned flags)
Init - This is used by the parser to implement scope caching.
const Scope * getParent() const
getParent - Return the scope that this is nested in.
@ FunctionPrototypeScope
This is a scope that corresponds to the parameters within a function prototype.
@ 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.
ParserCompletionContext
Describes the context in which code completion occurs.
@ PCC_TopLevelOrExpression
Code completion occurs at top-level in a REPL session.
@ PCC_Class
Code completion occurs within a class, struct, or union.
@ PCC_ObjCImplementation
Code completion occurs within an Objective-C implementation or category implementation.
@ PCC_Namespace
Code completion occurs at top-level or namespace context.
@ PCC_RecoveryInFunction
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
void CodeCompletePreprocessorMacroName(bool IsDefinition)
void CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
void CodeCompletePreprocessorExpression()
void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)
void CodeCompletePreprocessorMacroArgument(Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument)
void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
void CodeCompleteObjCMethodDecl(Scope *S, std::optional< bool > IsInstanceMethod, ParsedType ReturnType)
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
void CodeCompleteNaturalLanguage()
void CodeCompletePreprocessorDirective(bool InConditional)
Records and restores the CurFPFeatures state on entry/exit of compound statements.
ExprResult getExpression() const
NameClassificationKind getKind() const
NamedDecl * getNonTypeDecl() const
TemplateName getTemplateName() const
ParsedType getType() const
TemplateNameKind getTemplateNameKind() const
Sema - This implements semantic analysis and AST building for C.
void ActOnPopScope(SourceLocation Loc, Scope *S)
void ActOnDefinedDeclarationSpecifier(Decl *D)
Called once it is known whether a tag declaration is an anonymous union or struct.
Decl * ActOnSkippedFunctionBody(Decl *Decl)
void ActOnAnnotModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
void ActOnAnnotModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
@ IER_DoesNotExist
The symbol does not exist.
@ IER_Dependent
The name is a dependent name, so the results will differ from one instantiation to the next.
@ IER_Error
An error occurred.
@ IER_Exists
The symbol exists.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D, SourceLocation ExplicitThisLoc={})
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
@ Interface
'export module X;'
@ Implementation
'module X;'
void SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind, StringLiteral *DeletedMessage=nullptr)
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
void ActOnComment(SourceRange Comment)
@ Other
C++26 [dcl.fct.def.general]p1 function-body: ctor-initializer[opt] compound-statement function-try-bl...
@ Delete
deleted-function-body
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
void ActOnTranslationUnitScope(Scope *S)
Scope actions.
DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, ModuleIdPath Partition, ModuleImportState &ImportState)
The parser has processed a module-declaration that begins the definition of a module interface or imp...
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization, bool Disambiguation=false)
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
DeclarationNameInfo GetNameForDeclarator(Declarator &D)
GetNameForDeclarator - Determine the full declaration name for the given Declarator.
void ActOnAnnotModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
DeclResult ActOnModuleImport(SourceLocation StartLoc, SourceLocation ExportLoc, SourceLocation ImportLoc, ModuleIdPath Path, bool IsPartition=false)
The parser has processed a module import declaration.
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
ASTContext & getASTContext() const
@ NC_Unknown
This name is not a type or template in this context, but might be something else.
@ NC_VarTemplate
The name was classified as a variable template name.
@ NC_NonType
The name was classified as a specific non-type, non-template declaration.
@ NC_TypeTemplate
The name was classified as a template whose specializations are types.
@ NC_Error
Classification failed; an error has been produced.
@ NC_FunctionTemplate
The name was classified as a function template name.
@ NC_DependentNonType
The name denotes a member of a dependent type that could not be resolved.
@ NC_UndeclaredNonType
The name was classified as an ADL-only function name.
@ NC_UndeclaredTemplate
The name was classified as an ADL-only function template name.
@ NC_Keyword
The name has been typo-corrected to a keyword.
@ NC_Type
The name was classified as a type.
@ NC_OverloadSet
The name was classified as an overload set, and an expression representing that overload set has been...
@ NC_Concept
The name was classified as a concept name.
void PopExpressionEvaluationContext()
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
void * SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS)
Given a C++ nested-name-specifier, produce an annotation value that the parser can use later to recon...
void SetLateTemplateParser(LateTemplateParserCB *LTP, LateTemplateParserCleanupCB *LTPCleanup, void *P)
SemaCodeCompletion & CodeCompletion()
ASTConsumer & getASTConsumer() const
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr, FnBodyKind BodyKind=FnBodyKind::Other)
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used,...
std::function< TypeResult(StringRef, StringRef, SourceLocation)> ParseTypeFromStringCallback
Callback to the parser to parse a type expressed as a string.
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)
The parser has processed a global-module-fragment declaration that begins the definition of the globa...
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc)
The parser has processed a private-module-fragment declaration that begins the definition of the priv...
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc, ImplicitTypenameContext IsImplicitTypename=ImplicitTypenameContext::No)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
void ActOnStartOfTranslationUnit()
This is called before the very first declaration in the translation unit is parsed.
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, ImplicitTypenameContext AllowImplicitTypename=ImplicitTypenameContext::No, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type.
ModuleImportState
An enumeration to represent the transition of states in parsing module fragments and imports.
@ PrivateFragmentImportFinished
after 'module :private;' but a non-import decl has already been seen.
@ ImportFinished
after any non-import decl.
@ PrivateFragmentImportAllowed
after 'module :private;' but before any non-import decl.
@ FirstDecl
Parsing the first decl in a TU.
@ GlobalFragment
after 'module;' but before 'module X;'
@ NotACXX20Module
Not a C++20 TU, or an invalid state was found.
@ ImportAllowed
after 'module X;' but before any non-import decl.
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e....
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
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.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
OptionalFileEntryRef getFileEntryRefForID(FileID FID) const
Returns the FileEntryRef for the provided FileID.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
Stmt - This represents one statement.
StringLiteral - This represents a string literal expression, e.g.
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
bool isEditorPlaceholder() const
Returns true if this token is an editor placeholder.
void setKind(tok::TokenKind K)
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 isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
bool hasLeadingSpace() const
Return true if this token has whitespace before it.
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
void setLocation(SourceLocation L)
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
bool isNot(tok::TokenKind K) const
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
void setAnnotationValue(void *val)
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const
Return true if we have an ObjC keyword identifier.
void setAnnotationRange(SourceRange R)
void startToken()
Reset all flags to cleared.
void setIdentifierInfo(IdentifierInfo *II)
SourceLocation getLastLoc() const
bool isObjCObjectType() const
bool isObjCObjectPointerType() const
Represents a C++ unqualified-id that has been parsed.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
const char * getPunctuatorSpelling(TokenKind Kind) LLVM_READNONE
Determines the spelling of simple punctuation tokens like '!' or '', and returns NULL for literal and...
The JSON file list parser is used to communicate input to InstallAPI.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
TypeSpecifierType
Specifies the kind of type.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
@ TNK_Type_template
The name refers to a template whose specialization produces a type.
@ TNK_Undeclared_template
Lookup for the name failed, but we're assuming it was a template name anyway.
const FunctionProtoType * T
llvm::StringRef getAsString(SyncScope S)
@ Braces
New-expression has a C++11 list-initializer.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
bool isKNRPrototype() const
isKNRPrototype - Return true if this is a K&R style identifier list, like "void foo(a,...
const IdentifierInfo * Ident
Wraps an identifier and optional source location for the identifier.
Describes how types, statements, expressions, and declarations should be printed.
Information about a template-id annotation token.
const IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
TemplateNameKind Kind
The kind of template that Template refers to.
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.
bool mightBeType() const
Determine whether this might be a type template.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.