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