24#include "llvm/Support/Path.h"
35 explicit ActionCommentHandler(
Sema &S) : S(S) { }
53 : PP(pp), PreferredType(pp.isCodeCompletionEnabled()), Actions(actions),
54 Diags(PP.getDiagnostics()), GreaterThanIsOperator(
true),
55 ColonIsSacred(
false), InMessageExpression(
false),
56 TemplateParameterDepth(0), ParsingInObjCContainer(
false) {
60 Actions.CurScope =
nullptr;
62 CurParsedObjCImpl =
nullptr;
66 initializePragmaHandlers();
68 CommentSemaHandler.reset(
new ActionCommentHandler(actions));
75 return Diags.
Report(Loc, DiagID);
104 switch (ExpectedTok) {
106 return Tok.
is(tok::colon) || Tok.
is(tok::comma);
107 default:
return false;
111bool Parser::ExpectAndConsume(
tok::TokenKind ExpectedTok,
unsigned DiagID,
113 if (Tok.
is(ExpectedTok) || Tok.
is(tok::code_completion)) {
125 if (DiagID == diag::err_expected)
127 else if (DiagID == diag::err_expected_after)
128 DB << Msg << ExpectedTok;
139 const char *Spelling =
nullptr;
147 if (DiagID == diag::err_expected)
149 else if (DiagID == diag::err_expected_after)
150 DB << Msg << ExpectedTok;
157bool Parser::ExpectAndConsumeSemi(
unsigned DiagID, StringRef TokenUsed) {
161 if (Tok.
is(tok::code_completion)) {
162 handleUnexpectedCodeCompletionToken();
166 if ((Tok.
is(tok::r_paren) || Tok.
is(tok::r_square)) &&
168 Diag(Tok, diag::err_extraneous_token_before_semi)
176 return ExpectAndConsume(tok::semi, DiagID , TokenUsed);
179void Parser::ConsumeExtraSemi(ExtraSemiKind Kind,
DeclSpec::TST TST) {
180 if (!Tok.
is(tok::semi))
return;
182 bool HadMultipleSemis =
false;
188 HadMultipleSemis =
true;
197 Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi)
200 Diag(StartLoc, diag::ext_extra_semi_cxx11)
205 if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis)
206 Diag(StartLoc, diag::ext_extra_semi)
212 Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def)
216bool Parser::expectIdentifier() {
217 if (Tok.
is(tok::identifier))
221 Diag(Tok, diag::err_expected_token_instead_of_objcxx_keyword)
227 Diag(Tok, diag::err_expected) << tok::identifier;
242 Diag(FirstTokLoc, diag::warn_compound_token_split_by_macro)
243 << (FirstTokKind == Tok.
getKind()) << FirstTokKind << Tok.
getKind()
244 <<
static_cast<int>(Op) <<
SourceRange(FirstTokLoc);
245 Diag(SecondTokLoc, diag::note_compound_token_split_second_token_here)
255 SpaceLoc = FirstTokLoc;
256 Diag(SpaceLoc, diag::warn_compound_token_split_by_whitespace)
257 << (FirstTokKind == Tok.
getKind()) << FirstTokKind << Tok.
getKind()
258 <<
static_cast<int>(Op) <<
SourceRange(FirstTokLoc, SecondTokLoc);
268 return (
static_cast<unsigned>(L) &
static_cast<unsigned>(R)) != 0;
282 bool isFirstTokenSkipped =
true;
285 for (
unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) {
286 if (Tok.
is(Toks[i])) {
299 if (Toks.size() == 1 && Toks[0] == tok::eof &&
302 while (Tok.
isNot(tok::eof))
312 case tok::annot_pragma_openmp:
313 case tok::annot_attr_openmp:
314 case tok::annot_pragma_openmp_end:
316 if (OpenMPDirectiveParsing)
318 ConsumeAnnotationToken();
320 case tok::annot_module_begin:
321 case tok::annot_module_end:
322 case tok::annot_module_include:
328 case tok::code_completion:
330 handleUnexpectedCodeCompletionToken();
372 if (ParenCount && !isFirstTokenSkipped)
377 if (BracketCount && !isFirstTokenSkipped)
382 if (BraceCount && !isFirstTokenSkipped)
396 isFirstTokenSkipped =
false;
406 if (NumCachedScopes) {
407 Scope *N = ScopeCache[--NumCachedScopes];
409 Actions.CurScope = N;
424 Actions.CurScope = OldScope->
getParent();
426 if (NumCachedScopes == ScopeCacheSize)
429 ScopeCache[NumCachedScopes++] = OldScope;
434Parser::ParseScopeFlags::ParseScopeFlags(
Parser *Self,
unsigned ScopeFlags,
436 : CurScope(ManageFlags ? Self->getCurScope() : nullptr) {
438 OldFlags = CurScope->getFlags();
439 CurScope->setFlags(ScopeFlags);
445Parser::ParseScopeFlags::~ParseScopeFlags() {
447 CurScope->setFlags(OldFlags);
458 Actions.CurScope =
nullptr;
461 for (
unsigned i = 0, e = NumCachedScopes; i != e; ++i)
462 delete ScopeCache[i];
464 resetPragmaHandlers();
470 DestroyTemplateIds();
477 assert(
getCurScope() ==
nullptr &&
"A scope is already active?");
492 ObjCTypeQuals[objc_null_unspecified]
496 Ident_instancetype =
nullptr;
497 Ident_final =
nullptr;
498 Ident_sealed =
nullptr;
499 Ident_abstract =
nullptr;
500 Ident_override =
nullptr;
501 Ident_GNU_final =
nullptr;
502 Ident_import =
nullptr;
503 Ident_module =
nullptr;
507 Ident_vector =
nullptr;
508 Ident_bool =
nullptr;
509 Ident_Bool =
nullptr;
510 Ident_pixel =
nullptr;
519 Ident_introduced =
nullptr;
520 Ident_deprecated =
nullptr;
521 Ident_obsoleted =
nullptr;
522 Ident_unavailable =
nullptr;
523 Ident_strict =
nullptr;
524 Ident_replacement =
nullptr;
526 Ident_language = Ident_defined_in = Ident_generated_declaration = Ident_USR =
529 Ident__except =
nullptr;
531 Ident__exception_code = Ident__exception_info =
nullptr;
532 Ident__abnormal_termination = Ident___exception_code =
nullptr;
533 Ident___exception_info = Ident___abnormal_termination =
nullptr;
534 Ident_GetExceptionCode = Ident_GetExceptionInfo =
nullptr;
535 Ident_AbnormalTermination =
nullptr;
548 PP.
SetPoisonReason(Ident__exception_code,diag::err_seh___except_block);
549 PP.
SetPoisonReason(Ident___exception_code,diag::err_seh___except_block);
550 PP.
SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block);
551 PP.
SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter);
552 PP.
SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter);
553 PP.
SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter);
554 PP.
SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block);
555 PP.
SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block);
556 PP.
SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block);
570void Parser::DestroyTemplateIds() {
602 Diag(diag::ext_empty_translation_unit);
604 return NoTopLevelDecls;
615 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*
this);
624 case tok::annot_pragma_unused:
625 HandlePragmaUnused();
639 case tok::identifier: {
641 if ((II == Ident_module || II == Ident_import) &&
642 GetLookAheadToken(2).isNot(tok::coloncolon)) {
643 if (II == Ident_module)
658 Result = ParseModuleDecl(ImportState);
668 case tok::annot_module_include: {
681 ConsumeAnnotationToken();
685 case tok::annot_module_begin:
688 ConsumeAnnotationToken();
692 case tok::annot_module_end:
695 ConsumeAnnotationToken();
706 PP.
Diag(OverrideLoc, diag::note_max_tokens_total_override);
716 case tok::identifier:
741 while (MaybeParseCXX11Attributes(DeclAttrs) ||
742 MaybeParseGNUAttributes(DeclSpecAttrs))
745 Result = ParseExternalDeclaration(DeclAttrs, DeclSpecAttrs);
755 else if (ImportState ==
796 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(*
this);
804 Decl *SingleDecl =
nullptr;
806 case tok::annot_pragma_vis:
807 HandlePragmaVisibility();
809 case tok::annot_pragma_pack:
812 case tok::annot_pragma_msstruct:
813 HandlePragmaMSStruct();
815 case tok::annot_pragma_align:
818 case tok::annot_pragma_weak:
821 case tok::annot_pragma_weakalias:
822 HandlePragmaWeakAlias();
824 case tok::annot_pragma_redefine_extname:
825 HandlePragmaRedefineExtname();
827 case tok::annot_pragma_fp_contract:
828 HandlePragmaFPContract();
830 case tok::annot_pragma_fenv_access:
831 case tok::annot_pragma_fenv_access_ms:
832 HandlePragmaFEnvAccess();
834 case tok::annot_pragma_fenv_round:
835 HandlePragmaFEnvRound();
837 case tok::annot_pragma_float_control:
838 HandlePragmaFloatControl();
840 case tok::annot_pragma_fp:
843 case tok::annot_pragma_opencl_extension:
844 HandlePragmaOpenCLExtension();
846 case tok::annot_attr_openmp:
847 case tok::annot_pragma_openmp: {
849 return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
851 case tok::annot_pragma_ms_pointers_to_members:
852 HandlePragmaMSPointersToMembers();
854 case tok::annot_pragma_ms_vtordisp:
855 HandlePragmaMSVtorDisp();
857 case tok::annot_pragma_ms_pragma:
858 HandlePragmaMSPragma();
860 case tok::annot_pragma_dump:
863 case tok::annot_pragma_attribute:
864 HandlePragmaAttribute();
870 ConsumeExtraSemi(OutsideFunction);
873 Diag(Tok, diag::err_extraneous_closing_brace);
877 Diag(Tok, diag::err_expected_external_declaration);
879 case tok::kw___extension__: {
883 return ParseExternalDeclaration(Attrs, DeclSpecAttrs);
886 ProhibitAttributes(Attrs);
897 const auto *SL = cast<StringLiteral>(
Result.get());
898 if (!SL->getString().trim().empty())
899 Diag(StartLoc, diag::err_gnu_inline_asm_disabled);
902 ExpectAndConsume(tok::semi, diag::err_expected_after,
903 "top-level asm block");
911 return ParseObjCAtDirectives(Attrs, DeclSpecAttrs);
915 Diag(Tok, diag::err_expected_external_declaration);
919 SingleDecl = ParseObjCMethodDefinition();
921 case tok::code_completion:
923 if (CurParsedObjCImpl) {
933 case tok::kw_import: {
936 llvm_unreachable(
"not expecting a c++20 import here");
937 ProhibitAttributes(Attrs);
943 ProhibitAttributes(Attrs);
944 SingleDecl = ParseExportDeclaration();
951 case tok::kw_namespace:
952 case tok::kw_typedef:
953 case tok::kw_template:
954 case tok::kw_static_assert:
955 case tok::kw__Static_assert:
963 case tok::kw_cbuffer:
964 case tok::kw_tbuffer:
989 if (NextKind == tok::kw_namespace) {
997 if (NextKind == tok::kw_template) {
1007 case tok::kw_extern:
1013 diag::warn_cxx98_compat_extern_template :
1014 diag::ext_extern_template) <<
SourceRange(ExternLoc, TemplateLoc);
1021 case tok::kw___if_exists:
1022 case tok::kw___if_not_exists:
1023 ParseMicrosoftIfExistsExternalDeclaration();
1026 case tok::kw_module:
1027 Diag(Tok, diag::err_unexpected_module_decl);
1038 !isDeclarationStatement(
true))
1039 return ParseTopLevelStmtDecl();
1043 return ParseDeclarationOrFunctionDefinition(Attrs, DeclSpecAttrs, DS);
1053bool Parser::isDeclarationAfterDeclarator() {
1057 if (KW.
is(tok::kw_default) || KW.
is(tok::kw_delete))
1061 return Tok.
is(tok::equal) ||
1062 Tok.
is(tok::comma) ||
1063 Tok.
is(tok::semi) ||
1064 Tok.
is(tok::kw_asm) ||
1065 Tok.
is(tok::kw___attribute) ||
1067 Tok.
is(tok::l_paren));
1074 if (Tok.
is(tok::l_brace))
1084 return KW.
is(tok::kw_default) || KW.
is(tok::kw_delete);
1087 return Tok.
is(tok::colon) ||
1088 Tok.
is(tok::kw_try);
1114 "expected uninitialised source range");
1121 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS,
1122 DeclSpecContext::DSC_top_level);
1127 DS, AS, DeclSpecContext::DSC_top_level))
1132 if (Tok.
is(tok::semi)) {
1147 llvm_unreachable(
"we only expect to get the length of the class/struct/union/enum");
1157 ProhibitAttributes(Attrs, CorrectLocationForAttributes);
1164 Decl* decls[] = {AnonRecord, TheDecl};
1178 Diag(Tok, diag::err_objc_unexpected_attr);
1186 const char *PrevSpec =
nullptr;
1190 Diag(AtLoc, DiagID) << PrevSpec;
1193 return ParseObjCAtProtocolDeclaration(AtLoc, DS.
getAttributes());
1196 return ParseObjCAtImplementationDeclaration(AtLoc, DS.
getAttributes());
1199 ParseObjCAtInterfaceDeclaration(AtLoc, DS.
getAttributes()));
1208 ProhibitAttributes(Attrs);
1220 return ParseDeclOrFunctionDefInternal(Attrs, DeclSpecAttrs, *DS, AS);
1228 return ParseDeclOrFunctionDefInternal(Attrs, DeclSpecAttrs, PDS, AS);
1247 const ParsedTemplateInfo &TemplateInfo,
1248 LateParsedAttrList *LateParsedAttrs) {
1252 TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1260 const char *PrevSpec;
1274 ParseKNRParamDeclarations(D);
1278 if (Tok.
isNot(tok::l_brace) &&
1280 (Tok.
isNot(tok::colon) && Tok.
isNot(tok::kw_try) &&
1281 Tok.
isNot(tok::equal)))) {
1282 Diag(Tok, diag::err_expected_fn_body);
1288 if (Tok.
isNot(tok::l_brace))
1294 if (Tok.
isNot(tok::equal)) {
1296 if (AL.isKnownToGCC() && !AL.isStandardAttributeSyntax())
1297 Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL;
1303 TemplateInfo.Kind == ParsedTemplateInfo::Template &&
1318 trySkippingFunctionBody()) {
1324 LexTemplateFunctionForLateParsing(Toks);
1333 else if (CurParsedObjCImpl &&
1334 !TemplateInfo.TemplateParams &&
1335 (Tok.
is(tok::l_brace) || Tok.
is(tok::kw_try) ||
1336 Tok.
is(tok::colon)) &&
1349 StashAwayMethodOrFunctionBodyTokens(FuncDecl);
1350 CurParsedObjCImpl->HasCFunction =
true;
1369 ? diag::warn_cxx98_compat_defaulted_deleted_function
1370 : diag::ext_defaulted_deleted_function)
1375 ? diag::warn_cxx98_compat_defaulted_deleted_function
1376 : diag::ext_defaulted_deleted_function)
1380 llvm_unreachable(
"function definition after = not 'delete' or 'default'");
1383 if (Tok.
is(tok::comma)) {
1384 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration)
1387 }
else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
1399 TemplateInfo.TemplateParams
1400 ? *TemplateInfo.TemplateParams
1402 &SkipBody, BodyKind);
1432 Stmt *GeneratedBody = Res ? Res->
getBody() :
nullptr;
1439 if (
auto *Template = dyn_cast_or_null<FunctionTemplateDecl>(Res))
1440 if (Template->isAbbreviated() &&
1441 Template->getTemplateParameters()->getParam(0)->isImplicit())
1444 CurTemplateDepthTracker.addDepth(1);
1447 trySkippingFunctionBody()) {
1453 if (Tok.
is(tok::kw_try))
1454 return ParseFunctionTryBlock(Res, BodyScope);
1458 if (Tok.
is(tok::colon)) {
1459 ParseConstructorInitializer(Res);
1462 if (!Tok.
is(tok::l_brace)) {
1471 if (LateParsedAttrs)
1472 ParseLexedAttributeList(*LateParsedAttrs, Res,
false,
true);
1474 return ParseFunctionStatementBody(Res, BodyScope);
1477void Parser::SkipFunctionBody() {
1478 if (Tok.
is(tok::equal)) {
1483 bool IsFunctionTryBlock = Tok.
is(tok::kw_try);
1484 if (IsFunctionTryBlock)
1488 if (ConsumeAndStoreFunctionPrologue(Skipped))
1492 while (IsFunctionTryBlock && Tok.
is(tok::kw_catch)) {
1501void Parser::ParseKNRParamDeclarations(
Declarator &D) {
1516 ParseDeclarationSpecifiers(DS);
1524 Diag(DSStart, diag::err_declaration_does_not_declare_param);
1533 diag::err_invalid_storage_class_in_func_decl);
1538 diag::err_invalid_storage_class_in_func_decl);
1545 ParseDeclarator(ParmDeclarator);
1550 MaybeParseGNUAttributes(ParmDeclarator);
1558 ParmDeclarator.getIdentifier()) {
1562 for (
unsigned i = 0; ; ++i) {
1566 Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param)
1567 << ParmDeclarator.getIdentifier();
1571 if (FTI.
Params[i].
Ident == ParmDeclarator.getIdentifier()) {
1574 Diag(ParmDeclarator.getIdentifierLoc(),
1575 diag::err_param_redefinition)
1576 << ParmDeclarator.getIdentifier();
1587 if (Tok.
isNot(tok::comma))
1590 ParmDeclarator.clear();
1596 ParseDeclarator(ParmDeclarator);
1600 if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration))
1623ExprResult Parser::ParseAsmStringLiteral(
bool ForAsmLabel) {
1624 if (!isTokenStringLiteral()) {
1625 Diag(Tok, diag::err_expected_string_literal)
1631 if (!AsmString.isInvalid()) {
1632 const auto *SL = cast<StringLiteral>(AsmString.get());
1633 if (!SL->isOrdinary()) {
1634 Diag(Tok, diag::err_asm_operand_wide_string_literal)
1636 << SL->getSourceRange();
1639 if (ForAsmLabel && SL->getString().empty()) {
1640 Diag(Tok, diag::err_asm_operand_wide_string_literal)
1641 << 2 << SL->getSourceRange();
1654 assert(Tok.
is(tok::kw_asm) &&
"Not an asm!");
1657 if (isGNUAsmQualifier(Tok)) {
1661 Diag(Tok, diag::err_global_asm_qualifier_ignored)
1662 << GNUAsmQualifiers::getQualifierName(getGNUAsmQualifier(Tok))
1668 if (T.consumeOpen()) {
1669 Diag(Tok, diag::err_expected_lparen_after) <<
"asm";
1675 if (!
Result.isInvalid()) {
1679 *EndLoc = T.getCloseLocation();
1693 assert(tok.
is(tok::annot_template_id) &&
"Expected template-id token");
1699void Parser::AnnotateScopeToken(
CXXScopeSpec &SS,
bool IsNewAnnotation) {
1706 Tok.
setKind(tok::annot_cxxscope);
1713 if (IsNewAnnotation)
1727Parser::AnnotatedNameKind
1730 assert(Tok.
is(tok::identifier) || Tok.
is(tok::annot_cxxscope));
1732 const bool EnteringContext =
false;
1733 const bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
1737 ParseOptionalCXXScopeSpecifier(SS,
nullptr,
1744 AllowImplicitTypename))
1746 return ANK_Unresolved;
1754 if (isTentativelyDeclared(Name) && SS.
isEmpty()) {
1758 AllowImplicitTypename))
1760 return Tok.
is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl;
1777 isTemplateArgumentList(1) == TPResult::False) {
1779 Token FakeNext = Next;
1780 FakeNext.
setKind(tok::unknown);
1783 SS.
isEmpty() ? CCC :
nullptr);
1786 switch (Classification.
getKind()) {
1793 Tok.
setKind(Name->getTokenID());
1796 AnnotateScopeToken(SS, !WasScopeAnnotation);
1805 if (TryAltiVecVectorToken())
1829 else if (Tok.
is(tok::eof))
1833 Tok.
setKind(tok::annot_typename);
1834 setTypeAnnotation(Tok, Ty);
1842 Tok.
setKind(tok::annot_overload_set);
1851 if (TryAltiVecVectorToken())
1856 Tok.
setKind(tok::annot_non_type);
1862 AnnotateScopeToken(SS, !WasScopeAnnotation);
1868 ? tok::annot_non_type_undeclared
1869 : tok::annot_non_type_dependent);
1870 setIdentifierAnnotation(Tok, Name);
1875 AnnotateScopeToken(SS, !WasScopeAnnotation);
1879 if (Next.isNot(tok::less)) {
1882 AnnotateScopeToken(SS, !WasScopeAnnotation);
1883 return ANK_TemplateName;
1892 Id.setIdentifier(Name, NameLoc);
1893 if (AnnotateTemplateIdToken(
1901 Id.setIdentifier(Name, NameLoc);
1902 if (Next.is(tok::less))
1906 if (AnnotateTemplateIdToken(
1917 AnnotateScopeToken(SS, !WasScopeAnnotation);
1918 return ANK_Unresolved;
1921bool Parser::TryKeywordIdentFallback(
bool DisableKeyword) {
1922 assert(Tok.
isNot(tok::identifier));
1923 Diag(Tok, diag::ext_keyword_as_ident)
1956 assert((Tok.
is(tok::identifier) || Tok.
is(tok::coloncolon) ||
1957 Tok.
is(tok::kw_typename) || Tok.
is(tok::annot_cxxscope) ||
1958 Tok.
is(tok::kw_decltype) || Tok.
is(tok::annot_template_id) ||
1959 Tok.
is(tok::kw___super)) &&
1960 "Cannot be a type or scope token!");
1962 if (Tok.
is(tok::kw_typename)) {
1971 PP.
Lex(TypedefToken);
1976 Diag(Tok.
getLocation(), diag::warn_expected_qualified_after_typename);
1988 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
1994 if (Tok.
is(tok::identifier) || Tok.
is(tok::annot_template_id) ||
1995 Tok.
is(tok::annot_decltype)) {
1997 if (Tok.
is(tok::annot_decltype) ||
2000 unsigned DiagID = diag::err_expected_qualified_after_typename;
2004 DiagID = diag::warn_expected_qualified_after_typename;
2017 if (Tok.
is(tok::identifier)) {
2022 }
else if (Tok.
is(tok::annot_template_id)) {
2025 Diag(Tok, diag::err_typename_refers_to_non_type_template)
2039 TemplateArgsPtr, TemplateId->
RAngleLoc);
2041 Diag(Tok, diag::err_expected_type_name_after_typename)
2047 Tok.
setKind(tok::annot_typename);
2048 setTypeAnnotation(Tok, Ty);
2056 bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
2060 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2066 AllowImplicitTypename);
2075 if (Tok.
is(tok::identifier)) {
2079 false,
NextToken().is(tok::period),
nullptr,
2082 true, AllowImplicitTypename)) {
2101 else if (Tok.
is(tok::eof))
2107 Tok.
setKind(tok::annot_typename);
2108 setTypeAnnotation(Tok, Ty);
2132 bool MemberOfUnknownSpecialization;
2136 nullptr,
false, Template,
2137 MemberOfUnknownSpecialization)) {
2141 isTemplateArgumentList(1) != TPResult::False) {
2161 if (Tok.
is(tok::annot_template_id)) {
2168 AnnotateTemplateIdTokenAsType(SS, AllowImplicitTypename);
2177 AnnotateScopeToken(SS, IsNewScope);
2189 "Call sites of this function should be guarded by checking for C++");
2193 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
2200 AnnotateScopeToken(SS,
true);
2204bool Parser::isTokenEqualOrEqualTypo() {
2210 case tok::starequal:
2211 case tok::plusequal:
2212 case tok::minusequal:
2213 case tok::exclaimequal:
2214 case tok::slashequal:
2215 case tok::percentequal:
2216 case tok::lessequal:
2217 case tok::lesslessequal:
2218 case tok::greaterequal:
2219 case tok::greatergreaterequal:
2220 case tok::caretequal:
2221 case tok::pipeequal:
2222 case tok::equalequal:
2223 Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal)
2233 assert(Tok.
is(tok::code_completion));
2237 if (S->isFunctionScope()) {
2241 return PrevTokLocation;
2244 if (S->isClassScope()) {
2247 return PrevTokLocation;
2253 return PrevTokLocation;
2258void Parser::CodeCompleteDirective(
bool InConditional) {
2262void Parser::CodeCompleteInConditionalExclusion() {
2266void Parser::CodeCompleteMacroName(
bool IsDefinition) {
2270void Parser::CodeCompletePreprocessorExpression() {
2276 unsigned ArgumentIndex) {
2281void Parser::CodeCompleteIncludedFile(llvm::StringRef Dir,
bool IsAngled) {
2285void Parser::CodeCompleteNaturalLanguage() {
2289bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition&
Result) {
2290 assert((Tok.
is(tok::kw___if_exists) || Tok.
is(tok::kw___if_not_exists)) &&
2291 "Expected '__if_exists' or '__if_not_exists'");
2292 Result.IsIfExists = Tok.
is(tok::kw___if_exists);
2296 if (T.consumeOpen()) {
2297 Diag(Tok, diag::err_expected_lparen_after)
2298 << (
Result.IsIfExists?
"__if_exists" :
"__if_not_exists");
2304 ParseOptionalCXXScopeSpecifier(
Result.SS,
nullptr,
2309 if (
Result.SS.isInvalid()) {
2320 false, &TemplateKWLoc,
2326 if (T.consumeClose())
2334 Result.Behavior =
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2338 Result.Behavior = !
Result.IsIfExists ? IEB_Parse : IEB_Skip;
2342 Result.Behavior = IEB_Dependent;
2352void Parser::ParseMicrosoftIfExistsExternalDeclaration() {
2353 IfExistsCondition
Result;
2354 if (ParseMicrosoftIfExistsCondition(
Result))
2358 if (Braces.consumeOpen()) {
2359 Diag(Tok, diag::err_expected) << tok::l_brace;
2363 switch (
Result.Behavior) {
2369 llvm_unreachable(
"Cannot have a dependent external declaration");
2378 while (Tok.
isNot(tok::r_brace) && !isEofOrEom()) {
2380 MaybeParseCXX11Attributes(Attrs);
2386 Braces.consumeClose();
2411 (Tok.
is(tok::kw_module) ||
2413 "not a module declaration");
2418 DiagnoseAndSkipCXX11Attributes();
2424 Diag(StartLoc, diag::err_global_module_introducer_not_at_start)
2429 Diag(StartLoc, diag::err_module_fragment_exported)
2440 Diag(StartLoc, diag::err_module_fragment_exported)
2445 DiagnoseAndSkipCXX11Attributes();
2446 ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);
2454 if (ParseModuleName(ModuleLoc, Path,
false))
2459 if (Tok.
is(tok::colon)) {
2462 Diag(ColonLoc, diag::err_unsupported_module_partition)
2463 <<
SourceRange(ColonLoc, Partition.back().second);
2465 else if (ParseModuleName(ModuleLoc, Partition,
false))
2471 MaybeParseCXX11Attributes(Attrs);
2472 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr,
2476 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2478 return Actions.
ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, Partition,
2506 "Improper start to module import");
2512 bool IsPartition =
false;
2513 Module *HeaderUnit =
nullptr;
2514 if (Tok.
is(tok::header_name)) {
2519 }
else if (Tok.
is(tok::annot_header_unit)) {
2522 ConsumeAnnotationToken();
2523 }
else if (Tok.
is(tok::colon)) {
2526 Diag(ColonLoc, diag::err_unsupported_module_partition)
2529 else if (ParseModuleName(ColonLoc, Path,
true))
2534 if (ParseModuleName(ImportLoc, Path,
true))
2539 MaybeParseCXX11Attributes(Attrs);
2541 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr,
2552 bool SeenError =
true;
2553 switch (ImportState) {
2561 Diag(ImportLoc, diag::err_partition_import_outside_module);
2573 if (IsPartition || (HeaderUnit && HeaderUnit->
Kind !=
2575 Diag(ImportLoc, diag::err_import_in_wrong_fragment)
2584 Diag(ImportLoc, diag::err_import_not_allowed_here);
2590 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2598 else if (!Path.empty())
2601 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2607 if (IsObjCAtImport && AtLoc.
isValid()) {
2610 if (FE && llvm::sys::path::parent_path(FE->getDir().getName())
2611 .endswith(
".framework"))
2612 Diags.
Report(AtLoc, diag::warn_atimport_in_framework_header);
2625bool Parser::ParseModuleName(
2631 if (!Tok.
is(tok::identifier)) {
2632 if (Tok.
is(tok::code_completion)) {
2638 Diag(Tok, diag::err_module_expected_ident) << IsImport;
2647 if (Tok.
isNot(tok::period))
2658bool Parser::parseMisplacedModuleImport() {
2661 case tok::annot_module_end:
2665 if (MisplacedModuleBeginCount) {
2666 --MisplacedModuleBeginCount;
2668 reinterpret_cast<Module *
>(
2670 ConsumeAnnotationToken();
2677 case tok::annot_module_begin:
2680 reinterpret_cast<Module *
>(
2682 ConsumeAnnotationToken();
2683 ++MisplacedModuleBeginCount;
2685 case tok::annot_module_include:
2689 reinterpret_cast<Module *
>(
2691 ConsumeAnnotationToken();
2701bool BalancedDelimiterTracker::diagnoseOverflow() {
2702 P.
Diag(P.Tok, diag::err_bracket_depth_exceeded)
2704 P.
Diag(P.Tok, diag::note_bracket_depth);
2713 if (P.ExpectAndConsume(Kind, DiagID, Msg)) {
2714 if (SkipToTok != tok::unknown)
2722 return diagnoseOverflow();
2725bool BalancedDelimiterTracker::diagnoseMissingClose() {
2726 assert(!P.Tok.
is(Close) &&
"Should have consumed closing delimiter");
2728 if (P.Tok.
is(tok::annot_module_end))
2729 P.
Diag(P.Tok, diag::err_missing_before_module_end) << Close;
2731 P.
Diag(P.Tok, diag::err_expected) << Close;
2732 P.
Diag(LOpen, diag::note_matching) << Kind;
2736 if (P.Tok.
isNot(tok::r_paren) && P.Tok.
isNot(tok::r_brace) &&
2737 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)
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
const clang::PrintingPolicy & getPrintingPolicy() const
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
ActionResult - This structure is used while parsing/acting on expressions, stmts, 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
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.
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.
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 ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
Decl * ActOnSkippedFunctionBody(Decl *Decl)
@ 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.
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 CodeCompletePreprocessorMacroArgument(Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument)
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
void ActOnComment(SourceRange Comment)
@ Other
C++ [dcl.fct.def.general]p1 function-body: ctor-initializer[opt] compound-statement function-try-bloc...
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
void ActOnTranslationUnitScope(Scope *S)
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)
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 CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
void SetLateTemplateParser(LateTemplateParserCB *LTP, LateTemplateParserCleanupCB *LTPCleanup, void *P)
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,...
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...
void CodeCompleteNaturalLanguage()
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 CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)
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...
@ PCC_RecoveryInFunction
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
@ 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.
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
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 SetFunctionBodyKind(Decl *D, SourceLocation Loc, FnBodyKind BodyKind)
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.
void CodeCompleteObjCMethodDecl(Scope *S, std::optional< bool > IsInstanceMethod, ParsedType ReturnType)
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 CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
void CodeCompletePreprocessorMacroName(bool IsDefinition)
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
void CodeCompletePreprocessorDirective(bool InConditional)
void CodeCompletePreprocessorExpression()
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.
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.
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...
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.
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,...
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.
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.
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.