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