22 #include "llvm/Support/Path.h" 23 using namespace clang;
33 explicit ActionCommentHandler(
Sema &S) : S(S) { }
44 if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland))
45 Ident__except = PP.getIdentifierInfo(
"__except");
51 : PP(pp), Actions(actions), Diags(PP.getDiagnostics()),
52 GreaterThanIsOperator(
true), ColonIsSacred(
false),
53 InMessageExpression(
false), TemplateParameterDepth(0),
54 ParsingInObjCContainer(
false) {
58 Actions.CurScope =
nullptr;
60 CurParsedObjCImpl =
nullptr;
64 initializePragmaHandlers();
66 CommentSemaHandler.reset(
new ActionCommentHandler(actions));
73 return Diags.
Report(Loc, DiagID);
102 switch (ExpectedTok) {
104 return Tok.
is(tok::colon) || Tok.
is(tok::comma);
105 default:
return false;
109 bool Parser::ExpectAndConsume(
tok::TokenKind ExpectedTok,
unsigned DiagID,
111 if (Tok.
is(ExpectedTok) || Tok.
is(tok::code_completion)) {
123 if (DiagID == diag::err_expected)
125 else if (DiagID == diag::err_expected_after)
126 DB << Msg << ExpectedTok;
137 const char *Spelling =
nullptr;
145 if (DiagID == diag::err_expected)
147 else if (DiagID == diag::err_expected_after)
148 DB << Msg << ExpectedTok;
155 bool Parser::ExpectAndConsumeSemi(
unsigned DiagID) {
159 if (Tok.
is(tok::code_completion)) {
160 handleUnexpectedCodeCompletionToken();
164 if ((Tok.
is(tok::r_paren) || Tok.
is(tok::r_square)) &&
166 Diag(Tok, diag::err_extraneous_token_before_semi)
174 return ExpectAndConsume(tok::semi, DiagID);
177 void Parser::ConsumeExtraSemi(ExtraSemiKind
Kind,
unsigned TST) {
178 if (!Tok.
is(tok::semi))
return;
180 bool HadMultipleSemis =
false;
186 HadMultipleSemis =
true;
195 Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi)
198 Diag(StartLoc, diag::ext_extra_semi_cxx11)
203 if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis)
204 Diag(StartLoc, diag::ext_extra_semi)
210 Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def)
214 bool Parser::expectIdentifier() {
215 if (Tok.
is(tok::identifier))
219 Diag(Tok, diag::err_expected_token_instead_of_objcxx_keyword)
225 Diag(Tok, diag::err_expected) << tok::identifier;
234 return (static_cast<unsigned>(L) & static_cast<unsigned>(R)) != 0;
248 bool isFirstTokenSkipped =
true;
251 for (
unsigned i = 0, NumToks = Toks.size();
i != NumToks; ++
i) {
252 if (Tok.
is(Toks[
i])) {
265 if (Toks.size() == 1 && Toks[0] ==
tok::eof &&
278 case tok::annot_pragma_openmp:
279 case tok::annot_pragma_openmp_end:
281 case tok::annot_module_begin:
282 case tok::annot_module_end:
283 case tok::annot_module_include:
289 case tok::code_completion:
291 handleUnexpectedCodeCompletionToken();
333 if (ParenCount && !isFirstTokenSkipped)
338 if (BracketCount && !isFirstTokenSkipped)
343 if (BraceCount && !isFirstTokenSkipped)
357 isFirstTokenSkipped =
false;
367 if (NumCachedScopes) {
368 Scope *N = ScopeCache[--NumCachedScopes];
370 Actions.CurScope = N;
385 Actions.CurScope = OldScope->
getParent();
387 if (NumCachedScopes == ScopeCacheSize)
390 ScopeCache[NumCachedScopes++] = OldScope;
395 Parser::ParseScopeFlags::ParseScopeFlags(
Parser *Self,
unsigned ScopeFlags,
397 : CurScope(ManageFlags ? Self->
getCurScope() :
nullptr) {
399 OldFlags = CurScope->getFlags();
400 CurScope->setFlags(ScopeFlags);
406 Parser::ParseScopeFlags::~ParseScopeFlags() {
408 CurScope->setFlags(OldFlags);
419 Actions.CurScope =
nullptr;
422 for (
unsigned i = 0, e = NumCachedScopes;
i != e; ++
i)
423 delete ScopeCache[
i];
425 resetPragmaHandlers();
440 assert(TemplateIds.empty() &&
"Still alive TemplateIdAnnotations around?");
447 assert(
getCurScope() ==
nullptr &&
"A scope is already active?");
462 ObjCTypeQuals[objc_null_unspecified]
466 Ident_instancetype =
nullptr;
467 Ident_final =
nullptr;
468 Ident_sealed =
nullptr;
469 Ident_override =
nullptr;
470 Ident_GNU_final =
nullptr;
471 Ident_import =
nullptr;
472 Ident_module =
nullptr;
476 Ident_vector =
nullptr;
477 Ident_bool =
nullptr;
478 Ident_pixel =
nullptr;
486 Ident_introduced =
nullptr;
487 Ident_deprecated =
nullptr;
488 Ident_obsoleted =
nullptr;
489 Ident_unavailable =
nullptr;
490 Ident_strict =
nullptr;
491 Ident_replacement =
nullptr;
493 Ident_language = Ident_defined_in = Ident_generated_declaration =
nullptr;
495 Ident__except =
nullptr;
497 Ident__exception_code = Ident__exception_info =
nullptr;
498 Ident__abnormal_termination = Ident___exception_code =
nullptr;
499 Ident___exception_info = Ident___abnormal_termination =
nullptr;
500 Ident_GetExceptionCode = Ident_GetExceptionInfo =
nullptr;
501 Ident_AbnormalTermination =
nullptr;
514 PP.
SetPoisonReason(Ident__exception_code,diag::err_seh___except_block);
515 PP.
SetPoisonReason(Ident___exception_code,diag::err_seh___except_block);
516 PP.
SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block);
517 PP.
SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter);
518 PP.
SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter);
519 PP.
SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter);
520 PP.
SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block);
521 PP.
SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block);
522 PP.
SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block);
536 void Parser::LateTemplateParserCleanupCallback(
void *
P) {
563 Diag(diag::ext_empty_translation_unit);
565 return NoTopLevelDecls;
584 case tok::annot_pragma_unused:
585 HandlePragmaUnused();
599 case tok::identifier: {
601 if ((II == Ident_module || II == Ident_import) &&
602 GetLookAheadToken(2).isNot(tok::coloncolon)) {
603 if (II == Ident_module)
618 Result = ParseModuleDecl(IsFirstDecl);
629 case tok::annot_module_include:
631 reinterpret_cast<Module *
>(
633 ConsumeAnnotationToken();
636 case tok::annot_module_begin:
639 ConsumeAnnotationToken();
642 case tok::annot_module_end:
645 ConsumeAnnotationToken();
653 LateTemplateParserCleanupCallback :
nullptr,
660 case tok::identifier:
679 ParsedAttributesWithRange attrs(AttrFactory);
680 MaybeParseCXX11Attributes(attrs);
682 Result = ParseExternalDeclaration(attrs);
713 Parser::ParseExternalDeclaration(ParsedAttributesWithRange &attrs,
723 Decl *SingleDecl =
nullptr;
725 case tok::annot_pragma_vis:
726 HandlePragmaVisibility();
728 case tok::annot_pragma_pack:
731 case tok::annot_pragma_msstruct:
732 HandlePragmaMSStruct();
734 case tok::annot_pragma_align:
737 case tok::annot_pragma_weak:
740 case tok::annot_pragma_weakalias:
741 HandlePragmaWeakAlias();
743 case tok::annot_pragma_redefine_extname:
744 HandlePragmaRedefineExtname();
746 case tok::annot_pragma_fp_contract:
747 HandlePragmaFPContract();
749 case tok::annot_pragma_fenv_access:
750 HandlePragmaFEnvAccess();
752 case tok::annot_pragma_fp:
755 case tok::annot_pragma_opencl_extension:
756 HandlePragmaOpenCLExtension();
758 case tok::annot_pragma_openmp: {
760 return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs);
762 case tok::annot_pragma_ms_pointers_to_members:
763 HandlePragmaMSPointersToMembers();
765 case tok::annot_pragma_ms_vtordisp:
766 HandlePragmaMSVtorDisp();
768 case tok::annot_pragma_ms_pragma:
769 HandlePragmaMSPragma();
771 case tok::annot_pragma_dump:
774 case tok::annot_pragma_attribute:
775 HandlePragmaAttribute();
781 ConsumeExtraSemi(OutsideFunction);
784 Diag(Tok, diag::err_extraneous_closing_brace);
788 Diag(Tok, diag::err_expected_external_declaration);
790 case tok::kw___extension__: {
794 return ParseExternalDeclaration(attrs);
797 ProhibitAttributes(attrs);
808 const auto *SL = cast<StringLiteral>(Result.
get());
809 if (!SL->getString().trim().empty())
810 Diag(StartLoc, diag::err_gnu_inline_asm_disabled);
813 ExpectAndConsume(tok::semi, diag::err_expected_after,
814 "top-level asm block");
822 return ParseObjCAtDirectives(attrs);
826 Diag(Tok, diag::err_expected_external_declaration);
830 SingleDecl = ParseObjCMethodDefinition();
832 case tok::code_completion:
833 if (CurParsedObjCImpl) {
849 SingleDecl = ParseExportDeclaration();
856 case tok::kw_namespace:
857 case tok::kw_typedef:
858 case tok::kw_template:
859 case tok::kw_static_assert:
860 case tok::kw__Static_assert:
883 if (NextKind == tok::kw_namespace) {
890 if (NextKind == tok::kw_template) {
905 diag::warn_cxx98_compat_extern_template :
906 diag::ext_extern_template) <<
SourceRange(ExternLoc, TemplateLoc);
910 TemplateLoc, DeclEnd, attrs));
914 case tok::kw___if_exists:
915 case tok::kw___if_not_exists:
916 ParseMicrosoftIfExistsExternalDeclaration();
920 Diag(Tok, diag::err_unexpected_module_decl);
931 return ParseDeclarationOrFunctionDefinition(attrs, DS);
941 bool Parser::isDeclarationAfterDeclarator() {
945 if (KW.
is(tok::kw_default) || KW.
is(tok::kw_delete))
949 return Tok.
is(tok::equal) ||
950 Tok.
is(tok::comma) ||
952 Tok.
is(tok::kw_asm) ||
953 Tok.
is(tok::kw___attribute) ||
955 Tok.
is(tok::l_paren));
962 if (Tok.
is(tok::l_brace))
968 return isDeclarationSpecifier();
972 return KW.
is(tok::kw_default) || KW.
is(tok::kw_delete);
975 return Tok.
is(tok::colon) ||
996 Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs,
1001 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS,
1002 DeclSpecContext::DSC_top_level);
1007 DS, AS, DeclSpecContext::DSC_top_level))
1012 if (Tok.
is(tok::semi)) {
1027 llvm_unreachable(
"we only expect to get the length of the class/struct/union/enum");
1037 ProhibitAttributes(attrs, CorrectLocationForAttributes);
1046 Decl* decls[] = {AnonRecord, TheDecl};
1062 Diag(Tok, diag::err_objc_unexpected_attr);
1069 const char *PrevSpec =
nullptr;
1073 Diag(AtLoc, DiagID) << PrevSpec;
1076 return ParseObjCAtProtocolDeclaration(AtLoc, DS.
getAttributes());
1079 return ParseObjCAtImplementationDeclaration(AtLoc, DS.
getAttributes());
1082 ParseObjCAtInterfaceDeclaration(AtLoc, DS.
getAttributes()));
1088 if (
getLangOpts().CPlusPlus && isTokenStringLiteral() &&
1099 Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs,
1103 return ParseDeclOrFunctionDefInternal(attrs, *DS, AS);
1111 return ParseDeclOrFunctionDefInternal(attrs, PDS, AS);
1130 const ParsedTemplateInfo &TemplateInfo,
1131 LateParsedAttrList *LateParsedAttrs) {
1140 const char *PrevSpec;
1154 ParseKNRParamDeclarations(D);
1158 if (Tok.
isNot(tok::l_brace) &&
1160 (Tok.
isNot(tok::colon) && Tok.
isNot(tok::kw_try) &&
1161 Tok.
isNot(tok::equal)))) {
1162 Diag(Tok, diag::err_expected_fn_body);
1168 if (Tok.
isNot(tok::l_brace))
1174 if (Tok.
isNot(tok::equal)) {
1176 if (AL.isKnownToGCC() && !AL.isCXX11Attribute())
1177 Diag(AL.getLoc(), diag::warn_attribute_on_function_definition)
1184 TemplateInfo.Kind == ParsedTemplateInfo::Template &&
1194 TemplateParameterLists);
1199 trySkippingFunctionBody()) {
1205 LexTemplateFunctionForLateParsing(Toks);
1214 else if (CurParsedObjCImpl &&
1215 !TemplateInfo.TemplateParams &&
1216 (Tok.
is(tok::l_brace) || Tok.
is(tok::kw_try) ||
1217 Tok.
is(tok::colon)) &&
1230 StashAwayMethodOrFunctionBodyTokens(FuncDecl);
1231 CurParsedObjCImpl->HasCFunction =
true;
1245 TemplateInfo.TemplateParams
1246 ? *TemplateInfo.TemplateParams
1269 ? diag::warn_cxx98_compat_defaulted_deleted_function
1270 : diag::ext_defaulted_deleted_function)
1276 ? diag::warn_cxx98_compat_defaulted_deleted_function
1277 : diag::ext_defaulted_deleted_function)
1281 llvm_unreachable(
"function definition after = not 'delete' or 'default'");
1284 if (Tok.
is(tok::comma)) {
1285 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration)
1288 }
else if (ExpectAndConsume(tok::semi, diag::err_expected_after,
1289 Delete ?
"delete" :
"default")) {
1293 Stmt *GeneratedBody = Res ? Res->
getBody() :
nullptr;
1299 trySkippingFunctionBody()) {
1305 if (Tok.
is(tok::kw_try))
1306 return ParseFunctionTryBlock(Res, BodyScope);
1310 if (Tok.
is(tok::colon)) {
1311 ParseConstructorInitializer(Res);
1314 if (!Tok.
is(tok::l_brace)) {
1323 if (LateParsedAttrs)
1324 ParseLexedAttributeList(*LateParsedAttrs, Res,
false,
true);
1326 return ParseFunctionStatementBody(Res, BodyScope);
1329 void Parser::SkipFunctionBody() {
1330 if (Tok.
is(tok::equal)) {
1335 bool IsFunctionTryBlock = Tok.
is(tok::kw_try);
1336 if (IsFunctionTryBlock)
1340 if (ConsumeAndStoreFunctionPrologue(Skipped))
1344 while (IsFunctionTryBlock && Tok.
is(tok::kw_catch)) {
1353 void Parser::ParseKNRParamDeclarations(Declarator &D) {
1363 while (isDeclarationSpecifier()) {
1368 ParseDeclarationSpecifiers(DS);
1376 Diag(DSStart, diag::err_declaration_does_not_declare_param);
1385 diag::err_invalid_storage_class_in_func_decl);
1390 diag::err_invalid_storage_class_in_func_decl);
1396 ParseDeclarator(ParmDeclarator);
1401 MaybeParseGNUAttributes(ParmDeclarator);
1413 for (
unsigned i = 0; ; ++
i) {
1426 diag::err_param_redefinition)
1438 if (Tok.
isNot(tok::comma))
1441 ParmDeclarator.
clear();
1447 ParseDeclarator(ParmDeclarator);
1451 if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration))
1472 if (!isTokenStringLiteral()) {
1473 Diag(Tok, diag::err_expected_string_literal)
1478 ExprResult AsmString(ParseStringLiteralExpression());
1480 const auto *SL = cast<StringLiteral>(AsmString.
get());
1481 if (!SL->isAscii()) {
1482 Diag(Tok, diag::err_asm_operand_wide_string_literal)
1484 << SL->getSourceRange();
1497 assert(Tok.
is(tok::kw_asm) &&
"Not an asm!");
1500 if (Tok.
is(tok::kw_volatile)) {
1505 Diag(Tok, diag::warn_file_asm_volatile)
1512 Diag(Tok, diag::err_expected_lparen_after) <<
"asm";
1536 assert(tok.
is(tok::annot_template_id) &&
"Expected template-id token");
1542 void Parser::AnnotateScopeToken(
CXXScopeSpec &SS,
bool IsNewAnnotation) {
1549 Tok.
setKind(tok::annot_cxxscope);
1556 if (IsNewAnnotation)
1569 Parser::AnnotatedNameKind
1570 Parser::TryAnnotateName(
bool IsAddressOfOperand,
1572 assert(Tok.
is(tok::identifier) || Tok.
is(tok::annot_cxxscope));
1574 const bool EnteringContext =
false;
1575 const bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
1579 ParseOptionalCXXScopeSpecifier(SS,
nullptr, EnteringContext))
1585 return ANK_Unresolved;
1593 if (isTentativelyDeclared(Name)) {
1598 return Tok.
is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl;
1609 IsAddressOfOperand, SS.
isEmpty() ? CCC :
nullptr);
1616 isTemplateArgumentList(1) == TPResult::False) {
1618 Token FakeNext = Next;
1619 FakeNext.
setKind(tok::unknown);
1622 IsAddressOfOperand, SS.
isEmpty() ? CCC :
nullptr);
1625 switch (Classification.
getKind()) {
1635 AnnotateScopeToken(SS, !WasScopeAnnotation);
1658 = parseObjCTypeArgsAndProtocolQualifiers(IdentifierLoc, Ty,
1667 Tok.
setKind(tok::annot_typename);
1668 setTypeAnnotation(Tok, Ty);
1676 Tok.
setKind(tok::annot_primary_expr);
1685 if (Next.
isNot(tok::less)) {
1688 AnnotateScopeToken(SS, !WasScopeAnnotation);
1689 return ANK_TemplateName;
1699 if (AnnotateTemplateIdToken(
1707 llvm_unreachable(
"already parsed nested name specifier");
1712 AnnotateScopeToken(SS, !WasScopeAnnotation);
1713 return ANK_Unresolved;
1716 bool Parser::TryKeywordIdentFallback(
bool DisableKeyword) {
1717 assert(Tok.
isNot(tok::identifier));
1718 Diag(Tok, diag::ext_keyword_as_ident)
1750 assert((Tok.
is(tok::identifier) || Tok.
is(tok::coloncolon) ||
1751 Tok.
is(tok::kw_typename) || Tok.
is(tok::annot_cxxscope) ||
1752 Tok.
is(tok::kw_decltype) || Tok.
is(tok::annot_template_id) ||
1753 Tok.
is(tok::kw___super)) &&
1754 "Cannot be a type or scope token!");
1756 if (Tok.
is(tok::kw_typename)) {
1765 PP.
Lex(TypedefToken);
1770 Diag(Tok.
getLocation(), diag::warn_expected_qualified_after_typename);
1782 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
1787 if (Tok.
is(tok::identifier) || Tok.
is(tok::annot_template_id) ||
1788 Tok.
is(tok::annot_decltype)) {
1790 if (Tok.
is(tok::annot_decltype) ||
1792 unsigned DiagID = diag::err_expected_qualified_after_typename;
1796 DiagID = diag::warn_expected_qualified_after_typename;
1809 if (Tok.
is(tok::identifier)) {
1814 }
else if (Tok.
is(tok::annot_template_id)) {
1819 Diag(Tok, diag::err_typename_refers_to_non_type_template)
1836 Diag(Tok, diag::err_expected_type_name_after_typename)
1842 Tok.
setKind(tok::annot_typename);
1843 setTypeAnnotation(Tok, Ty.
isInvalid() ? nullptr : Ty.
get());
1851 bool WasScopeAnnotation = Tok.
is(tok::annot_cxxscope);
1855 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr,
false))
1866 if (Tok.
is(tok::identifier)) {
1881 (Ty.get()->isObjCObjectType() ||
1882 Ty.get()->isObjCObjectPointerType())) {
1887 = parseObjCTypeArgsAndProtocolQualifiers(IdentifierLoc, Ty,
1898 Tok.
setKind(tok::annot_typename);
1899 setTypeAnnotation(Tok, Ty);
1923 bool MemberOfUnknownSpecialization;
1926 false, TemplateName,
1927 nullptr,
false, Template,
1928 MemberOfUnknownSpecialization)) {
1932 isTemplateArgumentList(1) != TPResult::False) {
1952 if (Tok.
is(tok::annot_template_id)) {
1959 AnnotateTemplateIdTokenAsType();
1968 AnnotateScopeToken(SS, IsNewScope);
1980 "Call sites of this function should be guarded by checking for C++");
1981 assert((Tok.
is(tok::identifier) || Tok.
is(tok::coloncolon) ||
1982 (Tok.
is(tok::annot_template_id) &&
NextToken().
is(tok::coloncolon)) ||
1983 Tok.
is(tok::kw_decltype) || Tok.
is(tok::kw___super)) &&
1984 "Cannot be a type or scope token!");
1987 if (ParseOptionalCXXScopeSpecifier(SS,
nullptr, EnteringContext))
1992 AnnotateScopeToken(SS,
true);
1996 bool Parser::isTokenEqualOrEqualTypo() {
2002 case tok::starequal:
2003 case tok::plusequal:
2004 case tok::minusequal:
2005 case tok::exclaimequal:
2006 case tok::slashequal:
2007 case tok::percentequal:
2008 case tok::lessequal:
2009 case tok::lesslessequal:
2010 case tok::greaterequal:
2011 case tok::greatergreaterequal:
2012 case tok::caretequal:
2013 case tok::pipeequal:
2014 case tok::equalequal:
2015 Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal)
2025 assert(Tok.
is(tok::code_completion));
2033 return PrevTokLocation;
2039 return PrevTokLocation;
2045 return PrevTokLocation;
2050 void Parser::CodeCompleteDirective(
bool InConditional) {
2054 void Parser::CodeCompleteInConditionalExclusion() {
2058 void Parser::CodeCompleteMacroName(
bool IsDefinition) {
2062 void Parser::CodeCompletePreprocessorExpression() {
2068 unsigned ArgumentIndex) {
2073 void Parser::CodeCompleteIncludedFile(llvm::StringRef Dir,
bool IsAngled) {
2077 void Parser::CodeCompleteNaturalLanguage() {
2081 bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition&
Result) {
2082 assert((Tok.
is(tok::kw___if_exists) || Tok.
is(tok::kw___if_not_exists)) &&
2083 "Expected '__if_exists' or '__if_not_exists'");
2084 Result.IsIfExists = Tok.
is(tok::kw___if_exists);
2089 Diag(Tok, diag::err_expected_lparen_after)
2090 << (Result.IsIfExists?
"__if_exists" :
"__if_not_exists");
2096 ParseOptionalCXXScopeSpecifier(Result.SS,
nullptr,
2100 if (Result.SS.isInvalid()) {
2108 Result.SS,
false,
true,
2109 true,
false,
nullptr,
2110 &TemplateKWLoc, Result.Name)) {
2120 Result.IsIfExists, Result.SS,
2123 Result.Behavior = Result.IsIfExists ? IEB_Parse : IEB_Skip;
2127 Result.Behavior = !Result.IsIfExists ? IEB_Parse : IEB_Skip;
2131 Result.Behavior = IEB_Dependent;
2141 void Parser::ParseMicrosoftIfExistsExternalDeclaration() {
2142 IfExistsCondition
Result;
2143 if (ParseMicrosoftIfExistsCondition(Result))
2148 Diag(Tok, diag::err_expected) << tok::l_brace;
2152 switch (Result.Behavior) {
2158 llvm_unreachable(
"Cannot have a dependent external declaration");
2167 while (Tok.
isNot(tok::r_brace) && !isEofOrEom()) {
2168 ParsedAttributesWithRange attrs(AttrFactory);
2169 MaybeParseCXX11Attributes(attrs);
2198 (Tok.
is(tok::kw_module) ||
2200 "not a module declaration");
2205 DiagnoseAndSkipCXX11Attributes();
2211 Diag(StartLoc, diag::err_global_module_introducer_not_at_start)
2216 Diag(StartLoc, diag::err_module_fragment_exported)
2226 Diag(StartLoc, diag::err_module_fragment_exported)
2231 DiagnoseAndSkipCXX11Attributes();
2232 ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);
2237 if (ParseModuleName(ModuleLoc, Path,
false))
2241 if (Tok.
is(tok::colon)) {
2244 if (ParseModuleName(ModuleLoc, Partition,
false))
2248 Diag(ColonLoc, diag::err_unsupported_module_partition)
2249 <<
SourceRange(ColonLoc, Partition.back().second);
2254 ParsedAttributesWithRange Attrs(AttrFactory);
2255 MaybeParseCXX11Attributes(Attrs);
2256 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr);
2258 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2260 return Actions.
ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path, IsFirstDecl);
2286 "Improper start to module import");
2291 Module *HeaderUnit =
nullptr;
2293 if (Tok.
is(tok::header_name)) {
2298 }
else if (Tok.
is(tok::annot_header_unit)) {
2301 ConsumeAnnotationToken();
2302 }
else if (
getLangOpts().CPlusPlusModules && Tok.
is(tok::colon)) {
2304 if (ParseModuleName(ImportLoc, Path,
true))
2308 Diag(ColonLoc, diag::err_unsupported_module_partition)
2312 if (ParseModuleName(ImportLoc, Path,
true))
2316 ParsedAttributesWithRange Attrs(AttrFactory);
2317 MaybeParseCXX11Attributes(Attrs);
2319 ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr);
2331 else if (!Path.empty())
2333 ExpectAndConsumeSemi(diag::err_module_expected_semi);
2339 if (IsObjCAtImport && AtLoc.
isValid()) {
2342 if (FE && llvm::sys::path::parent_path(FE->getDir()->getName())
2343 .endswith(
".framework"))
2344 Diags.
Report(AtLoc, diag::warn_atimport_in_framework_header);
2347 return Import.
get();
2357 bool Parser::ParseModuleName(
2363 if (!Tok.
is(tok::identifier)) {
2364 if (Tok.
is(tok::code_completion)) {
2370 Diag(Tok, diag::err_module_expected_ident) << IsImport;
2379 if (Tok.
isNot(tok::period))
2390 bool Parser::parseMisplacedModuleImport() {
2393 case tok::annot_module_end:
2397 if (MisplacedModuleBeginCount) {
2398 --MisplacedModuleBeginCount;
2400 reinterpret_cast<Module *
>(
2402 ConsumeAnnotationToken();
2409 case tok::annot_module_begin:
2412 reinterpret_cast<Module *
>(
2414 ConsumeAnnotationToken();
2415 ++MisplacedModuleBeginCount;
2417 case tok::annot_module_include:
2421 reinterpret_cast<Module *
>(
2423 ConsumeAnnotationToken();
2433 bool BalancedDelimiterTracker::diagnoseOverflow() {
2434 P.Diag(P.Tok, diag::err_bracket_depth_exceeded)
2435 << P.getLangOpts().BracketDepth;
2436 P.Diag(P.Tok, diag::note_bracket_depth);
2444 LOpen = P.Tok.getLocation();
2445 if (P.ExpectAndConsume(Kind, DiagID, Msg)) {
2446 if (SkipToTok != tok::unknown)
2451 if (getDepth() < P.getLangOpts().BracketDepth)
2454 return diagnoseOverflow();
2457 bool BalancedDelimiterTracker::diagnoseMissingClose() {
2458 assert(!P.Tok.is(Close) &&
"Should have consumed closing delimiter");
2460 if (P.Tok.is(tok::annot_module_end))
2461 P.Diag(P.Tok, diag::err_missing_before_module_end) << Close;
2463 P.Diag(P.Tok, diag::err_expected) << Close;
2464 P.Diag(LOpen, diag::note_matching) <<
Kind;
2468 if (P.Tok.isNot(tok::r_paren) && P.Tok.isNot(tok::r_brace) &&
2469 P.Tok.isNot(tok::r_square) &&
2470 P.SkipUntil(Close, FinalToken,
2473 LClose = P.ConsumeAnyToken();
Defines the clang::ASTContext interface.
Represents a function declaration or definition.
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
ParseScope - Introduces a new scope for parsing.
This is a scope that corresponds to the parameters within a function prototype.
void clear()
Reset the contents of this Declarator.
DeclResult ActOnModuleImport(SourceLocation StartLoc, SourceLocation ExportLoc, SourceLocation ImportLoc, ModuleIdPath Path)
The parser has processed a module import declaration.
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
void Initialize()
Initialize - Warm up the parser.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Code completion occurs within a class, struct, or union.
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc)
The parser has processed a private-module-fragment declaration that begins the definition of the priv...
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
Stmt - This represents one statement.
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization)
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)) {...
The name refers to a dependent template name:
bool isEmpty() const
No scope specifier.
Decl - This represents one declaration (or definition), e.g.
bool isCodeCompletionReached() const
Returns true if code-completion is enabled and we have hit the code-completion point.
Defines the C++ template declaration subclasses.
void CodeCompleteNaturalLanguage()
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...
SourceLocation getCloseLocation() const
This indicates that the scope corresponds to a function, which means that labels are set here...
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
TemplateNameKind Kind
The kind of template that Template refers to.
Wrapper for void* pointer.
Parser - This implements a parser for the C family of languages.
TSCS getThreadStorageClassSpec() const
NameClassificationKind getKind() const
const ParsedAttributes & getAttributes() const
void * SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS)
Given a C++ nested-name-specifier, produce an annotation value that the parser can use later to recon...
bool isKNRPrototype() const
isKNRPrototype - Return true if this is a K&R style identifier list, like "void foo(a,b,c)".
bool hadModuleLoaderFatalFailure() const
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
static const TSCS TSCS_unspecified
Information about one declarator, including the parsed type information and the identifier.
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
TypeSpecifierType
Specifies the kind of type.
static const TST TST_interface
RAIIObject to destroy the contents of a SmallVector of TemplateIdAnnotation pointers and clear the ve...
Describes how types, statements, expressions, and declarations should be printed. ...
Code completion occurs within an Objective-C implementation or category implementation.
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing...
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
bool canSkipFunctionBody(Decl *D)
Determine whether we can skip parsing the body of a function definition, assuming we don't care about...
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
friend class ObjCDeclContextSwitch
void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD, CachedTokens &Toks)
tok::TokenKind getKind() const
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Information about a template-id annotation token.
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
Decl * ActOnStartOfFunctionDef(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists, SkipBodyInfo *SkipBody=nullptr)
Represents a struct/union/class.
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
void SetPoisonReason(IdentifierInfo *II, unsigned DiagID)
Specifies the reason for poisoning an identifier.
One of these records is kept for each identifier that is lexed.
Lookup for the name failed, but we're assuming it was a template name anyway.
SourceLocation getTypeSpecTypeLoc() const
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
static const TST TST_class
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Token - This structure provides full information about a lexed token.
static const TST TST_enum
void CodeCompletePreprocessorMacroArgument(Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument)
TemplateName getTemplateName() const
void setKind(tok::TokenKind K)
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
void removeCommentHandler(CommentHandler *Handler)
Remove the specified comment handler.
bool hasTagDefinition() const
void ClearStorageClassSpecs()
Describes a module or submodule.
Code completion occurs at top-level or namespace context.
static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R)
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const
Return true if we have an ObjC keyword identifier.
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
Represents a C++ unqualified-id that has been parsed.
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 ...
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
void SetRangeBegin(SourceLocation Loc)
SetRangeBegin - Set the start of the source range to Loc, unless it's invalid.
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl *> Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
ExprResult getExpression() const
const clang::PrintingPolicy & getPrintingPolicy() const
void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
IfExistsResult CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS, const DeclarationNameInfo &TargetNameInfo)
const ParsingDeclSpec & getDeclSpec() const
void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
Scope - A scope is a transient data structure that is used while parsing the program.
Decl * ActOnFileScopeAsmDecl(Expr *expr, SourceLocation AsmLoc, SourceLocation RParenLoc)
Represents a C++ nested-name-specifier or a global scope specifier.
void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)
void setCodeCompletionHandler(CodeCompletionHandler &Handler)
Set the code completion handler to the given object.
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type...
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
SourceRange getSourceRange() const LLVM_READONLY
IdentifierInfo * getIdentifier() const
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
Sema - This implements semantic analysis and AST building for C.
A little helper class used to produce diagnostics.
A class for parsing a declarator.
void clearCodeCompletionHandler()
Clear out the code completion handler.
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
SourceRange getRange() const
void setAnnotationRange(SourceRange R)
TST getTypeSpecType() const
static bool isDeclRep(TST T)
void setAnnotationValue(void *val)
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
void CodeCompleteObjCMethodDecl(Scope *S, Optional< bool > IsInstanceMethod, ParsedType ReturnType)
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e...
void AnnotateCachedTokens(const Token &Tok)
We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
This file defines the classes used to store parsed information about declaration-specifiers and decla...
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, ParsedType ObjectType, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
void RevertCachedTokens(unsigned N)
When backtracking is enabled and tokens are cached, this allows to revert a specific number of tokens...
SourceLocation getThreadStorageClassSpecLoc() const
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
SourceLocation getBeginLoc() const
Decl * ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList, SourceLocation SemiLoc)
Handle a C++11 empty-declaration and attribute-declaration.
Represents a C++ template name within the type system.
This is a compound statement scope.
void CodeCompletePreprocessorExpression()
SourceLocation getStorageClassSpecLoc() const
const char * getPunctuatorSpelling(TokenKind Kind) LLVM_READNONE
Determines the spelling of simple punctuation tokens like '!' or '', and returns NULL for literal and...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc)
SourceLocation getEnd() const
Wraps an identifier and optional source location for the identifier.
The result type of a method or function.
const LangOptions & getLangOpts() const
This is a scope that corresponds to the parameters within a function prototype for a function declara...
SourceManager & getSourceManager() const
void CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition=nullptr, SkipBodyInfo *SkipBody=nullptr)
Decl * ActOnSkippedFunctionBody(Decl *Decl)
A class for parsing a DeclSpec.
void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls)
Stop skipping at semicolon.
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
void TypoCorrectToken(const Token &Tok)
Update the current token to represent the provided identifier, in order to cache an action performed ...
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
SCS getStorageClassSpec() const
ASTContext & getASTContext() const
Encodes a location in the source.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setCurrentOpenCLExtensionForDecl(Decl *FD)
Set current OpenCL extensions for a declaration which can only be used when these OpenCL extensions a...
bool TryAnnotateTypeOrScopeToken()
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
void ExitScope()
ExitScope - Pop a scope off the scope stack.
static const TST TST_union
IdentifierInfo * getIdentifierInfo() const
Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)
void setAnnotationEndLoc(SourceLocation L)
IdentifierTable & getIdentifierTable()
ParsedAttr - Represents a syntactic attribute.
ParsedType getType() const
void setIdentifierInfo(IdentifierInfo *II)
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them...
void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc)
bool canDelayFunctionBody(const Declarator &D)
Determine whether we can delay parsing the body of a function or function template until it is used...
void CodeCompletePreprocessorDirective(bool InConditional)
void Lex(Token &Result)
Lex the next token for this preprocessor.
TemplateNameKind getTemplateNameKind() const
void EnterScope(unsigned ScopeFlags)
EnterScope - Start a new scope.
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, bool IsAddressOfOperand, 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...
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
bool isObjCObjectPointerType() const
static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok)
void SetLateTemplateParser(LateTemplateParserCB *LTP, LateTemplateParserCleanupCB *LTPCleanup, void *P)
void EnterToken(const Token &Tok, bool IsReinject)
Enters a token in the token stream to be lexed next.
Scope * getCurScope() const
The name is a dependent name, so the results will differ from one instantiation to the next...
void Init(Scope *parent, unsigned flags)
Init - This is used by the parser to implement scope caching.
void ActOnStartOfTranslationUnit()
This is called before the very first declaration in the translation unit is parsed.
ASTConsumer & getASTConsumer() const
bool isInvalid() const
An error occurred during parsing of the scope specifier.
void CodeCompletePreprocessorMacroName(bool IsDefinition)
void setFunctionDefinitionKind(FunctionDefinitionKind Val)
Describes a module import declaration, which makes the contents of the named module visible in the cu...
The scope of a struct/union/class definition.
bool isNot(tok::TokenKind K) const
bool isBacktrackEnabled() const
True if EnableBacktrackAtThisPos() was called and caching of tokens is on.
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
'export module X;'
bool expectAndConsume(unsigned DiagID=diag::err_expected, const char *Msg="", tok::TokenKind SkipToTok=tok::unknown)
const Scope * getParent() const
getParent - Return the scope that this is nested in.
void addCommentHandler(CommentHandler *Handler)
Add the specified comment handler to the preprocessor.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
SkipUntilFlags
Control flags for SkipUntil functions.
TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, const CXXScopeSpec &SS, const IdentifierInfo &II, SourceLocation IdLoc)
Called when the parser has parsed a C++ typename specifier, e.g., "typename T::type".
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
The name refers to a template whose specialization produces a type.
static const TST TST_unspecified
Encapsulates the data about a macro definition (e.g.
void takeAttributesFrom(ParsedAttributes &attrs)
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl)
The parser has processed a module-declaration that begins the definition of a module interface or imp...
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.
SmallVector< TemplateParameterList *, 4 > TemplateParameterLists
This is a scope that can contain a declaration.
bool isObjCObjectType() const
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
NamedDecl * HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists)
SourceLocation getIdentifierLoc() const
void ActOnTranslationUnitScope(Scope *S)
bool isSet() const
Deprecated.
ParsingDeclSpec & getMutableDeclSpec() const
Captures information about "declaration specifiers".
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
SourceLocation getLastLoc() const
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
void ActOnPopScope(SourceLocation Loc, Scope *S)
Scope actions.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, bool IsNewScope)
Try to annotate a type or scope token, having already parsed an optional scope specifier.
static Decl::Kind getKind(const Decl *D)
void ActOnComment(SourceRange Comment)
static OpaquePtr make(TemplateName P)
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
virtual bool HandleTopLevelDecl(DeclGroupRef D)
HandleTopLevelDecl - Handle the specified top-level declaration.
static const TST TST_struct
void setLocation(SourceLocation L)
void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
A trivial tuple used to represent a source range.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
bool isTranslationUnit() const
bool isEditorPlaceholder() const
Returns true if this token is an editor placeholder.
unsigned NumArgs
NumArgs - The number of template arguments.
void * getAnnotationValue() const
SourceLocation getBegin() const
SourceLocation ColonLoc
Location of ':'.
void setCommaLoc(SourceLocation CL)
The symbol does not exist.
void CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
ParsedAttributes & getAttributes()
void startToken()
Reset all flags to cleared.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result)
Parse the first top-level declaration in a translation unit.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Stop skipping at specified token, but don't skip the token itself.