1//===--- Parser.cpp - C Language Family Parser ----------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Parser interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "RAIIObjectsForParser.h" 16#include "clang/AST/ASTConsumer.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/Parse/ParseDiagnostic.h" 20#include "clang/Sema/DeclSpec.h" 21#include "clang/Sema/ParsedTemplate.h" 22#include "clang/Sema/Scope.h" 23#include "llvm/Support/raw_ostream.h" 24using namespace clang; 25 26 27namespace { 28/// \brief A comment handler that passes comments found by the preprocessor 29/// to the parser action. 30class ActionCommentHandler : public CommentHandler { 31 Sema &S; 32 33public: 34 explicit ActionCommentHandler(Sema &S) : S(S) { } 35 36 bool HandleComment(Preprocessor &PP, SourceRange Comment) override { 37 S.ActOnComment(Comment); 38 return false; 39 } 40}; 41} // end anonymous namespace 42 43IdentifierInfo *Parser::getSEHExceptKeyword() { 44 // __except is accepted as a (contextual) keyword 45 if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland)) 46 Ident__except = PP.getIdentifierInfo("__except"); 47 48 return Ident__except; 49} 50 51Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies) 52 : PP(pp), Actions(actions), Diags(PP.getDiagnostics()), 53 GreaterThanIsOperator(true), ColonIsSacred(false), 54 InMessageExpression(false), TemplateParameterDepth(0), 55 ParsingInObjCContainer(false) { 56 SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies; 57 Tok.startToken(); 58 Tok.setKind(tok::eof); 59 Actions.CurScope = nullptr; 60 NumCachedScopes = 0; 61 ParenCount = BracketCount = BraceCount = 0; 62 CurParsedObjCImpl = nullptr; 63 64 // Add #pragma handlers. These are removed and destroyed in the 65 // destructor. 66 initializePragmaHandlers(); 67 68 CommentSemaHandler.reset(new ActionCommentHandler(actions)); 69 PP.addCommentHandler(CommentSemaHandler.get()); 70 71 PP.setCodeCompletionHandler(*this); 72} 73 74DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) { 75 return Diags.Report(Loc, DiagID); 76} 77 78DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) { 79 return Diag(Tok.getLocation(), DiagID); 80} 81 82/// \brief Emits a diagnostic suggesting parentheses surrounding a 83/// given range. 84/// 85/// \param Loc The location where we'll emit the diagnostic. 86/// \param DK The kind of diagnostic to emit. 87/// \param ParenRange Source range enclosing code that should be parenthesized. 88void Parser::SuggestParentheses(SourceLocation Loc, unsigned DK, 89 SourceRange ParenRange) { 90 SourceLocation EndLoc = PP.getLocForEndOfToken(ParenRange.getEnd()); 91 if (!ParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { 92 // We can't display the parentheses, so just dig the 93 // warning/error and return. 94 Diag(Loc, DK); 95 return; 96 } 97 98 Diag(Loc, DK) 99 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 100 << FixItHint::CreateInsertion(EndLoc, ")"); 101} 102 103static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok) { 104 switch (ExpectedTok) { 105 case tok::semi: 106 return Tok.is(tok::colon) || Tok.is(tok::comma); // : or , for ; 107 default: return false; 108 } 109} 110 111bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID, 112 StringRef Msg) { 113 if (Tok.is(ExpectedTok) || Tok.is(tok::code_completion)) { 114 ConsumeAnyToken(); 115 return false; 116 } 117 118 // Detect common single-character typos and resume. 119 if (IsCommonTypo(ExpectedTok, Tok)) { 120 SourceLocation Loc = Tok.getLocation(); 121 { 122 DiagnosticBuilder DB = Diag(Loc, DiagID); 123 DB << FixItHint::CreateReplacement( 124 SourceRange(Loc), tok::getPunctuatorSpelling(ExpectedTok)); 125 if (DiagID == diag::err_expected) 126 DB << ExpectedTok; 127 else if (DiagID == diag::err_expected_after) 128 DB << Msg << ExpectedTok; 129 else 130 DB << Msg; 131 } 132 133 // Pretend there wasn't a problem. 134 ConsumeAnyToken(); 135 return false; 136 } 137 138 SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); 139 const char *Spelling = nullptr; 140 if (EndLoc.isValid()) 141 Spelling = tok::getPunctuatorSpelling(ExpectedTok); 142 143 DiagnosticBuilder DB = 144 Spelling 145 ? Diag(EndLoc, DiagID) << FixItHint::CreateInsertion(EndLoc, Spelling) 146 : Diag(Tok, DiagID); 147 if (DiagID == diag::err_expected) 148 DB << ExpectedTok; 149 else if (DiagID == diag::err_expected_after) 150 DB << Msg << ExpectedTok; 151 else 152 DB << Msg; 153 154 return true; 155} 156 157bool Parser::ExpectAndConsumeSemi(unsigned DiagID) { 158 if (TryConsumeToken(tok::semi)) 159 return false; 160 161 if (Tok.is(tok::code_completion)) { 162 handleUnexpectedCodeCompletionToken(); 163 return false; 164 } 165 166 if ((Tok.is(tok::r_paren) || Tok.is(tok::r_square)) && 167 NextToken().is(tok::semi)) { 168 Diag(Tok, diag::err_extraneous_token_before_semi) 169 << PP.getSpelling(Tok) 170 << FixItHint::CreateRemoval(Tok.getLocation()); 171 ConsumeAnyToken(); // The ')' or ']'. 172 ConsumeToken(); // The ';'. 173 return false; 174 } 175 176 return ExpectAndConsume(tok::semi, DiagID); 177} 178 179void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST) { 180 if (!Tok.is(tok::semi)) return; 181 182 bool HadMultipleSemis = false; 183 SourceLocation StartLoc = Tok.getLocation(); 184 SourceLocation EndLoc = Tok.getLocation(); 185 ConsumeToken(); 186 187 while ((Tok.is(tok::semi) && !Tok.isAtStartOfLine())) { 188 HadMultipleSemis = true; 189 EndLoc = Tok.getLocation(); 190 ConsumeToken(); 191 } 192 193 // C++11 allows extra semicolons at namespace scope, but not in any of the 194 // other contexts. 195 if (Kind == OutsideFunction && getLangOpts().CPlusPlus) { 196 if (getLangOpts().CPlusPlus11) 197 Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi) 198 << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); 199 else 200 Diag(StartLoc, diag::ext_extra_semi_cxx11) 201 << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); 202 return; 203 } 204 205 if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis) 206 Diag(StartLoc, diag::ext_extra_semi) 207 << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST, 208 Actions.getASTContext().getPrintingPolicy()) 209 << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); 210 else 211 // A single semicolon is valid after a member function definition. 212 Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def) 213 << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); 214} 215 216//===----------------------------------------------------------------------===// 217// Error recovery. 218//===----------------------------------------------------------------------===// 219 220static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R) { 221 return (static_cast<unsigned>(L) & static_cast<unsigned>(R)) != 0; 222} 223 224/// SkipUntil - Read tokens until we get to the specified token, then consume 225/// it (unless no flag StopBeforeMatch). Because we cannot guarantee that the 226/// token will ever occur, this skips to the next token, or to some likely 227/// good stopping point. If StopAtSemi is true, skipping will stop at a ';' 228/// character. 229/// 230/// If SkipUntil finds the specified token, it returns true, otherwise it 231/// returns false. 232bool Parser::SkipUntil(ArrayRef<tok::TokenKind> Toks, SkipUntilFlags Flags) { 233 // We always want this function to skip at least one token if the first token 234 // isn't T and if not at EOF. 235 bool isFirstTokenSkipped = true; 236 while (1) { 237 // If we found one of the tokens, stop and return true. 238 for (unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) { 239 if (Tok.is(Toks[i])) { 240 if (HasFlagsSet(Flags, StopBeforeMatch)) { 241 // Noop, don't consume the token. 242 } else { 243 ConsumeAnyToken(); 244 } 245 return true; 246 } 247 } 248 249 // Important special case: The caller has given up and just wants us to 250 // skip the rest of the file. Do this without recursing, since we can 251 // get here precisely because the caller detected too much recursion. 252 if (Toks.size() == 1 && Toks[0] == tok::eof && 253 !HasFlagsSet(Flags, StopAtSemi) && 254 !HasFlagsSet(Flags, StopAtCodeCompletion)) { 255 while (Tok.isNot(tok::eof)) 256 ConsumeAnyToken(); 257 return true; 258 } 259 260 switch (Tok.getKind()) { 261 case tok::eof: 262 // Ran out of tokens. 263 return false; 264 265 case tok::annot_pragma_openmp_end: 266 // Stop before an OpenMP pragma boundary. 267 case tok::annot_module_begin: 268 case tok::annot_module_end: 269 case tok::annot_module_include: 270 // Stop before we change submodules. They generally indicate a "good" 271 // place to pick up parsing again (except in the special case where 272 // we're trying to skip to EOF). 273 return false; 274 275 case tok::code_completion: 276 if (!HasFlagsSet(Flags, StopAtCodeCompletion)) 277 handleUnexpectedCodeCompletionToken(); 278 return false; 279 280 case tok::l_paren: 281 // Recursively skip properly-nested parens. 282 ConsumeParen(); 283 if (HasFlagsSet(Flags, StopAtCodeCompletion)) 284 SkipUntil(tok::r_paren, StopAtCodeCompletion); 285 else 286 SkipUntil(tok::r_paren); 287 break; 288 case tok::l_square: 289 // Recursively skip properly-nested square brackets. 290 ConsumeBracket(); 291 if (HasFlagsSet(Flags, StopAtCodeCompletion)) 292 SkipUntil(tok::r_square, StopAtCodeCompletion); 293 else 294 SkipUntil(tok::r_square); 295 break; 296 case tok::l_brace: 297 // Recursively skip properly-nested braces. 298 ConsumeBrace(); 299 if (HasFlagsSet(Flags, StopAtCodeCompletion)) 300 SkipUntil(tok::r_brace, StopAtCodeCompletion); 301 else 302 SkipUntil(tok::r_brace); 303 break; 304 305 // Okay, we found a ']' or '}' or ')', which we think should be balanced. 306 // Since the user wasn't looking for this token (if they were, it would 307 // already be handled), this isn't balanced. If there is a LHS token at a 308 // higher level, we will assume that this matches the unbalanced token 309 // and return it. Otherwise, this is a spurious RHS token, which we skip. 310 case tok::r_paren: 311 if (ParenCount && !isFirstTokenSkipped) 312 return false; // Matches something. 313 ConsumeParen(); 314 break; 315 case tok::r_square: 316 if (BracketCount && !isFirstTokenSkipped) 317 return false; // Matches something. 318 ConsumeBracket(); 319 break; 320 case tok::r_brace: 321 if (BraceCount && !isFirstTokenSkipped) 322 return false; // Matches something. 323 ConsumeBrace(); 324 break; 325 326 case tok::string_literal: 327 case tok::wide_string_literal: 328 case tok::utf8_string_literal: 329 case tok::utf16_string_literal: 330 case tok::utf32_string_literal: 331 ConsumeStringToken(); 332 break; 333 334 case tok::semi: 335 if (HasFlagsSet(Flags, StopAtSemi)) 336 return false; 337 // FALL THROUGH. 338 default: 339 // Skip this token. 340 ConsumeToken(); 341 break; 342 } 343 isFirstTokenSkipped = false; 344 } 345} 346 347//===----------------------------------------------------------------------===// 348// Scope manipulation 349//===----------------------------------------------------------------------===// 350 351/// EnterScope - Start a new scope. 352void Parser::EnterScope(unsigned ScopeFlags) { 353 if (NumCachedScopes) { 354 Scope *N = ScopeCache[--NumCachedScopes]; 355 N->Init(getCurScope(), ScopeFlags); 356 Actions.CurScope = N; 357 } else { 358 Actions.CurScope = new Scope(getCurScope(), ScopeFlags, Diags); 359 } 360} 361 362/// ExitScope - Pop a scope off the scope stack. 363void Parser::ExitScope() { 364 assert(getCurScope() && "Scope imbalance!"); 365 366 // Inform the actions module that this scope is going away if there are any 367 // decls in it. 368 Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); 369 370 Scope *OldScope = getCurScope(); 371 Actions.CurScope = OldScope->getParent(); 372 373 if (NumCachedScopes == ScopeCacheSize) 374 delete OldScope; 375 else 376 ScopeCache[NumCachedScopes++] = OldScope; 377} 378 379/// Set the flags for the current scope to ScopeFlags. If ManageFlags is false, 380/// this object does nothing. 381Parser::ParseScopeFlags::ParseScopeFlags(Parser *Self, unsigned ScopeFlags, 382 bool ManageFlags) 383 : CurScope(ManageFlags ? Self->getCurScope() : nullptr) { 384 if (CurScope) { 385 OldFlags = CurScope->getFlags(); 386 CurScope->setFlags(ScopeFlags); 387 } 388} 389 390/// Restore the flags for the current scope to what they were before this 391/// object overrode them. 392Parser::ParseScopeFlags::~ParseScopeFlags() { 393 if (CurScope) 394 CurScope->setFlags(OldFlags); 395} 396 397 398//===----------------------------------------------------------------------===// 399// C99 6.9: External Definitions. 400//===----------------------------------------------------------------------===// 401 402Parser::~Parser() { 403 // If we still have scopes active, delete the scope tree. 404 delete getCurScope(); 405 Actions.CurScope = nullptr; 406 407 // Free the scope cache. 408 for (unsigned i = 0, e = NumCachedScopes; i != e; ++i) 409 delete ScopeCache[i]; 410 411 resetPragmaHandlers(); 412 413 PP.removeCommentHandler(CommentSemaHandler.get()); 414 415 PP.clearCodeCompletionHandler(); 416 417 assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?"); 418} 419 420/// Initialize - Warm up the parser. 421/// 422void Parser::Initialize() { 423 // Create the translation unit scope. Install it as the current scope. 424 assert(getCurScope() == nullptr && "A scope is already active?"); 425 EnterScope(Scope::DeclScope); 426 Actions.ActOnTranslationUnitScope(getCurScope()); 427 428 // Initialization for Objective-C context sensitive keywords recognition. 429 // Referenced in Parser::ParseObjCTypeQualifierList. 430 if (getLangOpts().ObjC1) { 431 ObjCTypeQuals[objc_in] = &PP.getIdentifierTable().get("in"); 432 ObjCTypeQuals[objc_out] = &PP.getIdentifierTable().get("out"); 433 ObjCTypeQuals[objc_inout] = &PP.getIdentifierTable().get("inout"); 434 ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway"); 435 ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy"); 436 ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref"); 437 } 438 439 Ident_instancetype = nullptr; 440 Ident_final = nullptr; 441 Ident_sealed = nullptr; 442 Ident_override = nullptr; 443 444 Ident_super = &PP.getIdentifierTable().get("super"); 445 446 if (getLangOpts().AltiVec) { 447 Ident_vector = &PP.getIdentifierTable().get("vector"); 448 Ident_pixel = &PP.getIdentifierTable().get("pixel"); 449 Ident_bool = &PP.getIdentifierTable().get("bool"); 450 } 451 452 Ident_introduced = nullptr; 453 Ident_deprecated = nullptr; 454 Ident_obsoleted = nullptr; 455 Ident_unavailable = nullptr; 456 457 Ident__except = nullptr; 458 459 Ident__exception_code = Ident__exception_info = nullptr; 460 Ident__abnormal_termination = Ident___exception_code = nullptr; 461 Ident___exception_info = Ident___abnormal_termination = nullptr; 462 Ident_GetExceptionCode = Ident_GetExceptionInfo = nullptr; 463 Ident_AbnormalTermination = nullptr; 464 465 if(getLangOpts().Borland) { 466 Ident__exception_info = PP.getIdentifierInfo("_exception_info"); 467 Ident___exception_info = PP.getIdentifierInfo("__exception_info"); 468 Ident_GetExceptionInfo = PP.getIdentifierInfo("GetExceptionInformation"); 469 Ident__exception_code = PP.getIdentifierInfo("_exception_code"); 470 Ident___exception_code = PP.getIdentifierInfo("__exception_code"); 471 Ident_GetExceptionCode = PP.getIdentifierInfo("GetExceptionCode"); 472 Ident__abnormal_termination = PP.getIdentifierInfo("_abnormal_termination"); 473 Ident___abnormal_termination = PP.getIdentifierInfo("__abnormal_termination"); 474 Ident_AbnormalTermination = PP.getIdentifierInfo("AbnormalTermination"); 475 476 PP.SetPoisonReason(Ident__exception_code,diag::err_seh___except_block); 477 PP.SetPoisonReason(Ident___exception_code,diag::err_seh___except_block); 478 PP.SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block); 479 PP.SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter); 480 PP.SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter); 481 PP.SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter); 482 PP.SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block); 483 PP.SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block); 484 PP.SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block); 485 } 486 487 Actions.Initialize(); 488 489 // Prime the lexer look-ahead. 490 ConsumeToken(); 491} 492 493namespace { 494 /// \brief RAIIObject to destroy the contents of a SmallVector of 495 /// TemplateIdAnnotation pointers and clear the vector. 496 class DestroyTemplateIdAnnotationsRAIIObj { 497 SmallVectorImpl<TemplateIdAnnotation *> &Container; 498 public: 499 DestroyTemplateIdAnnotationsRAIIObj(SmallVectorImpl<TemplateIdAnnotation *> 500 &Container) 501 : Container(Container) {} 502 503 ~DestroyTemplateIdAnnotationsRAIIObj() { 504 for (SmallVectorImpl<TemplateIdAnnotation *>::iterator I = 505 Container.begin(), E = Container.end(); 506 I != E; ++I) 507 (*I)->Destroy(); 508 Container.clear(); 509 } 510 }; 511} 512 513void Parser::LateTemplateParserCleanupCallback(void *P) { 514 // While this RAII helper doesn't bracket any actual work, the destructor will 515 // clean up annotations that were created during ActOnEndOfTranslationUnit 516 // when incremental processing is enabled. 517 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(((Parser *)P)->TemplateIds); 518} 519 520/// ParseTopLevelDecl - Parse one top-level declaration, return whatever the 521/// action tells us to. This returns true if the EOF was encountered. 522bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result) { 523 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); 524 525 // Skip over the EOF token, flagging end of previous input for incremental 526 // processing 527 if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof)) 528 ConsumeToken(); 529 530 Result = DeclGroupPtrTy(); 531 switch (Tok.getKind()) { 532 case tok::annot_pragma_unused: 533 HandlePragmaUnused(); 534 return false; 535 536 case tok::annot_module_include: 537 Actions.ActOnModuleInclude(Tok.getLocation(), 538 reinterpret_cast<Module *>( 539 Tok.getAnnotationValue())); 540 ConsumeToken(); 541 return false; 542 543 case tok::annot_module_begin: 544 case tok::annot_module_end: 545 // FIXME: Update visibility based on the submodule we're in. 546 ConsumeToken(); 547 return false; 548 549 case tok::eof: 550 // Late template parsing can begin. 551 if (getLangOpts().DelayedTemplateParsing) 552 Actions.SetLateTemplateParser(LateTemplateParserCallback, 553 PP.isIncrementalProcessingEnabled() ? 554 LateTemplateParserCleanupCallback : nullptr, 555 this); 556 if (!PP.isIncrementalProcessingEnabled()) 557 Actions.ActOnEndOfTranslationUnit(); 558 //else don't tell Sema that we ended parsing: more input might come. 559 return true; 560 561 default: 562 break; 563 } 564 565 ParsedAttributesWithRange attrs(AttrFactory); 566 MaybeParseCXX11Attributes(attrs); 567 MaybeParseMicrosoftAttributes(attrs); 568 569 Result = ParseExternalDeclaration(attrs); 570 return false; 571} 572 573/// ParseExternalDeclaration: 574/// 575/// external-declaration: [C99 6.9], declaration: [C++ dcl.dcl] 576/// function-definition 577/// declaration 578/// [GNU] asm-definition 579/// [GNU] __extension__ external-declaration 580/// [OBJC] objc-class-definition 581/// [OBJC] objc-class-declaration 582/// [OBJC] objc-alias-declaration 583/// [OBJC] objc-protocol-definition 584/// [OBJC] objc-method-definition 585/// [OBJC] @end 586/// [C++] linkage-specification 587/// [GNU] asm-definition: 588/// simple-asm-expr ';' 589/// [C++11] empty-declaration 590/// [C++11] attribute-declaration 591/// 592/// [C++11] empty-declaration: 593/// ';' 594/// 595/// [C++0x/GNU] 'extern' 'template' declaration 596Parser::DeclGroupPtrTy 597Parser::ParseExternalDeclaration(ParsedAttributesWithRange &attrs, 598 ParsingDeclSpec *DS) { 599 DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); 600 ParenBraceBracketBalancer BalancerRAIIObj(*this); 601 602 if (PP.isCodeCompletionReached()) { 603 cutOffParsing(); 604 return DeclGroupPtrTy(); 605 } 606 607 Decl *SingleDecl = nullptr; 608 switch (Tok.getKind()) { 609 case tok::annot_pragma_vis: 610 HandlePragmaVisibility(); 611 return DeclGroupPtrTy(); 612 case tok::annot_pragma_pack: 613 HandlePragmaPack(); 614 return DeclGroupPtrTy(); 615 case tok::annot_pragma_msstruct: 616 HandlePragmaMSStruct(); 617 return DeclGroupPtrTy(); 618 case tok::annot_pragma_align: 619 HandlePragmaAlign(); 620 return DeclGroupPtrTy(); 621 case tok::annot_pragma_weak: 622 HandlePragmaWeak(); 623 return DeclGroupPtrTy(); 624 case tok::annot_pragma_weakalias: 625 HandlePragmaWeakAlias(); 626 return DeclGroupPtrTy(); 627 case tok::annot_pragma_redefine_extname: 628 HandlePragmaRedefineExtname(); 629 return DeclGroupPtrTy(); 630 case tok::annot_pragma_fp_contract: 631 HandlePragmaFPContract(); 632 return DeclGroupPtrTy(); 633 case tok::annot_pragma_opencl_extension: 634 HandlePragmaOpenCLExtension(); 635 return DeclGroupPtrTy(); 636 case tok::annot_pragma_openmp: 637 return ParseOpenMPDeclarativeDirective(); 638 case tok::annot_pragma_ms_pointers_to_members: 639 HandlePragmaMSPointersToMembers(); 640 return DeclGroupPtrTy(); 641 case tok::annot_pragma_ms_vtordisp: 642 HandlePragmaMSVtorDisp(); 643 return DeclGroupPtrTy(); 644 case tok::annot_pragma_ms_pragma: 645 HandlePragmaMSPragma(); 646 return DeclGroupPtrTy(); 647 case tok::semi: 648 // Either a C++11 empty-declaration or attribute-declaration. 649 SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), 650 attrs.getList(), 651 Tok.getLocation()); 652 ConsumeExtraSemi(OutsideFunction); 653 break; 654 case tok::r_brace: 655 Diag(Tok, diag::err_extraneous_closing_brace); 656 ConsumeBrace(); 657 return DeclGroupPtrTy(); 658 case tok::eof: 659 Diag(Tok, diag::err_expected_external_declaration); 660 return DeclGroupPtrTy(); 661 case tok::kw___extension__: { 662 // __extension__ silences extension warnings in the subexpression. 663 ExtensionRAIIObject O(Diags); // Use RAII to do this. 664 ConsumeToken(); 665 return ParseExternalDeclaration(attrs); 666 } 667 case tok::kw_asm: { 668 ProhibitAttributes(attrs); 669 670 SourceLocation StartLoc = Tok.getLocation(); 671 SourceLocation EndLoc; 672 ExprResult Result(ParseSimpleAsm(&EndLoc)); 673 674 ExpectAndConsume(tok::semi, diag::err_expected_after, 675 "top-level asm block"); 676 677 if (Result.isInvalid()) 678 return DeclGroupPtrTy(); 679 SingleDecl = Actions.ActOnFileScopeAsmDecl(Result.get(), StartLoc, EndLoc); 680 break; 681 } 682 case tok::at: 683 return ParseObjCAtDirectives(); 684 case tok::minus: 685 case tok::plus: 686 if (!getLangOpts().ObjC1) { 687 Diag(Tok, diag::err_expected_external_declaration); 688 ConsumeToken(); 689 return DeclGroupPtrTy(); 690 } 691 SingleDecl = ParseObjCMethodDefinition(); 692 break; 693 case tok::code_completion: 694 Actions.CodeCompleteOrdinaryName(getCurScope(), 695 CurParsedObjCImpl? Sema::PCC_ObjCImplementation 696 : Sema::PCC_Namespace); 697 cutOffParsing(); 698 return DeclGroupPtrTy(); 699 case tok::kw_using: 700 case tok::kw_namespace: 701 case tok::kw_typedef: 702 case tok::kw_template: 703 case tok::kw_export: // As in 'export template' 704 case tok::kw_static_assert: 705 case tok::kw__Static_assert: 706 // A function definition cannot start with any of these keywords. 707 { 708 SourceLocation DeclEnd; 709 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); 710 } 711 712 case tok::kw_static: 713 // Parse (then ignore) 'static' prior to a template instantiation. This is 714 // a GCC extension that we intentionally do not support. 715 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { 716 Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) 717 << 0; 718 SourceLocation DeclEnd; 719 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); 720 } 721 goto dont_know; 722 723 case tok::kw_inline: 724 if (getLangOpts().CPlusPlus) { 725 tok::TokenKind NextKind = NextToken().getKind(); 726 727 // Inline namespaces. Allowed as an extension even in C++03. 728 if (NextKind == tok::kw_namespace) { 729 SourceLocation DeclEnd; 730 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); 731 } 732 733 // Parse (then ignore) 'inline' prior to a template instantiation. This is 734 // a GCC extension that we intentionally do not support. 735 if (NextKind == tok::kw_template) { 736 Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) 737 << 1; 738 SourceLocation DeclEnd; 739 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); 740 } 741 } 742 goto dont_know; 743 744 case tok::kw_extern: 745 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { 746 // Extern templates 747 SourceLocation ExternLoc = ConsumeToken(); 748 SourceLocation TemplateLoc = ConsumeToken(); 749 Diag(ExternLoc, getLangOpts().CPlusPlus11 ? 750 diag::warn_cxx98_compat_extern_template : 751 diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc); 752 SourceLocation DeclEnd; 753 return Actions.ConvertDeclToDeclGroup( 754 ParseExplicitInstantiation(Declarator::FileContext, 755 ExternLoc, TemplateLoc, DeclEnd)); 756 } 757 goto dont_know; 758 759 case tok::kw___if_exists: 760 case tok::kw___if_not_exists: 761 ParseMicrosoftIfExistsExternalDeclaration(); 762 return DeclGroupPtrTy(); 763 764 default: 765 dont_know: 766 // We can't tell whether this is a function-definition or declaration yet. 767 return ParseDeclarationOrFunctionDefinition(attrs, DS); 768 } 769 770 // This routine returns a DeclGroup, if the thing we parsed only contains a 771 // single decl, convert it now. 772 return Actions.ConvertDeclToDeclGroup(SingleDecl); 773} 774 775/// \brief Determine whether the current token, if it occurs after a 776/// declarator, continues a declaration or declaration list. 777bool Parser::isDeclarationAfterDeclarator() { 778 // Check for '= delete' or '= default' 779 if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { 780 const Token &KW = NextToken(); 781 if (KW.is(tok::kw_default) || KW.is(tok::kw_delete)) 782 return false; 783 } 784 785 return Tok.is(tok::equal) || // int X()= -> not a function def 786 Tok.is(tok::comma) || // int X(), -> not a function def 787 Tok.is(tok::semi) || // int X(); -> not a function def 788 Tok.is(tok::kw_asm) || // int X() __asm__ -> not a function def 789 Tok.is(tok::kw___attribute) || // int X() __attr__ -> not a function def 790 (getLangOpts().CPlusPlus && 791 Tok.is(tok::l_paren)); // int X(0) -> not a function def [C++] 792} 793 794/// \brief Determine whether the current token, if it occurs after a 795/// declarator, indicates the start of a function definition. 796bool Parser::isStartOfFunctionDefinition(const ParsingDeclarator &Declarator) { 797 assert(Declarator.isFunctionDeclarator() && "Isn't a function declarator"); 798 if (Tok.is(tok::l_brace)) // int X() {} 799 return true; 800 801 // Handle K&R C argument lists: int X(f) int f; {} 802 if (!getLangOpts().CPlusPlus && 803 Declarator.getFunctionTypeInfo().isKNRPrototype()) 804 return isDeclarationSpecifier(); 805 806 if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { 807 const Token &KW = NextToken(); 808 return KW.is(tok::kw_default) || KW.is(tok::kw_delete); 809 } 810 811 return Tok.is(tok::colon) || // X() : Base() {} (used for ctors) 812 Tok.is(tok::kw_try); // X() try { ... } 813} 814 815/// ParseDeclarationOrFunctionDefinition - Parse either a function-definition or 816/// a declaration. We can't tell which we have until we read up to the 817/// compound-statement in function-definition. TemplateParams, if 818/// non-NULL, provides the template parameters when we're parsing a 819/// C++ template-declaration. 820/// 821/// function-definition: [C99 6.9.1] 822/// decl-specs declarator declaration-list[opt] compound-statement 823/// [C90] function-definition: [C99 6.7.1] - implicit int result 824/// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement 825/// 826/// declaration: [C99 6.7] 827/// declaration-specifiers init-declarator-list[opt] ';' 828/// [!C99] init-declarator-list ';' [TODO: warn in c99 mode] 829/// [OMP] threadprivate-directive [TODO] 830/// 831Parser::DeclGroupPtrTy 832Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs, 833 ParsingDeclSpec &DS, 834 AccessSpecifier AS) { 835 // Parse the common declaration-specifiers piece. 836 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC_top_level); 837 838 // If we had a free-standing type definition with a missing semicolon, we 839 // may get this far before the problem becomes obvious. 840 if (DS.hasTagDefinition() && 841 DiagnoseMissingSemiAfterTagDefinition(DS, AS, DSC_top_level)) 842 return DeclGroupPtrTy(); 843 844 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 845 // declaration-specifiers init-declarator-list[opt] ';' 846 if (Tok.is(tok::semi)) { 847 ProhibitAttributes(attrs); 848 ConsumeToken(); 849 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS); 850 DS.complete(TheDecl); 851 return Actions.ConvertDeclToDeclGroup(TheDecl); 852 } 853 854 DS.takeAttributesFrom(attrs); 855 856 // ObjC2 allows prefix attributes on class interfaces and protocols. 857 // FIXME: This still needs better diagnostics. We should only accept 858 // attributes here, no types, etc. 859 if (getLangOpts().ObjC2 && Tok.is(tok::at)) { 860 SourceLocation AtLoc = ConsumeToken(); // the "@" 861 if (!Tok.isObjCAtKeyword(tok::objc_interface) && 862 !Tok.isObjCAtKeyword(tok::objc_protocol)) { 863 Diag(Tok, diag::err_objc_unexpected_attr); 864 SkipUntil(tok::semi); // FIXME: better skip? 865 return DeclGroupPtrTy(); 866 } 867 868 DS.abort(); 869 870 const char *PrevSpec = nullptr; 871 unsigned DiagID; 872 if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID, 873 Actions.getASTContext().getPrintingPolicy())) 874 Diag(AtLoc, DiagID) << PrevSpec; 875 876 if (Tok.isObjCAtKeyword(tok::objc_protocol)) 877 return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes()); 878 879 return Actions.ConvertDeclToDeclGroup( 880 ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes())); 881 } 882 883 // If the declspec consisted only of 'extern' and we have a string 884 // literal following it, this must be a C++ linkage specifier like 885 // 'extern "C"'. 886 if (getLangOpts().CPlusPlus && isTokenStringLiteral() && 887 DS.getStorageClassSpec() == DeclSpec::SCS_extern && 888 DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) { 889 Decl *TheDecl = ParseLinkage(DS, Declarator::FileContext); 890 return Actions.ConvertDeclToDeclGroup(TheDecl); 891 } 892 893 return ParseDeclGroup(DS, Declarator::FileContext); 894} 895 896Parser::DeclGroupPtrTy 897Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs, 898 ParsingDeclSpec *DS, 899 AccessSpecifier AS) { 900 if (DS) { 901 return ParseDeclOrFunctionDefInternal(attrs, *DS, AS); 902 } else { 903 ParsingDeclSpec PDS(*this); 904 // Must temporarily exit the objective-c container scope for 905 // parsing c constructs and re-enter objc container scope 906 // afterwards. 907 ObjCDeclContextSwitch ObjCDC(*this); 908 909 return ParseDeclOrFunctionDefInternal(attrs, PDS, AS); 910 } 911} 912 913/// ParseFunctionDefinition - We parsed and verified that the specified 914/// Declarator is well formed. If this is a K&R-style function, read the 915/// parameters declaration-list, then start the compound-statement. 916/// 917/// function-definition: [C99 6.9.1] 918/// decl-specs declarator declaration-list[opt] compound-statement 919/// [C90] function-definition: [C99 6.7.1] - implicit int result 920/// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement 921/// [C++] function-definition: [C++ 8.4] 922/// decl-specifier-seq[opt] declarator ctor-initializer[opt] 923/// function-body 924/// [C++] function-definition: [C++ 8.4] 925/// decl-specifier-seq[opt] declarator function-try-block 926/// 927Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, 928 const ParsedTemplateInfo &TemplateInfo, 929 LateParsedAttrList *LateParsedAttrs) { 930 // Poison SEH identifiers so they are flagged as illegal in function bodies. 931 PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true); 932 const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 933 934 // If this is C90 and the declspecs were completely missing, fudge in an 935 // implicit int. We do this here because this is the only place where 936 // declaration-specifiers are completely optional in the grammar. 937 if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) { 938 const char *PrevSpec; 939 unsigned DiagID; 940 const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); 941 D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int, 942 D.getIdentifierLoc(), 943 PrevSpec, DiagID, 944 Policy); 945 D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin()); 946 } 947 948 // If this declaration was formed with a K&R-style identifier list for the 949 // arguments, parse declarations for all of the args next. 950 // int foo(a,b) int a; float b; {} 951 if (FTI.isKNRPrototype()) 952 ParseKNRParamDeclarations(D); 953 954 // We should have either an opening brace or, in a C++ constructor, 955 // we may have a colon. 956 if (Tok.isNot(tok::l_brace) && 957 (!getLangOpts().CPlusPlus || 958 (Tok.isNot(tok::colon) && Tok.isNot(tok::kw_try) && 959 Tok.isNot(tok::equal)))) { 960 Diag(Tok, diag::err_expected_fn_body); 961 962 // Skip over garbage, until we get to '{'. Don't eat the '{'. 963 SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); 964 965 // If we didn't find the '{', bail out. 966 if (Tok.isNot(tok::l_brace)) 967 return nullptr; 968 } 969 970 // Check to make sure that any normal attributes are allowed to be on 971 // a definition. Late parsed attributes are checked at the end. 972 if (Tok.isNot(tok::equal)) { 973 AttributeList *DtorAttrs = D.getAttributes(); 974 while (DtorAttrs) { 975 if (DtorAttrs->isKnownToGCC() && 976 !DtorAttrs->isCXX11Attribute()) { 977 Diag(DtorAttrs->getLoc(), diag::warn_attribute_on_function_definition) 978 << DtorAttrs->getName(); 979 } 980 DtorAttrs = DtorAttrs->getNext(); 981 } 982 } 983 984 // In delayed template parsing mode, for function template we consume the 985 // tokens and store them for late parsing at the end of the translation unit. 986 if (getLangOpts().DelayedTemplateParsing && Tok.isNot(tok::equal) && 987 TemplateInfo.Kind == ParsedTemplateInfo::Template && 988 Actions.canDelayFunctionBody(D)) { 989 MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams); 990 991 ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); 992 Scope *ParentScope = getCurScope()->getParent(); 993 994 D.setFunctionDefinitionKind(FDK_Definition); 995 Decl *DP = Actions.HandleDeclarator(ParentScope, D, 996 TemplateParameterLists); 997 D.complete(DP); 998 D.getMutableDeclSpec().abort(); 999 1000 CachedTokens Toks; 1001 LexTemplateFunctionForLateParsing(Toks); 1002 1003 if (DP) { 1004 FunctionDecl *FnD = DP->getAsFunction(); 1005 Actions.CheckForFunctionRedefinition(FnD); 1006 Actions.MarkAsLateParsedTemplate(FnD, DP, Toks); 1007 } 1008 return DP; 1009 } 1010 else if (CurParsedObjCImpl && 1011 !TemplateInfo.TemplateParams && 1012 (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || 1013 Tok.is(tok::colon)) && 1014 Actions.CurContext->isTranslationUnit()) { 1015 ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); 1016 Scope *ParentScope = getCurScope()->getParent(); 1017 1018 D.setFunctionDefinitionKind(FDK_Definition); 1019 Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D, 1020 MultiTemplateParamsArg()); 1021 D.complete(FuncDecl); 1022 D.getMutableDeclSpec().abort(); 1023 if (FuncDecl) { 1024 // Consume the tokens and store them for later parsing. 1025 StashAwayMethodOrFunctionBodyTokens(FuncDecl); 1026 CurParsedObjCImpl->HasCFunction = true; 1027 return FuncDecl; 1028 } 1029 // FIXME: Should we really fall through here? 1030 } 1031 1032 // Enter a scope for the function body. 1033 ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); 1034 1035 // Tell the actions module that we have entered a function definition with the 1036 // specified Declarator for the function. 1037 Decl *Res = TemplateInfo.TemplateParams? 1038 Actions.ActOnStartOfFunctionTemplateDef(getCurScope(), 1039 *TemplateInfo.TemplateParams, D) 1040 : Actions.ActOnStartOfFunctionDef(getCurScope(), D); 1041 1042 // Break out of the ParsingDeclarator context before we parse the body. 1043 D.complete(Res); 1044 1045 // Break out of the ParsingDeclSpec context, too. This const_cast is 1046 // safe because we're always the sole owner. 1047 D.getMutableDeclSpec().abort(); 1048 1049 if (TryConsumeToken(tok::equal)) { 1050 assert(getLangOpts().CPlusPlus && "Only C++ function definitions have '='"); 1051 1052 bool Delete = false; 1053 SourceLocation KWLoc; 1054 if (TryConsumeToken(tok::kw_delete, KWLoc)) { 1055 Diag(KWLoc, getLangOpts().CPlusPlus11 1056 ? diag::warn_cxx98_compat_deleted_function 1057 : diag::ext_deleted_function); 1058 Actions.SetDeclDeleted(Res, KWLoc); 1059 Delete = true; 1060 } else if (TryConsumeToken(tok::kw_default, KWLoc)) { 1061 Diag(KWLoc, getLangOpts().CPlusPlus11 1062 ? diag::warn_cxx98_compat_defaulted_function 1063 : diag::ext_defaulted_function); 1064 Actions.SetDeclDefaulted(Res, KWLoc); 1065 } else { 1066 llvm_unreachable("function definition after = not 'delete' or 'default'"); 1067 } 1068 1069 if (Tok.is(tok::comma)) { 1070 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) 1071 << Delete; 1072 SkipUntil(tok::semi); 1073 } else if (ExpectAndConsume(tok::semi, diag::err_expected_after, 1074 Delete ? "delete" : "default")) { 1075 SkipUntil(tok::semi); 1076 } 1077 1078 Stmt *GeneratedBody = Res ? Res->getBody() : nullptr; 1079 Actions.ActOnFinishFunctionBody(Res, GeneratedBody, false); 1080 return Res; 1081 } 1082 1083 if (Tok.is(tok::kw_try)) 1084 return ParseFunctionTryBlock(Res, BodyScope); 1085 1086 // If we have a colon, then we're probably parsing a C++ 1087 // ctor-initializer. 1088 if (Tok.is(tok::colon)) { 1089 ParseConstructorInitializer(Res); 1090 1091 // Recover from error. 1092 if (!Tok.is(tok::l_brace)) { 1093 BodyScope.Exit(); 1094 Actions.ActOnFinishFunctionBody(Res, nullptr); 1095 return Res; 1096 } 1097 } else 1098 Actions.ActOnDefaultCtorInitializers(Res); 1099 1100 // Late attributes are parsed in the same scope as the function body. 1101 if (LateParsedAttrs) 1102 ParseLexedAttributeList(*LateParsedAttrs, Res, false, true); 1103 1104 return ParseFunctionStatementBody(Res, BodyScope); 1105} 1106 1107/// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides 1108/// types for a function with a K&R-style identifier list for arguments. 1109void Parser::ParseKNRParamDeclarations(Declarator &D) { 1110 // We know that the top-level of this declarator is a function. 1111 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 1112 1113 // Enter function-declaration scope, limiting any declarators to the 1114 // function prototype scope, including parameter declarators. 1115 ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | 1116 Scope::FunctionDeclarationScope | Scope::DeclScope); 1117 1118 // Read all the argument declarations. 1119 while (isDeclarationSpecifier()) { 1120 SourceLocation DSStart = Tok.getLocation(); 1121 1122 // Parse the common declaration-specifiers piece. 1123 DeclSpec DS(AttrFactory); 1124 ParseDeclarationSpecifiers(DS); 1125 1126 // C99 6.9.1p6: 'each declaration in the declaration list shall have at 1127 // least one declarator'. 1128 // NOTE: GCC just makes this an ext-warn. It's not clear what it does with 1129 // the declarations though. It's trivial to ignore them, really hard to do 1130 // anything else with them. 1131 if (TryConsumeToken(tok::semi)) { 1132 Diag(DSStart, diag::err_declaration_does_not_declare_param); 1133 continue; 1134 } 1135 1136 // C99 6.9.1p6: Declarations shall contain no storage-class specifiers other 1137 // than register. 1138 if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 1139 DS.getStorageClassSpec() != DeclSpec::SCS_register) { 1140 Diag(DS.getStorageClassSpecLoc(), 1141 diag::err_invalid_storage_class_in_func_decl); 1142 DS.ClearStorageClassSpecs(); 1143 } 1144 if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) { 1145 Diag(DS.getThreadStorageClassSpecLoc(), 1146 diag::err_invalid_storage_class_in_func_decl); 1147 DS.ClearStorageClassSpecs(); 1148 } 1149 1150 // Parse the first declarator attached to this declspec. 1151 Declarator ParmDeclarator(DS, Declarator::KNRTypeListContext); 1152 ParseDeclarator(ParmDeclarator); 1153 1154 // Handle the full declarator list. 1155 while (1) { 1156 // If attributes are present, parse them. 1157 MaybeParseGNUAttributes(ParmDeclarator); 1158 1159 // Ask the actions module to compute the type for this declarator. 1160 Decl *Param = 1161 Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator); 1162 1163 if (Param && 1164 // A missing identifier has already been diagnosed. 1165 ParmDeclarator.getIdentifier()) { 1166 1167 // Scan the argument list looking for the correct param to apply this 1168 // type. 1169 for (unsigned i = 0; ; ++i) { 1170 // C99 6.9.1p6: those declarators shall declare only identifiers from 1171 // the identifier list. 1172 if (i == FTI.NumParams) { 1173 Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param) 1174 << ParmDeclarator.getIdentifier(); 1175 break; 1176 } 1177 1178 if (FTI.Params[i].Ident == ParmDeclarator.getIdentifier()) { 1179 // Reject redefinitions of parameters. 1180 if (FTI.Params[i].Param) { 1181 Diag(ParmDeclarator.getIdentifierLoc(), 1182 diag::err_param_redefinition) 1183 << ParmDeclarator.getIdentifier(); 1184 } else { 1185 FTI.Params[i].Param = Param; 1186 } 1187 break; 1188 } 1189 } 1190 } 1191 1192 // If we don't have a comma, it is either the end of the list (a ';') or 1193 // an error, bail out. 1194 if (Tok.isNot(tok::comma)) 1195 break; 1196 1197 ParmDeclarator.clear(); 1198 1199 // Consume the comma. 1200 ParmDeclarator.setCommaLoc(ConsumeToken()); 1201 1202 // Parse the next declarator. 1203 ParseDeclarator(ParmDeclarator); 1204 } 1205 1206 // Consume ';' and continue parsing. 1207 if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration)) 1208 continue; 1209 1210 // Otherwise recover by skipping to next semi or mandatory function body. 1211 if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch)) 1212 break; 1213 TryConsumeToken(tok::semi); 1214 } 1215 1216 // The actions module must verify that all arguments were declared. 1217 Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation()); 1218} 1219 1220 1221/// ParseAsmStringLiteral - This is just a normal string-literal, but is not 1222/// allowed to be a wide string, and is not subject to character translation. 1223/// 1224/// [GNU] asm-string-literal: 1225/// string-literal 1226/// 1227ExprResult Parser::ParseAsmStringLiteral() { 1228 if (!isTokenStringLiteral()) { 1229 Diag(Tok, diag::err_expected_string_literal) 1230 << /*Source='in...'*/0 << "'asm'"; 1231 return ExprError(); 1232 } 1233 1234 ExprResult AsmString(ParseStringLiteralExpression()); 1235 if (!AsmString.isInvalid()) { 1236 const auto *SL = cast<StringLiteral>(AsmString.get()); 1237 if (!SL->isAscii()) { 1238 Diag(Tok, diag::err_asm_operand_wide_string_literal) 1239 << SL->isWide() 1240 << SL->getSourceRange(); 1241 return ExprError(); 1242 } 1243 } 1244 return AsmString; 1245} 1246 1247/// ParseSimpleAsm 1248/// 1249/// [GNU] simple-asm-expr: 1250/// 'asm' '(' asm-string-literal ')' 1251/// 1252ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { 1253 assert(Tok.is(tok::kw_asm) && "Not an asm!"); 1254 SourceLocation Loc = ConsumeToken(); 1255 1256 if (Tok.is(tok::kw_volatile)) { 1257 // Remove from the end of 'asm' to the end of 'volatile'. 1258 SourceRange RemovalRange(PP.getLocForEndOfToken(Loc), 1259 PP.getLocForEndOfToken(Tok.getLocation())); 1260 1261 Diag(Tok, diag::warn_file_asm_volatile) 1262 << FixItHint::CreateRemoval(RemovalRange); 1263 ConsumeToken(); 1264 } 1265 1266 BalancedDelimiterTracker T(*this, tok::l_paren); 1267 if (T.consumeOpen()) { 1268 Diag(Tok, diag::err_expected_lparen_after) << "asm"; 1269 return ExprError(); 1270 } 1271 1272 ExprResult Result(ParseAsmStringLiteral()); 1273 1274 if (!Result.isInvalid()) { 1275 // Close the paren and get the location of the end bracket 1276 T.consumeClose(); 1277 if (EndLoc) 1278 *EndLoc = T.getCloseLocation(); 1279 } else if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) { 1280 if (EndLoc) 1281 *EndLoc = Tok.getLocation(); 1282 ConsumeParen(); 1283 } 1284 1285 return Result; 1286} 1287 1288/// \brief Get the TemplateIdAnnotation from the token and put it in the 1289/// cleanup pool so that it gets destroyed when parsing the current top level 1290/// declaration is finished. 1291TemplateIdAnnotation *Parser::takeTemplateIdAnnotation(const Token &tok) { 1292 assert(tok.is(tok::annot_template_id) && "Expected template-id token"); 1293 TemplateIdAnnotation * 1294 Id = static_cast<TemplateIdAnnotation *>(tok.getAnnotationValue()); 1295 return Id; 1296} 1297 1298void Parser::AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation) { 1299 // Push the current token back into the token stream (or revert it if it is 1300 // cached) and use an annotation scope token for current token. 1301 if (PP.isBacktrackEnabled()) 1302 PP.RevertCachedTokens(1); 1303 else 1304 PP.EnterToken(Tok); 1305 Tok.setKind(tok::annot_cxxscope); 1306 Tok.setAnnotationValue(Actions.SaveNestedNameSpecifierAnnotation(SS)); 1307 Tok.setAnnotationRange(SS.getRange()); 1308 1309 // In case the tokens were cached, have Preprocessor replace them 1310 // with the annotation token. We don't need to do this if we've 1311 // just reverted back to a prior state. 1312 if (IsNewAnnotation) 1313 PP.AnnotateCachedTokens(Tok); 1314} 1315 1316/// \brief Attempt to classify the name at the current token position. This may 1317/// form a type, scope or primary expression annotation, or replace the token 1318/// with a typo-corrected keyword. This is only appropriate when the current 1319/// name must refer to an entity which has already been declared. 1320/// 1321/// \param IsAddressOfOperand Must be \c true if the name is preceded by an '&' 1322/// and might possibly have a dependent nested name specifier. 1323/// \param CCC Indicates how to perform typo-correction for this name. If NULL, 1324/// no typo correction will be performed. 1325Parser::AnnotatedNameKind 1326Parser::TryAnnotateName(bool IsAddressOfOperand, 1327 std::unique_ptr<CorrectionCandidateCallback> CCC) { 1328 assert(Tok.is(tok::identifier) || Tok.is(tok::annot_cxxscope)); 1329 1330 const bool EnteringContext = false; 1331 const bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); 1332 1333 CXXScopeSpec SS; 1334 if (getLangOpts().CPlusPlus && 1335 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) 1336 return ANK_Error; 1337 1338 if (Tok.isNot(tok::identifier) || SS.isInvalid()) { 1339 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, 1340 !WasScopeAnnotation)) 1341 return ANK_Error; 1342 return ANK_Unresolved; 1343 } 1344 1345 IdentifierInfo *Name = Tok.getIdentifierInfo(); 1346 SourceLocation NameLoc = Tok.getLocation(); 1347 1348 // FIXME: Move the tentative declaration logic into ClassifyName so we can 1349 // typo-correct to tentatively-declared identifiers. 1350 if (isTentativelyDeclared(Name)) { 1351 // Identifier has been tentatively declared, and thus cannot be resolved as 1352 // an expression. Fall back to annotating it as a type. 1353 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, 1354 !WasScopeAnnotation)) 1355 return ANK_Error; 1356 return Tok.is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl; 1357 } 1358 1359 Token Next = NextToken(); 1360 1361 // Look up and classify the identifier. We don't perform any typo-correction 1362 // after a scope specifier, because in general we can't recover from typos 1363 // there (eg, after correcting 'A::tempalte B<X>::C' [sic], we would need to 1364 // jump back into scope specifier parsing). 1365 Sema::NameClassification Classification = Actions.ClassifyName( 1366 getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, 1367 SS.isEmpty() ? std::move(CCC) : nullptr); 1368 1369 switch (Classification.getKind()) { 1370 case Sema::NC_Error: 1371 return ANK_Error; 1372 1373 case Sema::NC_Keyword: 1374 // The identifier was typo-corrected to a keyword. 1375 Tok.setIdentifierInfo(Name); 1376 Tok.setKind(Name->getTokenID()); 1377 PP.TypoCorrectToken(Tok); 1378 if (SS.isNotEmpty()) 1379 AnnotateScopeToken(SS, !WasScopeAnnotation); 1380 // We've "annotated" this as a keyword. 1381 return ANK_Success; 1382 1383 case Sema::NC_Unknown: 1384 // It's not something we know about. Leave it unannotated. 1385 break; 1386 1387 case Sema::NC_Type: 1388 Tok.setKind(tok::annot_typename); 1389 setTypeAnnotation(Tok, Classification.getType()); 1390 Tok.setAnnotationEndLoc(NameLoc); 1391 if (SS.isNotEmpty()) 1392 Tok.setLocation(SS.getBeginLoc()); 1393 PP.AnnotateCachedTokens(Tok); 1394 return ANK_Success; 1395 1396 case Sema::NC_Expression: 1397 Tok.setKind(tok::annot_primary_expr); 1398 setExprAnnotation(Tok, Classification.getExpression()); 1399 Tok.setAnnotationEndLoc(NameLoc); 1400 if (SS.isNotEmpty()) 1401 Tok.setLocation(SS.getBeginLoc()); 1402 PP.AnnotateCachedTokens(Tok); 1403 return ANK_Success; 1404 1405 case Sema::NC_TypeTemplate: 1406 if (Next.isNot(tok::less)) { 1407 // This may be a type template being used as a template template argument. 1408 if (SS.isNotEmpty()) 1409 AnnotateScopeToken(SS, !WasScopeAnnotation); 1410 return ANK_TemplateName; 1411 } 1412 // Fall through. 1413 case Sema::NC_VarTemplate: 1414 case Sema::NC_FunctionTemplate: { 1415 // We have a type, variable or function template followed by '<'. 1416 ConsumeToken(); 1417 UnqualifiedId Id; 1418 Id.setIdentifier(Name, NameLoc); 1419 if (AnnotateTemplateIdToken( 1420 TemplateTy::make(Classification.getTemplateName()), 1421 Classification.getTemplateNameKind(), SS, SourceLocation(), Id)) 1422 return ANK_Error; 1423 return ANK_Success; 1424 } 1425 1426 case Sema::NC_NestedNameSpecifier: 1427 llvm_unreachable("already parsed nested name specifier"); 1428 } 1429 1430 // Unable to classify the name, but maybe we can annotate a scope specifier. 1431 if (SS.isNotEmpty()) 1432 AnnotateScopeToken(SS, !WasScopeAnnotation); 1433 return ANK_Unresolved; 1434} 1435 1436bool Parser::TryKeywordIdentFallback(bool DisableKeyword) { 1437 assert(Tok.isNot(tok::identifier)); 1438 Diag(Tok, diag::ext_keyword_as_ident) 1439 << PP.getSpelling(Tok) 1440 << DisableKeyword; 1441 if (DisableKeyword) 1442 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier(); 1443 Tok.setKind(tok::identifier); 1444 return true; 1445} 1446 1447/// TryAnnotateTypeOrScopeToken - If the current token position is on a 1448/// typename (possibly qualified in C++) or a C++ scope specifier not followed 1449/// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens 1450/// with a single annotation token representing the typename or C++ scope 1451/// respectively. 1452/// This simplifies handling of C++ scope specifiers and allows efficient 1453/// backtracking without the need to re-parse and resolve nested-names and 1454/// typenames. 1455/// It will mainly be called when we expect to treat identifiers as typenames 1456/// (if they are typenames). For example, in C we do not expect identifiers 1457/// inside expressions to be treated as typenames so it will not be called 1458/// for expressions in C. 1459/// The benefit for C/ObjC is that a typename will be annotated and 1460/// Actions.getTypeName will not be needed to be called again (e.g. getTypeName 1461/// will not be called twice, once to check whether we have a declaration 1462/// specifier, and another one to get the actual type inside 1463/// ParseDeclarationSpecifiers). 1464/// 1465/// This returns true if an error occurred. 1466/// 1467/// Note that this routine emits an error if you call it with ::new or ::delete 1468/// as the current tokens, so only call it in contexts where these are invalid. 1469bool Parser::TryAnnotateTypeOrScopeToken(bool EnteringContext, bool NeedType) { 1470 assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || 1471 Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || 1472 Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) || 1473 Tok.is(tok::kw___super)) && 1474 "Cannot be a type or scope token!"); 1475 1476 if (Tok.is(tok::kw_typename)) { 1477 // MSVC lets you do stuff like: 1478 // typename typedef T_::D D; 1479 // 1480 // We will consume the typedef token here and put it back after we have 1481 // parsed the first identifier, transforming it into something more like: 1482 // typename T_::D typedef D; 1483 if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) { 1484 Token TypedefToken; 1485 PP.Lex(TypedefToken); 1486 bool Result = TryAnnotateTypeOrScopeToken(EnteringContext, NeedType); 1487 PP.EnterToken(Tok); 1488 Tok = TypedefToken; 1489 if (!Result) 1490 Diag(Tok.getLocation(), diag::warn_expected_qualified_after_typename); 1491 return Result; 1492 } 1493 1494 // Parse a C++ typename-specifier, e.g., "typename T::type". 1495 // 1496 // typename-specifier: 1497 // 'typename' '::' [opt] nested-name-specifier identifier 1498 // 'typename' '::' [opt] nested-name-specifier template [opt] 1499 // simple-template-id 1500 SourceLocation TypenameLoc = ConsumeToken(); 1501 CXXScopeSpec SS; 1502 if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/ParsedType(), 1503 /*EnteringContext=*/false, 1504 nullptr, /*IsTypename*/ true)) 1505 return true; 1506 if (!SS.isSet()) { 1507 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id) || 1508 Tok.is(tok::annot_decltype)) { 1509 // Attempt to recover by skipping the invalid 'typename' 1510 if (Tok.is(tok::annot_decltype) || 1511 (!TryAnnotateTypeOrScopeToken(EnteringContext, NeedType) && 1512 Tok.isAnnotation())) { 1513 unsigned DiagID = diag::err_expected_qualified_after_typename; 1514 // MS compatibility: MSVC permits using known types with typename. 1515 // e.g. "typedef typename T* pointer_type" 1516 if (getLangOpts().MicrosoftExt) 1517 DiagID = diag::warn_expected_qualified_after_typename; 1518 Diag(Tok.getLocation(), DiagID); 1519 return false; 1520 } 1521 } 1522 1523 Diag(Tok.getLocation(), diag::err_expected_qualified_after_typename); 1524 return true; 1525 } 1526 1527 TypeResult Ty; 1528 if (Tok.is(tok::identifier)) { 1529 // FIXME: check whether the next token is '<', first! 1530 Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, 1531 *Tok.getIdentifierInfo(), 1532 Tok.getLocation()); 1533 } else if (Tok.is(tok::annot_template_id)) { 1534 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 1535 if (TemplateId->Kind != TNK_Type_template && 1536 TemplateId->Kind != TNK_Dependent_template_name) { 1537 Diag(Tok, diag::err_typename_refers_to_non_type_template) 1538 << Tok.getAnnotationRange(); 1539 return true; 1540 } 1541 1542 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 1543 TemplateId->NumArgs); 1544 1545 Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, 1546 TemplateId->TemplateKWLoc, 1547 TemplateId->Template, 1548 TemplateId->TemplateNameLoc, 1549 TemplateId->LAngleLoc, 1550 TemplateArgsPtr, 1551 TemplateId->RAngleLoc); 1552 } else { 1553 Diag(Tok, diag::err_expected_type_name_after_typename) 1554 << SS.getRange(); 1555 return true; 1556 } 1557 1558 SourceLocation EndLoc = Tok.getLastLoc(); 1559 Tok.setKind(tok::annot_typename); 1560 setTypeAnnotation(Tok, Ty.isInvalid() ? ParsedType() : Ty.get()); 1561 Tok.setAnnotationEndLoc(EndLoc); 1562 Tok.setLocation(TypenameLoc); 1563 PP.AnnotateCachedTokens(Tok); 1564 return false; 1565 } 1566 1567 // Remembers whether the token was originally a scope annotation. 1568 bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); 1569 1570 CXXScopeSpec SS; 1571 if (getLangOpts().CPlusPlus) 1572 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) 1573 return true; 1574 1575 return TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, NeedType, 1576 SS, !WasScopeAnnotation); 1577} 1578 1579/// \brief Try to annotate a type or scope token, having already parsed an 1580/// optional scope specifier. \p IsNewScope should be \c true unless the scope 1581/// specifier was extracted from an existing tok::annot_cxxscope annotation. 1582bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(bool EnteringContext, 1583 bool NeedType, 1584 CXXScopeSpec &SS, 1585 bool IsNewScope) { 1586 if (Tok.is(tok::identifier)) { 1587 IdentifierInfo *CorrectedII = nullptr; 1588 // Determine whether the identifier is a type name. 1589 if (ParsedType Ty = Actions.getTypeName(*Tok.getIdentifierInfo(), 1590 Tok.getLocation(), getCurScope(), 1591 &SS, false, 1592 NextToken().is(tok::period), 1593 ParsedType(), 1594 /*IsCtorOrDtorName=*/false, 1595 /*NonTrivialTypeSourceInfo*/ true, 1596 NeedType ? &CorrectedII 1597 : nullptr)) { 1598 // A FixIt was applied as a result of typo correction 1599 if (CorrectedII) 1600 Tok.setIdentifierInfo(CorrectedII); 1601 // This is a typename. Replace the current token in-place with an 1602 // annotation type token. 1603 Tok.setKind(tok::annot_typename); 1604 setTypeAnnotation(Tok, Ty); 1605 Tok.setAnnotationEndLoc(Tok.getLocation()); 1606 if (SS.isNotEmpty()) // it was a C++ qualified type name. 1607 Tok.setLocation(SS.getBeginLoc()); 1608 1609 // In case the tokens were cached, have Preprocessor replace 1610 // them with the annotation token. 1611 PP.AnnotateCachedTokens(Tok); 1612 return false; 1613 } 1614 1615 if (!getLangOpts().CPlusPlus) { 1616 // If we're in C, we can't have :: tokens at all (the lexer won't return 1617 // them). If the identifier is not a type, then it can't be scope either, 1618 // just early exit. 1619 return false; 1620 } 1621 1622 // If this is a template-id, annotate with a template-id or type token. 1623 if (NextToken().is(tok::less)) { 1624 TemplateTy Template; 1625 UnqualifiedId TemplateName; 1626 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 1627 bool MemberOfUnknownSpecialization; 1628 if (TemplateNameKind TNK 1629 = Actions.isTemplateName(getCurScope(), SS, 1630 /*hasTemplateKeyword=*/false, TemplateName, 1631 /*ObjectType=*/ ParsedType(), 1632 EnteringContext, 1633 Template, MemberOfUnknownSpecialization)) { 1634 // Consume the identifier. 1635 ConsumeToken(); 1636 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), 1637 TemplateName)) { 1638 // If an unrecoverable error occurred, we need to return true here, 1639 // because the token stream is in a damaged state. We may not return 1640 // a valid identifier. 1641 return true; 1642 } 1643 } 1644 } 1645 1646 // The current token, which is either an identifier or a 1647 // template-id, is not part of the annotation. Fall through to 1648 // push that token back into the stream and complete the C++ scope 1649 // specifier annotation. 1650 } 1651 1652 if (Tok.is(tok::annot_template_id)) { 1653 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 1654 if (TemplateId->Kind == TNK_Type_template) { 1655 // A template-id that refers to a type was parsed into a 1656 // template-id annotation in a context where we weren't allowed 1657 // to produce a type annotation token. Update the template-id 1658 // annotation token to a type annotation token now. 1659 AnnotateTemplateIdTokenAsType(); 1660 return false; 1661 } 1662 } 1663 1664 if (SS.isEmpty()) 1665 return false; 1666 1667 // A C++ scope specifier that isn't followed by a typename. 1668 AnnotateScopeToken(SS, IsNewScope); 1669 return false; 1670} 1671 1672/// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only 1673/// annotates C++ scope specifiers and template-ids. This returns 1674/// true if there was an error that could not be recovered from. 1675/// 1676/// Note that this routine emits an error if you call it with ::new or ::delete 1677/// as the current tokens, so only call it in contexts where these are invalid. 1678bool Parser::TryAnnotateCXXScopeToken(bool EnteringContext) { 1679 assert(getLangOpts().CPlusPlus && 1680 "Call sites of this function should be guarded by checking for C++"); 1681 assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || 1682 (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) || 1683 Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super)) && 1684 "Cannot be a type or scope token!"); 1685 1686 CXXScopeSpec SS; 1687 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) 1688 return true; 1689 if (SS.isEmpty()) 1690 return false; 1691 1692 AnnotateScopeToken(SS, true); 1693 return false; 1694} 1695 1696bool Parser::isTokenEqualOrEqualTypo() { 1697 tok::TokenKind Kind = Tok.getKind(); 1698 switch (Kind) { 1699 default: 1700 return false; 1701 case tok::ampequal: // &= 1702 case tok::starequal: // *= 1703 case tok::plusequal: // += 1704 case tok::minusequal: // -= 1705 case tok::exclaimequal: // != 1706 case tok::slashequal: // /= 1707 case tok::percentequal: // %= 1708 case tok::lessequal: // <= 1709 case tok::lesslessequal: // <<= 1710 case tok::greaterequal: // >= 1711 case tok::greatergreaterequal: // >>= 1712 case tok::caretequal: // ^= 1713 case tok::pipeequal: // |= 1714 case tok::equalequal: // == 1715 Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal) 1716 << Kind 1717 << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "="); 1718 case tok::equal: 1719 return true; 1720 } 1721} 1722 1723SourceLocation Parser::handleUnexpectedCodeCompletionToken() { 1724 assert(Tok.is(tok::code_completion)); 1725 PrevTokLocation = Tok.getLocation(); 1726 1727 for (Scope *S = getCurScope(); S; S = S->getParent()) { 1728 if (S->getFlags() & Scope::FnScope) { 1729 Actions.CodeCompleteOrdinaryName(getCurScope(), 1730 Sema::PCC_RecoveryInFunction); 1731 cutOffParsing(); 1732 return PrevTokLocation; 1733 } 1734 1735 if (S->getFlags() & Scope::ClassScope) { 1736 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class); 1737 cutOffParsing(); 1738 return PrevTokLocation; 1739 } 1740 } 1741 1742 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace); 1743 cutOffParsing(); 1744 return PrevTokLocation; 1745} 1746 1747// Code-completion pass-through functions 1748 1749void Parser::CodeCompleteDirective(bool InConditional) { 1750 Actions.CodeCompletePreprocessorDirective(InConditional); 1751} 1752 1753void Parser::CodeCompleteInConditionalExclusion() { 1754 Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope()); 1755} 1756 1757void Parser::CodeCompleteMacroName(bool IsDefinition) { 1758 Actions.CodeCompletePreprocessorMacroName(IsDefinition); 1759} 1760 1761void Parser::CodeCompletePreprocessorExpression() { 1762 Actions.CodeCompletePreprocessorExpression(); 1763} 1764 1765void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro, 1766 MacroInfo *MacroInfo, 1767 unsigned ArgumentIndex) { 1768 Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, 1769 ArgumentIndex); 1770} 1771 1772void Parser::CodeCompleteNaturalLanguage() { 1773 Actions.CodeCompleteNaturalLanguage(); 1774} 1775 1776bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition& Result) { 1777 assert((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists)) && 1778 "Expected '__if_exists' or '__if_not_exists'"); 1779 Result.IsIfExists = Tok.is(tok::kw___if_exists); 1780 Result.KeywordLoc = ConsumeToken(); 1781 1782 BalancedDelimiterTracker T(*this, tok::l_paren); 1783 if (T.consumeOpen()) { 1784 Diag(Tok, diag::err_expected_lparen_after) 1785 << (Result.IsIfExists? "__if_exists" : "__if_not_exists"); 1786 return true; 1787 } 1788 1789 // Parse nested-name-specifier. 1790 if (getLangOpts().CPlusPlus) 1791 ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), 1792 /*EnteringContext=*/false); 1793 1794 // Check nested-name specifier. 1795 if (Result.SS.isInvalid()) { 1796 T.skipToEnd(); 1797 return true; 1798 } 1799 1800 // Parse the unqualified-id. 1801 SourceLocation TemplateKWLoc; // FIXME: parsed, but unused. 1802 if (ParseUnqualifiedId(Result.SS, false, true, true, ParsedType(), 1803 TemplateKWLoc, Result.Name)) { 1804 T.skipToEnd(); 1805 return true; 1806 } 1807 1808 if (T.consumeClose()) 1809 return true; 1810 1811 // Check if the symbol exists. 1812 switch (Actions.CheckMicrosoftIfExistsSymbol(getCurScope(), Result.KeywordLoc, 1813 Result.IsIfExists, Result.SS, 1814 Result.Name)) { 1815 case Sema::IER_Exists: 1816 Result.Behavior = Result.IsIfExists ? IEB_Parse : IEB_Skip; 1817 break; 1818 1819 case Sema::IER_DoesNotExist: 1820 Result.Behavior = !Result.IsIfExists ? IEB_Parse : IEB_Skip; 1821 break; 1822 1823 case Sema::IER_Dependent: 1824 Result.Behavior = IEB_Dependent; 1825 break; 1826 1827 case Sema::IER_Error: 1828 return true; 1829 } 1830 1831 return false; 1832} 1833 1834void Parser::ParseMicrosoftIfExistsExternalDeclaration() { 1835 IfExistsCondition Result; 1836 if (ParseMicrosoftIfExistsCondition(Result)) 1837 return; 1838 1839 BalancedDelimiterTracker Braces(*this, tok::l_brace); 1840 if (Braces.consumeOpen()) { 1841 Diag(Tok, diag::err_expected) << tok::l_brace; 1842 return; 1843 } 1844 1845 switch (Result.Behavior) { 1846 case IEB_Parse: 1847 // Parse declarations below. 1848 break; 1849 1850 case IEB_Dependent: 1851 llvm_unreachable("Cannot have a dependent external declaration"); 1852 1853 case IEB_Skip: 1854 Braces.skipToEnd(); 1855 return; 1856 } 1857 1858 // Parse the declarations. 1859 // FIXME: Support module import within __if_exists? 1860 while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { 1861 ParsedAttributesWithRange attrs(AttrFactory); 1862 MaybeParseCXX11Attributes(attrs); 1863 MaybeParseMicrosoftAttributes(attrs); 1864 DeclGroupPtrTy Result = ParseExternalDeclaration(attrs); 1865 if (Result && !getCurScope()->getParent()) 1866 Actions.getASTConsumer().HandleTopLevelDecl(Result.get()); 1867 } 1868 Braces.consumeClose(); 1869} 1870 1871Parser::DeclGroupPtrTy Parser::ParseModuleImport(SourceLocation AtLoc) { 1872 assert(Tok.isObjCAtKeyword(tok::objc_import) && 1873 "Improper start to module import"); 1874 SourceLocation ImportLoc = ConsumeToken(); 1875 1876 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path; 1877 1878 // Parse the module path. 1879 do { 1880 if (!Tok.is(tok::identifier)) { 1881 if (Tok.is(tok::code_completion)) { 1882 Actions.CodeCompleteModuleImport(ImportLoc, Path); 1883 cutOffParsing(); 1884 return DeclGroupPtrTy(); 1885 } 1886 1887 Diag(Tok, diag::err_module_expected_ident); 1888 SkipUntil(tok::semi); 1889 return DeclGroupPtrTy(); 1890 } 1891 1892 // Record this part of the module path. 1893 Path.push_back(std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation())); 1894 ConsumeToken(); 1895 1896 if (Tok.is(tok::period)) { 1897 ConsumeToken(); 1898 continue; 1899 } 1900 1901 break; 1902 } while (true); 1903 1904 if (PP.hadModuleLoaderFatalFailure()) { 1905 // With a fatal failure in the module loader, we abort parsing. 1906 cutOffParsing(); 1907 return DeclGroupPtrTy(); 1908 } 1909 1910 DeclResult Import = Actions.ActOnModuleImport(AtLoc, ImportLoc, Path); 1911 ExpectAndConsumeSemi(diag::err_module_expected_semi); 1912 if (Import.isInvalid()) 1913 return DeclGroupPtrTy(); 1914 1915 return Actions.ConvertDeclToDeclGroup(Import.get()); 1916} 1917 1918bool BalancedDelimiterTracker::diagnoseOverflow() { 1919 P.Diag(P.Tok, diag::err_bracket_depth_exceeded) 1920 << P.getLangOpts().BracketDepth; 1921 P.Diag(P.Tok, diag::note_bracket_depth); 1922 P.cutOffParsing(); 1923 return true; 1924} 1925 1926bool BalancedDelimiterTracker::expectAndConsume(unsigned DiagID, 1927 const char *Msg, 1928 tok::TokenKind SkipToTok) { 1929 LOpen = P.Tok.getLocation(); 1930 if (P.ExpectAndConsume(Kind, DiagID, Msg)) { 1931 if (SkipToTok != tok::unknown) 1932 P.SkipUntil(SkipToTok, Parser::StopAtSemi); 1933 return true; 1934 } 1935 1936 if (getDepth() < MaxDepth) 1937 return false; 1938 1939 return diagnoseOverflow(); 1940} 1941 1942bool BalancedDelimiterTracker::diagnoseMissingClose() { 1943 assert(!P.Tok.is(Close) && "Should have consumed closing delimiter"); 1944 1945 P.Diag(P.Tok, diag::err_expected) << Close; 1946 P.Diag(LOpen, diag::note_matching) << Kind; 1947 1948 // If we're not already at some kind of closing bracket, skip to our closing 1949 // token. 1950 if (P.Tok.isNot(tok::r_paren) && P.Tok.isNot(tok::r_brace) && 1951 P.Tok.isNot(tok::r_square) && 1952 P.SkipUntil(Close, FinalToken, 1953 Parser::StopAtSemi | Parser::StopBeforeMatch) && 1954 P.Tok.is(Close)) 1955 LClose = P.ConsumeAnyToken(); 1956 return true; 1957} 1958 1959void BalancedDelimiterTracker::skipToEnd() { 1960 P.SkipUntil(Close, Parser::StopBeforeMatch); 1961 consumeClose(); 1962} 1963