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);
1307 const char *PrevSpec;
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 &&
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)) &&
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);
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;
2064 if (Tok.
is(tok::identifier)) {
2069 }
else if (Tok.
is(tok::annot_template_id)) {
2072 Diag(Tok, diag::err_typename_refers_to_non_type_template)
2086 TemplateArgsPtr, TemplateId->
RAngleLoc);
2088 Diag(Tok, diag::err_expected_type_name_after_typename)
2094 Tok.
setKind(tok::annot_typename);
2095 setTypeAnnotation(Tok, Ty);
2103 bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
2107 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2113 AllowImplicitTypename);
2122 if (Tok.
is(tok::identifier)) {
2126 false,
NextToken().is(tok::period),
nullptr,
2129 true, AllowImplicitTypename)) {
2148 else if (Tok.
is(tok::eof))
2154 Tok.
setKind(tok::annot_typename);
2155 setTypeAnnotation(Tok, Ty);
2179 bool MemberOfUnknownSpecialization;
2183 nullptr,
false, Template,
2184 MemberOfUnknownSpecialization)) {
2188 isTemplateArgumentList(1) != TPResult::False) {
2208 if (Tok.
is(tok::annot_template_id)) {
2215 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
2224 AnnotateScopeToken(SS, IsNewScope);
2236 "Call sites of this function should be guarded by checking for C++");
2240 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2247 AnnotateScopeToken(SS,
true);
2251bool Parser::isTokenEqualOrEqualTypo() {
2257 case tok::starequal:
2258 case tok::plusequal:
2259 case tok::minusequal:
2260 case tok::exclaimequal:
2261 case tok::slashequal:
2262 case tok::percentequal:
2263 case tok::lessequal:
2264 case tok::lesslessequal:
2265 case tok::greaterequal:
2266 case tok::greatergreaterequal:
2267 case tok::caretequal:
2268 case tok::pipeequal:
2269 case tok::equalequal:
2270 Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal)
2280 assert(Tok.
is(tok::code_completion));
2284 if (S->isFunctionScope()) {
2288 return PrevTokLocation;
2291 if (S->isClassScope()) {
2295 return PrevTokLocation;
2302 return PrevTokLocation;
2307void Parser::CodeCompleteDirective(
bool InConditional) {
2311void Parser::CodeCompleteInConditionalExclusion() {
2316void Parser::CodeCompleteMacroName(
bool IsDefinition) {
2320void Parser::CodeCompletePreprocessorExpression() {
2326 unsigned ArgumentIndex) {
2331void Parser::CodeCompleteIncludedFile(llvm::StringRef Dir,
bool IsAngled) {
2335void Parser::CodeCompleteNaturalLanguage() {
2339bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition&
Result) {
2340 assert((Tok.
is(tok::kw___if_exists) || Tok.
is(tok::kw___if_not_exists)) &&
2341 "Expected '__if_exists' or '__if_not_exists'");
2342 Result.IsIfExists = Tok.
is(tok::kw___if_exists);
2346 if (
T.consumeOpen()) {
2347 Diag(Tok, diag::err_expected_lparen_after)
2348 << (
Result.IsIfExists?
"__if_exists" :
"__if_not_exists");
2354 ParseOptionalCXXScopeSpecifier(
Result.SS,
nullptr,
2359 if (
Result.SS.isInvalid()) {
2370 false, &TemplateKWLoc,
2376 if (
T.consumeClose())
2384 Result.Behavior =
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2388 Result.Behavior = !
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2392 Result.Behavior = IEB_Dependent;
2402void Parser::ParseMicrosoftIfExistsExternalDeclaration() {
2403 IfExistsCondition
Result;
2404 if (ParseMicrosoftIfExistsCondition(
Result))
2408 if (
Braces.consumeOpen()) {
2409 Diag(Tok, diag::err_expected) << tok::l_brace;
2413 switch (
Result.Behavior) {
2419 llvm_unreachable(
"Cannot have a dependent external declaration");
2428 while (Tok.
isNot(tok::r_brace) && !isEofOrEom()) {
2430 MaybeParseCXX11Attributes(Attrs);
2461 (Tok.
is(tok::kw_module) ||
2463 "not a module declaration");
2468 DiagnoseAndSkipCXX11Attributes();
2474 Diag(StartLoc, diag::err_global_module_introducer_not_at_start)
2479 Diag(StartLoc, diag::err_module_fragment_exported)
2490 Diag(StartLoc, diag::err_module_fragment_exported)
2495 DiagnoseAndSkipCXX11Attributes();
2496 ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);
2504 if (ParseModuleName(ModuleLoc, Path,
false))
2509 if (Tok.
is(tok::colon)) {
2512 Diag(ColonLoc, diag::err_unsupported_module_partition)
2513 <<
SourceRange(ColonLoc, Partition.back().second);
2515 else if (ParseModuleName(ModuleLoc, Partition,
false))
2521 MaybeParseCXX11Attributes(Attrs);
2522 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr,
2523 diag::err_keyword_not_module_attr,
2527 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2529 return Actions.
ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
2557 "Improper start to module import");
2563 bool IsPartition =
false;
2564 Module *HeaderUnit =
nullptr;
2565 if (Tok.
is(tok::header_name)) {
2570 }
else if (Tok.
is(tok::annot_header_unit)) {
2573 ConsumeAnnotationToken();
2574 }
else if (Tok.
is(tok::colon)) {
2577 Diag(ColonLoc, diag::err_unsupported_module_partition)
2580 else if (ParseModuleName(ColonLoc, Path,
true))
2585 if (ParseModuleName(ImportLoc, Path,
true))
2590 MaybeParseCXX11Attributes(Attrs);
2592 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr,
2593 diag::err_keyword_not_import_attr,
2604 bool SeenError =
true;
2605 switch (ImportState) {
2617 Diag(ImportLoc, diag::err_partition_import_outside_module);
2629 if (IsPartition || (HeaderUnit && HeaderUnit->
Kind !=
2631 Diag(ImportLoc, diag::err_import_in_wrong_fragment)
2640 Diag(ImportLoc, diag::err_import_not_allowed_here);
2646 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2654 else if (!Path.empty())
2657 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2663 if (IsObjCAtImport && AtLoc.
isValid()) {
2666 if (FE && llvm::sys::path::parent_path(FE->getDir().getName())
2667 .ends_with(
".framework"))
2668 Diags.
Report(AtLoc, diag::warn_atimport_in_framework_header);
2681bool Parser::ParseModuleName(
2687 if (!Tok.
is(tok::identifier)) {
2688 if (Tok.
is(tok::code_completion)) {
2694 Diag(Tok, diag::err_module_expected_ident) << IsImport;
2703 if (Tok.
isNot(tok::period))
2714bool Parser::parseMisplacedModuleImport() {
2717 case tok::annot_module_end:
2721 if (MisplacedModuleBeginCount) {
2722 --MisplacedModuleBeginCount;
2726 ConsumeAnnotationToken();
2733 case tok::annot_module_begin:
2738 ConsumeAnnotationToken();
2739 ++MisplacedModuleBeginCount;
2741 case tok::annot_module_include:
2747 ConsumeAnnotationToken();
2757void Parser::diagnoseUseOfC11Keyword(
const Token &Tok) {
2762 : diag::ext_c11_feature)
2766bool BalancedDelimiterTracker::diagnoseOverflow() {
2767 P.
Diag(P.Tok, diag::err_bracket_depth_exceeded)
2769 P.
Diag(P.Tok, diag::note_bracket_depth);
2778 if (P.ExpectAndConsume(Kind, DiagID, Msg)) {
2779 if (SkipToTok != tok::unknown)
2787 return diagnoseOverflow();
2790bool BalancedDelimiterTracker::diagnoseMissingClose() {
2791 assert(!P.Tok.
is(Close) &&
"Should have consumed closing delimiter");
2793 if (P.Tok.
is(tok::annot_module_end))
2794 P.
Diag(P.Tok, diag::err_missing_before_module_end) << Close;
2796 P.
Diag(P.Tok, diag::err_expected) << Close;
2797 P.
Diag(LOpen, diag::note_matching) << Kind;
2801 if (P.Tok.
isNot(tok::r_paren) && P.Tok.
isNot(tok::r_brace) &&
2802 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
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
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.
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...
void SetRangeBegin(SourceLocation Loc)
SetRangeBegin - Set the start of the source range to Loc, unless it's invalid.
const ParsedAttributes & getAttributes() const
SourceLocation getIdentifierLoc() const
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
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.
const ParsingDeclSpec & getDeclSpec() const
ParsingDeclSpec & getMutableDeclSpec() const
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.