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