head 1.1; branch 1.1.1; access; symbols netbsd-10-2-RELEASE:1.1.1.15 netbsd-9-5-RELEASE:1.1.1.14 netbsd-11-0-RELEASE:1.1.1.15 netbsd-11-0-RC7:1.1.1.15 netbsd-11-0-RC6:1.1.1.15 netbsd-11-0-RC5:1.1.1.15 netbsd-11-0-RC4:1.1.1.15 netbsd-11-0-RC3:1.1.1.15 netbsd-11-0-RC2:1.1.1.15 netbsd-11-0-RC1:1.1.1.15 perseant-exfatfs-base-20250801:1.1.1.15 netbsd-11:1.1.1.15.0.10 netbsd-11-base:1.1.1.15 netbsd-10-1-RELEASE:1.1.1.15 perseant-exfatfs-base-20240630:1.1.1.15 perseant-exfatfs:1.1.1.15.0.8 perseant-exfatfs-base:1.1.1.15 netbsd-8-3-RELEASE:1.1.1.11 netbsd-9-4-RELEASE:1.1.1.14 netbsd-10-0-RELEASE:1.1.1.15 netbsd-10-0-RC6:1.1.1.15 netbsd-10-0-RC5:1.1.1.15 netbsd-10-0-RC4:1.1.1.15 netbsd-10-0-RC3:1.1.1.15 netbsd-10-0-RC2:1.1.1.15 netbsd-10-0-RC1:1.1.1.15 netbsd-10:1.1.1.15.0.6 netbsd-10-base:1.1.1.15 netbsd-9-3-RELEASE:1.1.1.14 cjep_sun2x:1.1.1.15.0.4 cjep_sun2x-base:1.1.1.15 cjep_staticlib_x-base1:1.1.1.15 netbsd-9-2-RELEASE:1.1.1.14 cjep_staticlib_x:1.1.1.15.0.2 cjep_staticlib_x-base:1.1.1.15 netbsd-9-1-RELEASE:1.1.1.14 phil-wifi-20200421:1.1.1.15 phil-wifi-20200411:1.1.1.15 phil-wifi-20200406:1.1.1.15 netbsd-8-2-RELEASE:1.1.1.11 netbsd-9-0-RELEASE:1.1.1.14 netbsd-9-0-RC2:1.1.1.14 netbsd-9-0-RC1:1.1.1.14 netbsd-9:1.1.1.14.0.2 netbsd-9-base:1.1.1.14 phil-wifi-20190609:1.1.1.14 netbsd-8-1-RELEASE:1.1.1.11 netbsd-8-1-RC1:1.1.1.11 pgoyette-compat-merge-20190127:1.1.1.13.2.1 pgoyette-compat-20190127:1.1.1.14 pgoyette-compat-20190118:1.1.1.14 pgoyette-compat-1226:1.1.1.14 pgoyette-compat-1126:1.1.1.14 pgoyette-compat-1020:1.1.1.14 pgoyette-compat-0930:1.1.1.14 pgoyette-compat-0906:1.1.1.14 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.14 clang-337282:1.1.1.14 netbsd-8-0-RELEASE:1.1.1.11 phil-wifi:1.1.1.13.0.4 phil-wifi-base:1.1.1.13 pgoyette-compat-0625:1.1.1.13 netbsd-8-0-RC2:1.1.1.11 pgoyette-compat-0521:1.1.1.13 pgoyette-compat-0502:1.1.1.13 pgoyette-compat-0422:1.1.1.13 netbsd-8-0-RC1:1.1.1.11 pgoyette-compat-0415:1.1.1.13 pgoyette-compat-0407:1.1.1.13 pgoyette-compat-0330:1.1.1.13 pgoyette-compat-0322:1.1.1.13 pgoyette-compat-0315:1.1.1.13 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.13.0.2 pgoyette-compat-base:1.1.1.13 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.13 matt-nb8-mediatek:1.1.1.11.0.8 matt-nb8-mediatek-base:1.1.1.11 clang-309604:1.1.1.12 perseant-stdc-iso10646:1.1.1.11.0.6 perseant-stdc-iso10646-base:1.1.1.11 netbsd-8:1.1.1.11.0.4 netbsd-8-base:1.1.1.11 prg-localcount2-base3:1.1.1.11 prg-localcount2-base2:1.1.1.11 prg-localcount2-base1:1.1.1.11 prg-localcount2:1.1.1.11.0.2 prg-localcount2-base:1.1.1.11 pgoyette-localcount-20170426:1.1.1.11 bouyer-socketcan-base1:1.1.1.11 pgoyette-localcount-20170320:1.1.1.11 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.11 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.21; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.18; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.04; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.29; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.42; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.25; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.48; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.33.43; author joerg; state Exp; branches 1.1.1.10.2.1; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.02.09.17.38.06; author joerg; state Exp; branches; next 1.1.1.12; commitid UxB8JMFWM7xyMiFz; 1.1.1.12 date 2017.08.01.19.34.58; author joerg; state Exp; branches; next 1.1.1.13; commitid pMuDy65V0VicSx1A; 1.1.1.13 date 2017.12.17.20.58.54; author joerg; state Exp; branches 1.1.1.13.2.1 1.1.1.13.4.1; next 1.1.1.14; commitid T7p9sjiUJyY1UhjA; 1.1.1.14 date 2018.07.17.18.30.57; author joerg; state Exp; branches; next 1.1.1.15; commitid wDzL46ALjrCZgwKA; 1.1.1.15 date 2019.11.13.22.19.26; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.09; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.29; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.18.29; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.25; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.47.29; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.52.40; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2017.04.21.16.51.39; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.13.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.13.4.1 date 2019.06.10.21.45.26; author christos; state Exp; branches; next 1.1.1.13.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.13.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- Parser.cpp - C Language Family Parser ----------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the Parser interfaces. // //===----------------------------------------------------------------------===// #include "clang/Parse/Parser.h" #include "ParsePragma.h" #include "RAIIObjectsForParser.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/DeclTemplate.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "llvm/Support/raw_ostream.h" using namespace clang; namespace { /// \brief A comment handler that passes comments found by the preprocessor /// to the parser action. class ActionCommentHandler : public CommentHandler { Sema &S; public: explicit ActionCommentHandler(Sema &S) : S(S) { } virtual bool HandleComment(Preprocessor &PP, SourceRange Comment) { S.ActOnComment(Comment); return false; } }; } // end anonymous namespace IdentifierInfo *Parser::getSEHExceptKeyword() { // __except is accepted as a (contextual) keyword if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland)) Ident__except = PP.getIdentifierInfo("__except"); return Ident__except; } Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies) : PP(pp), Actions(actions), Diags(PP.getDiagnostics()), GreaterThanIsOperator(true), ColonIsSacred(false), InMessageExpression(false), TemplateParameterDepth(0), ParsingInObjCContainer(false) { SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies; Tok.startToken(); Tok.setKind(tok::eof); Actions.CurScope = 0; NumCachedScopes = 0; ParenCount = BracketCount = BraceCount = 0; CurParsedObjCImpl = 0; // Add #pragma handlers. These are removed and destroyed in the // destructor. AlignHandler.reset(new PragmaAlignHandler()); PP.AddPragmaHandler(AlignHandler.get()); GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); OptionsHandler.reset(new PragmaOptionsHandler()); PP.AddPragmaHandler(OptionsHandler.get()); PackHandler.reset(new PragmaPackHandler()); PP.AddPragmaHandler(PackHandler.get()); MSStructHandler.reset(new PragmaMSStructHandler()); PP.AddPragmaHandler(MSStructHandler.get()); UnusedHandler.reset(new PragmaUnusedHandler()); PP.AddPragmaHandler(UnusedHandler.get()); WeakHandler.reset(new PragmaWeakHandler()); PP.AddPragmaHandler(WeakHandler.get()); RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); PP.AddPragmaHandler(RedefineExtnameHandler.get()); FPContractHandler.reset(new PragmaFPContractHandler()); PP.AddPragmaHandler("STDC", FPContractHandler.get()); if (getLangOpts().OpenCL) { OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); } if (getLangOpts().OpenMP) OpenMPHandler.reset(new PragmaOpenMPHandler()); else OpenMPHandler.reset(new PragmaNoOpenMPHandler()); PP.AddPragmaHandler(OpenMPHandler.get()); if (getLangOpts().MicrosoftExt) { MSCommentHandler.reset(new PragmaCommentHandler(actions)); PP.AddPragmaHandler(MSCommentHandler.get()); MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(actions)); PP.AddPragmaHandler(MSDetectMismatchHandler.get()); } CommentSemaHandler.reset(new ActionCommentHandler(actions)); PP.addCommentHandler(CommentSemaHandler.get()); PP.setCodeCompletionHandler(*this); } DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) { return Diags.Report(Loc, DiagID); } DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) { return Diag(Tok.getLocation(), DiagID); } /// \brief Emits a diagnostic suggesting parentheses surrounding a /// given range. /// /// \param Loc The location where we'll emit the diagnostic. /// \param DK The kind of diagnostic to emit. /// \param ParenRange Source range enclosing code that should be parenthesized. void Parser::SuggestParentheses(SourceLocation Loc, unsigned DK, SourceRange ParenRange) { SourceLocation EndLoc = PP.getLocForEndOfToken(ParenRange.getEnd()); if (!ParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { // We can't display the parentheses, so just dig the // warning/error and return. Diag(Loc, DK); return; } Diag(Loc, DK) << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") << FixItHint::CreateInsertion(EndLoc, ")"); } static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok) { switch (ExpectedTok) { case tok::semi: return Tok.is(tok::colon) || Tok.is(tok::comma); // : or , for ; default: return false; } } /// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the /// input. If so, it is consumed and false is returned. /// /// If the input is malformed, this emits the specified diagnostic. Next, if /// SkipToTok is specified, it calls SkipUntil(SkipToTok). Finally, true is /// returned. bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID, const char *Msg, tok::TokenKind SkipToTok) { if (Tok.is(ExpectedTok) || Tok.is(tok::code_completion)) { ConsumeAnyToken(); return false; } // Detect common single-character typos and resume. if (IsCommonTypo(ExpectedTok, Tok)) { SourceLocation Loc = Tok.getLocation(); Diag(Loc, DiagID) << Msg << FixItHint::CreateReplacement(SourceRange(Loc), getTokenSimpleSpelling(ExpectedTok)); ConsumeAnyToken(); // Pretend there wasn't a problem. return false; } const char *Spelling = 0; SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); if (EndLoc.isValid() && (Spelling = tok::getTokenSimpleSpelling(ExpectedTok))) { // Show what code to insert to fix this problem. Diag(EndLoc, DiagID) << Msg << FixItHint::CreateInsertion(EndLoc, Spelling); } else Diag(Tok, DiagID) << Msg; if (SkipToTok != tok::unknown) SkipUntil(SkipToTok, StopAtSemi); return true; } bool Parser::ExpectAndConsumeSemi(unsigned DiagID) { if (Tok.is(tok::semi) || Tok.is(tok::code_completion)) { ConsumeToken(); return false; } if ((Tok.is(tok::r_paren) || Tok.is(tok::r_square)) && NextToken().is(tok::semi)) { Diag(Tok, diag::err_extraneous_token_before_semi) << PP.getSpelling(Tok) << FixItHint::CreateRemoval(Tok.getLocation()); ConsumeAnyToken(); // The ')' or ']'. ConsumeToken(); // The ';'. return false; } return ExpectAndConsume(tok::semi, DiagID); } void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST) { if (!Tok.is(tok::semi)) return; bool HadMultipleSemis = false; SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc = Tok.getLocation(); ConsumeToken(); while ((Tok.is(tok::semi) && !Tok.isAtStartOfLine())) { HadMultipleSemis = true; EndLoc = Tok.getLocation(); ConsumeToken(); } // C++11 allows extra semicolons at namespace scope, but not in any of the // other contexts. if (Kind == OutsideFunction && getLangOpts().CPlusPlus) { if (getLangOpts().CPlusPlus11) Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else Diag(StartLoc, diag::ext_extra_semi_cxx11) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); return; } if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis) Diag(StartLoc, diag::ext_extra_semi) << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else // A single semicolon is valid after a member function definition. Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); } //===----------------------------------------------------------------------===// // Error recovery. //===----------------------------------------------------------------------===// static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R) { return (static_cast(L) & static_cast(R)) != 0; } /// SkipUntil - Read tokens until we get to the specified token, then consume /// it (unless no flag StopBeforeMatch). Because we cannot guarantee that the /// token will ever occur, this skips to the next token, or to some likely /// good stopping point. If StopAtSemi is true, skipping will stop at a ';' /// character. /// /// If SkipUntil finds the specified token, it returns true, otherwise it /// returns false. bool Parser::SkipUntil(ArrayRef Toks, SkipUntilFlags Flags) { // We always want this function to skip at least one token if the first token // isn't T and if not at EOF. bool isFirstTokenSkipped = true; while (1) { // If we found one of the tokens, stop and return true. for (unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) { if (Tok.is(Toks[i])) { if (HasFlagsSet(Flags, StopBeforeMatch)) { // Noop, don't consume the token. } else { ConsumeAnyToken(); } return true; } } // Important special case: The caller has given up and just wants us to // skip the rest of the file. Do this without recursing, since we can // get here precisely because the caller detected too much recursion. if (Toks.size() == 1 && Toks[0] == tok::eof && !HasFlagsSet(Flags, StopAtSemi) && !HasFlagsSet(Flags, StopAtCodeCompletion)) { while (Tok.getKind() != tok::eof) ConsumeAnyToken(); return true; } switch (Tok.getKind()) { case tok::eof: // Ran out of tokens. return false; case tok::code_completion: if (!HasFlagsSet(Flags, StopAtCodeCompletion)) ConsumeToken(); return false; case tok::l_paren: // Recursively skip properly-nested parens. ConsumeParen(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_paren, StopAtCodeCompletion); else SkipUntil(tok::r_paren); break; case tok::l_square: // Recursively skip properly-nested square brackets. ConsumeBracket(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_square, StopAtCodeCompletion); else SkipUntil(tok::r_square); break; case tok::l_brace: // Recursively skip properly-nested braces. ConsumeBrace(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_brace, StopAtCodeCompletion); else SkipUntil(tok::r_brace); break; // Okay, we found a ']' or '}' or ')', which we think should be balanced. // Since the user wasn't looking for this token (if they were, it would // already be handled), this isn't balanced. If there is a LHS token at a // higher level, we will assume that this matches the unbalanced token // and return it. Otherwise, this is a spurious RHS token, which we skip. case tok::r_paren: if (ParenCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeParen(); break; case tok::r_square: if (BracketCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBracket(); break; case tok::r_brace: if (BraceCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBrace(); break; case tok::string_literal: case tok::wide_string_literal: case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: ConsumeStringToken(); break; case tok::semi: if (HasFlagsSet(Flags, StopAtSemi)) return false; // FALL THROUGH. default: // Skip this token. ConsumeToken(); break; } isFirstTokenSkipped = false; } } //===----------------------------------------------------------------------===// // Scope manipulation //===----------------------------------------------------------------------===// /// EnterScope - Start a new scope. void Parser::EnterScope(unsigned ScopeFlags) { if (NumCachedScopes) { Scope *N = ScopeCache[--NumCachedScopes]; N->Init(getCurScope(), ScopeFlags); Actions.CurScope = N; } else { Actions.CurScope = new Scope(getCurScope(), ScopeFlags, Diags); } } /// ExitScope - Pop a scope off the scope stack. void Parser::ExitScope() { assert(getCurScope() && "Scope imbalance!"); // Inform the actions module that this scope is going away if there are any // decls in it. if (!getCurScope()->decl_empty()) Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); Scope *OldScope = getCurScope(); Actions.CurScope = OldScope->getParent(); if (NumCachedScopes == ScopeCacheSize) delete OldScope; else ScopeCache[NumCachedScopes++] = OldScope; } /// Set the flags for the current scope to ScopeFlags. If ManageFlags is false, /// this object does nothing. Parser::ParseScopeFlags::ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags) : CurScope(ManageFlags ? Self->getCurScope() : 0) { if (CurScope) { OldFlags = CurScope->getFlags(); CurScope->setFlags(ScopeFlags); } } /// Restore the flags for the current scope to what they were before this /// object overrode them. Parser::ParseScopeFlags::~ParseScopeFlags() { if (CurScope) CurScope->setFlags(OldFlags); } //===----------------------------------------------------------------------===// // C99 6.9: External Definitions. //===----------------------------------------------------------------------===// Parser::~Parser() { // If we still have scopes active, delete the scope tree. delete getCurScope(); Actions.CurScope = 0; // Free the scope cache. for (unsigned i = 0, e = NumCachedScopes; i != e; ++i) delete ScopeCache[i]; // Remove the pragma handlers we installed. PP.RemovePragmaHandler(AlignHandler.get()); AlignHandler.reset(); PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); GCCVisibilityHandler.reset(); PP.RemovePragmaHandler(OptionsHandler.get()); OptionsHandler.reset(); PP.RemovePragmaHandler(PackHandler.get()); PackHandler.reset(); PP.RemovePragmaHandler(MSStructHandler.get()); MSStructHandler.reset(); PP.RemovePragmaHandler(UnusedHandler.get()); UnusedHandler.reset(); PP.RemovePragmaHandler(WeakHandler.get()); WeakHandler.reset(); PP.RemovePragmaHandler(RedefineExtnameHandler.get()); RedefineExtnameHandler.reset(); if (getLangOpts().OpenCL) { PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get()); OpenCLExtensionHandler.reset(); PP.RemovePragmaHandler("OPENCL", FPContractHandler.get()); } PP.RemovePragmaHandler(OpenMPHandler.get()); OpenMPHandler.reset(); if (getLangOpts().MicrosoftExt) { PP.RemovePragmaHandler(MSCommentHandler.get()); MSCommentHandler.reset(); PP.RemovePragmaHandler(MSDetectMismatchHandler.get()); MSDetectMismatchHandler.reset(); } PP.RemovePragmaHandler("STDC", FPContractHandler.get()); FPContractHandler.reset(); PP.removeCommentHandler(CommentSemaHandler.get()); PP.clearCodeCompletionHandler(); assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?"); } /// Initialize - Warm up the parser. /// void Parser::Initialize() { // Create the translation unit scope. Install it as the current scope. assert(getCurScope() == 0 && "A scope is already active?"); EnterScope(Scope::DeclScope); Actions.ActOnTranslationUnitScope(getCurScope()); // Initialization for Objective-C context sensitive keywords recognition. // Referenced in Parser::ParseObjCTypeQualifierList. if (getLangOpts().ObjC1) { ObjCTypeQuals[objc_in] = &PP.getIdentifierTable().get("in"); ObjCTypeQuals[objc_out] = &PP.getIdentifierTable().get("out"); ObjCTypeQuals[objc_inout] = &PP.getIdentifierTable().get("inout"); ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway"); ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy"); ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref"); } Ident_instancetype = 0; Ident_final = 0; Ident_sealed = 0; Ident_override = 0; Ident_super = &PP.getIdentifierTable().get("super"); if (getLangOpts().AltiVec) { Ident_vector = &PP.getIdentifierTable().get("vector"); Ident_pixel = &PP.getIdentifierTable().get("pixel"); Ident_bool = &PP.getIdentifierTable().get("bool"); } Ident_introduced = 0; Ident_deprecated = 0; Ident_obsoleted = 0; Ident_unavailable = 0; Ident__except = 0; Ident__exception_code = Ident__exception_info = Ident__abnormal_termination = 0; Ident___exception_code = Ident___exception_info = Ident___abnormal_termination = 0; Ident_GetExceptionCode = Ident_GetExceptionInfo = Ident_AbnormalTermination = 0; if(getLangOpts().Borland) { Ident__exception_info = PP.getIdentifierInfo("_exception_info"); Ident___exception_info = PP.getIdentifierInfo("__exception_info"); Ident_GetExceptionInfo = PP.getIdentifierInfo("GetExceptionInformation"); Ident__exception_code = PP.getIdentifierInfo("_exception_code"); Ident___exception_code = PP.getIdentifierInfo("__exception_code"); Ident_GetExceptionCode = PP.getIdentifierInfo("GetExceptionCode"); Ident__abnormal_termination = PP.getIdentifierInfo("_abnormal_termination"); Ident___abnormal_termination = PP.getIdentifierInfo("__abnormal_termination"); Ident_AbnormalTermination = PP.getIdentifierInfo("AbnormalTermination"); PP.SetPoisonReason(Ident__exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident___exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block); PP.SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter); PP.SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block); } Actions.Initialize(); // Prime the lexer look-ahead. ConsumeToken(); } namespace { /// \brief RAIIObject to destroy the contents of a SmallVector of /// TemplateIdAnnotation pointers and clear the vector. class DestroyTemplateIdAnnotationsRAIIObj { SmallVectorImpl &Container; public: DestroyTemplateIdAnnotationsRAIIObj(SmallVectorImpl &Container) : Container(Container) {} ~DestroyTemplateIdAnnotationsRAIIObj() { for (SmallVectorImpl::iterator I = Container.begin(), E = Container.end(); I != E; ++I) (*I)->Destroy(); Container.clear(); } }; } /// ParseTopLevelDecl - Parse one top-level declaration, return whatever the /// action tells us to. This returns true if the EOF was encountered. bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); // Skip over the EOF token, flagging end of previous input for incremental // processing if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof)) ConsumeToken(); Result = DeclGroupPtrTy(); switch (Tok.getKind()) { case tok::annot_pragma_unused: HandlePragmaUnused(); return false; case tok::annot_module_include: Actions.ActOnModuleInclude(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); return false; case tok::eof: // Late template parsing can begin. if (getLangOpts().DelayedTemplateParsing) Actions.SetLateTemplateParser(LateTemplateParserCallback, this); if (!PP.isIncrementalProcessingEnabled()) Actions.ActOnEndOfTranslationUnit(); //else don't tell Sema that we ended parsing: more input might come. return true; default: break; } ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); Result = ParseExternalDeclaration(attrs); return false; } /// ParseExternalDeclaration: /// /// external-declaration: [C99 6.9], declaration: [C++ dcl.dcl] /// function-definition /// declaration /// [GNU] asm-definition /// [GNU] __extension__ external-declaration /// [OBJC] objc-class-definition /// [OBJC] objc-class-declaration /// [OBJC] objc-alias-declaration /// [OBJC] objc-protocol-definition /// [OBJC] objc-method-definition /// [OBJC] @@end /// [C++] linkage-specification /// [GNU] asm-definition: /// simple-asm-expr ';' /// [C++11] empty-declaration /// [C++11] attribute-declaration /// /// [C++11] empty-declaration: /// ';' /// /// [C++0x/GNU] 'extern' 'template' declaration Parser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); ParenBraceBracketBalancer BalancerRAIIObj(*this); if (PP.isCodeCompletionReached()) { cutOffParsing(); return DeclGroupPtrTy(); } Decl *SingleDecl = 0; switch (Tok.getKind()) { case tok::annot_pragma_vis: HandlePragmaVisibility(); return DeclGroupPtrTy(); case tok::annot_pragma_pack: HandlePragmaPack(); return DeclGroupPtrTy(); case tok::annot_pragma_msstruct: HandlePragmaMSStruct(); return DeclGroupPtrTy(); case tok::annot_pragma_align: HandlePragmaAlign(); return DeclGroupPtrTy(); case tok::annot_pragma_weak: HandlePragmaWeak(); return DeclGroupPtrTy(); case tok::annot_pragma_weakalias: HandlePragmaWeakAlias(); return DeclGroupPtrTy(); case tok::annot_pragma_redefine_extname: HandlePragmaRedefineExtname(); return DeclGroupPtrTy(); case tok::annot_pragma_fp_contract: HandlePragmaFPContract(); return DeclGroupPtrTy(); case tok::annot_pragma_opencl_extension: HandlePragmaOpenCLExtension(); return DeclGroupPtrTy(); case tok::annot_pragma_openmp: ParseOpenMPDeclarativeDirective(); return DeclGroupPtrTy(); case tok::semi: // Either a C++11 empty-declaration or attribute-declaration. SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs.getList(), Tok.getLocation()); ConsumeExtraSemi(OutsideFunction); break; case tok::r_brace: Diag(Tok, diag::err_extraneous_closing_brace); ConsumeBrace(); return DeclGroupPtrTy(); case tok::eof: Diag(Tok, diag::err_expected_external_declaration); return DeclGroupPtrTy(); case tok::kw___extension__: { // __extension__ silences extension warnings in the subexpression. ExtensionRAIIObject O(Diags); // Use RAII to do this. ConsumeToken(); return ParseExternalDeclaration(attrs); } case tok::kw_asm: { ProhibitAttributes(attrs); SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc; ExprResult Result(ParseSimpleAsm(&EndLoc)); ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "top-level asm block"); if (Result.isInvalid()) return DeclGroupPtrTy(); SingleDecl = Actions.ActOnFileScopeAsmDecl(Result.get(), StartLoc, EndLoc); break; } case tok::at: return ParseObjCAtDirectives(); case tok::minus: case tok::plus: if (!getLangOpts().ObjC1) { Diag(Tok, diag::err_expected_external_declaration); ConsumeToken(); return DeclGroupPtrTy(); } SingleDecl = ParseObjCMethodDefinition(); break; case tok::code_completion: Actions.CodeCompleteOrdinaryName(getCurScope(), CurParsedObjCImpl? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); cutOffParsing(); return DeclGroupPtrTy(); case tok::kw_using: case tok::kw_namespace: case tok::kw_typedef: case tok::kw_template: case tok::kw_export: // As in 'export template' case tok::kw_static_assert: case tok::kw__Static_assert: // A function definition cannot start with any of these keywords. { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } case tok::kw_static: // Parse (then ignore) 'static' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 0; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } goto dont_know; case tok::kw_inline: if (getLangOpts().CPlusPlus) { tok::TokenKind NextKind = NextToken().getKind(); // Inline namespaces. Allowed as an extension even in C++03. if (NextKind == tok::kw_namespace) { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } // Parse (then ignore) 'inline' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (NextKind == tok::kw_template) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 1; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } } goto dont_know; case tok::kw_extern: if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { // Extern templates SourceLocation ExternLoc = ConsumeToken(); SourceLocation TemplateLoc = ConsumeToken(); Diag(ExternLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_extern_template : diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc); SourceLocation DeclEnd; return Actions.ConvertDeclToDeclGroup( ParseExplicitInstantiation(Declarator::FileContext, ExternLoc, TemplateLoc, DeclEnd)); } // FIXME: Detect C++ linkage specifications here? goto dont_know; case tok::kw___if_exists: case tok::kw___if_not_exists: ParseMicrosoftIfExistsExternalDeclaration(); return DeclGroupPtrTy(); default: dont_know: // We can't tell whether this is a function-definition or declaration yet. return ParseDeclarationOrFunctionDefinition(attrs, DS); } // This routine returns a DeclGroup, if the thing we parsed only contains a // single decl, convert it now. return Actions.ConvertDeclToDeclGroup(SingleDecl); } /// \brief Determine whether the current token, if it occurs after a /// declarator, continues a declaration or declaration list. bool Parser::isDeclarationAfterDeclarator() { // Check for '= delete' or '= default' if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); if (KW.is(tok::kw_default) || KW.is(tok::kw_delete)) return false; } return Tok.is(tok::equal) || // int X()= -> not a function def Tok.is(tok::comma) || // int X(), -> not a function def Tok.is(tok::semi) || // int X(); -> not a function def Tok.is(tok::kw_asm) || // int X() __asm__ -> not a function def Tok.is(tok::kw___attribute) || // int X() __attr__ -> not a function def (getLangOpts().CPlusPlus && Tok.is(tok::l_paren)); // int X(0) -> not a function def [C++] } /// \brief Determine whether the current token, if it occurs after a /// declarator, indicates the start of a function definition. bool Parser::isStartOfFunctionDefinition(const ParsingDeclarator &Declarator) { assert(Declarator.isFunctionDeclarator() && "Isn't a function declarator"); if (Tok.is(tok::l_brace)) // int X() {} return true; // Handle K&R C argument lists: int X(f) int f; {} if (!getLangOpts().CPlusPlus && Declarator.getFunctionTypeInfo().isKNRPrototype()) return isDeclarationSpecifier(); if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); return KW.is(tok::kw_default) || KW.is(tok::kw_delete); } return Tok.is(tok::colon) || // X() : Base() {} (used for ctors) Tok.is(tok::kw_try); // X() try { ... } } /// ParseDeclarationOrFunctionDefinition - Parse either a function-definition or /// a declaration. We can't tell which we have until we read up to the /// compound-statement in function-definition. TemplateParams, if /// non-NULL, provides the template parameters when we're parsing a /// C++ template-declaration. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// /// declaration: [C99 6.7] /// declaration-specifiers init-declarator-list[opt] ';' /// [!C99] init-declarator-list ';' [TODO: warn in c99 mode] /// [OMP] threadprivate-directive [TODO] /// Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs, ParsingDeclSpec &DS, AccessSpecifier AS) { // Parse the common declaration-specifiers piece. ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC_top_level); // If we had a free-standing type definition with a missing semicolon, we // may get this far before the problem becomes obvious. if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition(DS, AS, DSC_top_level)) return DeclGroupPtrTy(); // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" // declaration-specifiers init-declarator-list[opt] ';' if (Tok.is(tok::semi)) { ProhibitAttributes(attrs); ConsumeToken(); Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS); DS.complete(TheDecl); return Actions.ConvertDeclToDeclGroup(TheDecl); } DS.takeAttributesFrom(attrs); // ObjC2 allows prefix attributes on class interfaces and protocols. // FIXME: This still needs better diagnostics. We should only accept // attributes here, no types, etc. if (getLangOpts().ObjC2 && Tok.is(tok::at)) { SourceLocation AtLoc = ConsumeToken(); // the "@@" if (!Tok.isObjCAtKeyword(tok::objc_interface) && !Tok.isObjCAtKeyword(tok::objc_protocol)) { Diag(Tok, diag::err_objc_unexpected_attr); SkipUntil(tok::semi); // FIXME: better skip? return DeclGroupPtrTy(); } DS.abort(); const char *PrevSpec = 0; unsigned DiagID; if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID)) Diag(AtLoc, DiagID) << PrevSpec; if (Tok.isObjCAtKeyword(tok::objc_protocol)) return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes()); return Actions.ConvertDeclToDeclGroup( ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes())); } // If the declspec consisted only of 'extern' and we have a string // literal following it, this must be a C++ linkage specifier like // 'extern "C"'. if (Tok.is(tok::string_literal) && getLangOpts().CPlusPlus && DS.getStorageClassSpec() == DeclSpec::SCS_extern && DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) { Decl *TheDecl = ParseLinkage(DS, Declarator::FileContext); return Actions.ConvertDeclToDeclGroup(TheDecl); } return ParseDeclGroup(DS, Declarator::FileContext, true); } Parser::DeclGroupPtrTy Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS, AccessSpecifier AS) { if (DS) { return ParseDeclOrFunctionDefInternal(attrs, *DS, AS); } else { ParsingDeclSpec PDS(*this); // Must temporarily exit the objective-c container scope for // parsing c constructs and re-enter objc container scope // afterwards. ObjCDeclContextSwitch ObjCDC(*this); return ParseDeclOrFunctionDefInternal(attrs, PDS, AS); } } static inline bool isFunctionDeclaratorRequiringReturnTypeDeduction( const Declarator &D) { if (!D.isFunctionDeclarator() || !D.getDeclSpec().containsPlaceholderType()) return false; for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { unsigned chunkIndex = E - I - 1; const DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); if (DeclType.Kind == DeclaratorChunk::Function) { const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; if (!FTI.hasTrailingReturnType()) return true; QualType TrailingRetType = FTI.getTrailingReturnType().get(); return TrailingRetType->getCanonicalTypeInternal() ->getContainedAutoType(); } } return false; } /// ParseFunctionDefinition - We parsed and verified that the specified /// Declarator is well formed. If this is a K&R-style function, read the /// parameters declaration-list, then start the compound-statement. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator ctor-initializer[opt] /// function-body /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator function-try-block /// Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) { // Poison the SEH identifiers so they are flagged as illegal in function bodies PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true); const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // If this is C90 and the declspecs were completely missing, fudge in an // implicit int. We do this here because this is the only place where // declaration-specifiers are completely optional in the grammar. if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) { const char *PrevSpec; unsigned DiagID; D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int, D.getIdentifierLoc(), PrevSpec, DiagID); D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin()); } // If this declaration was formed with a K&R-style identifier list for the // arguments, parse declarations for all of the args next. // int foo(a,b) int a; float b; {} if (FTI.isKNRPrototype()) ParseKNRParamDeclarations(D); // We should have either an opening brace or, in a C++ constructor, // we may have a colon. if (Tok.isNot(tok::l_brace) && (!getLangOpts().CPlusPlus || (Tok.isNot(tok::colon) && Tok.isNot(tok::kw_try) && Tok.isNot(tok::equal)))) { Diag(Tok, diag::err_expected_fn_body); // Skip over garbage, until we get to '{'. Don't eat the '{'. SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); // If we didn't find the '{', bail out. if (Tok.isNot(tok::l_brace)) return 0; } // Check to make sure that any normal attributes are allowed to be on // a definition. Late parsed attributes are checked at the end. if (Tok.isNot(tok::equal)) { AttributeList *DtorAttrs = D.getAttributes(); while (DtorAttrs) { if (!IsThreadSafetyAttribute(DtorAttrs->getName()->getName()) && !DtorAttrs->isCXX11Attribute()) { Diag(DtorAttrs->getLoc(), diag::warn_attribute_on_function_definition) << DtorAttrs->getName()->getName(); } DtorAttrs = DtorAttrs->getNext(); } } // In delayed template parsing mode, for function template we consume the // tokens and store them for late parsing at the end of the translation unit. if (getLangOpts().DelayedTemplateParsing && Tok.isNot(tok::equal) && TemplateInfo.Kind == ParsedTemplateInfo::Template && !D.getDeclSpec().isConstexprSpecified() && !isFunctionDeclaratorRequiringReturnTypeDeduction(D)) { MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams); ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *DP = Actions.HandleDeclarator(ParentScope, D, TemplateParameterLists); D.complete(DP); D.getMutableDeclSpec().abort(); CachedTokens Toks; LexTemplateFunctionForLateParsing(Toks); if (DP) { FunctionDecl *FnD = 0; if (FunctionTemplateDecl *FunTmpl = dyn_cast(DP)) FnD = FunTmpl->getTemplatedDecl(); else FnD = cast(DP); Actions.CheckForFunctionRedefinition(FnD); Actions.MarkAsLateParsedTemplate(FnD, DP, Toks); } return DP; } else if (CurParsedObjCImpl && !TemplateInfo.TemplateParams && (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || Tok.is(tok::colon)) && Actions.CurContext->isTranslationUnit()) { ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); D.complete(FuncDecl); D.getMutableDeclSpec().abort(); if (FuncDecl) { // Consume the tokens and store them for later parsing. StashAwayMethodOrFunctionBodyTokens(FuncDecl); CurParsedObjCImpl->HasCFunction = true; return FuncDecl; } } // Enter a scope for the function body. ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); // Tell the actions module that we have entered a function definition with the // specified Declarator for the function. Decl *Res = TemplateInfo.TemplateParams? Actions.ActOnStartOfFunctionTemplateDef(getCurScope(), *TemplateInfo.TemplateParams, D) : Actions.ActOnStartOfFunctionDef(getCurScope(), D); // Break out of the ParsingDeclarator context before we parse the body. D.complete(Res); // Break out of the ParsingDeclSpec context, too. This const_cast is // safe because we're always the sole owner. D.getMutableDeclSpec().abort(); if (Tok.is(tok::equal)) { assert(getLangOpts().CPlusPlus && "Only C++ function definitions have '='"); ConsumeToken(); Actions.ActOnFinishFunctionBody(Res, 0, false); bool Delete = false; SourceLocation KWLoc; if (Tok.is(tok::kw_delete)) { Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_deleted_function : diag::ext_deleted_function); KWLoc = ConsumeToken(); Actions.SetDeclDeleted(Res, KWLoc); Delete = true; } else if (Tok.is(tok::kw_default)) { Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_function : diag::ext_defaulted_function); KWLoc = ConsumeToken(); Actions.SetDeclDefaulted(Res, KWLoc); } else { llvm_unreachable("function definition after = not 'delete' or 'default'"); } if (Tok.is(tok::comma)) { Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) << Delete; SkipUntil(tok::semi); } else { ExpectAndConsume(tok::semi, diag::err_expected_semi_after, Delete ? "delete" : "default", tok::semi); } return Res; } if (Tok.is(tok::kw_try)) return ParseFunctionTryBlock(Res, BodyScope); // If we have a colon, then we're probably parsing a C++ // ctor-initializer. if (Tok.is(tok::colon)) { ParseConstructorInitializer(Res); // Recover from error. if (!Tok.is(tok::l_brace)) { BodyScope.Exit(); Actions.ActOnFinishFunctionBody(Res, 0); return Res; } } else Actions.ActOnDefaultCtorInitializers(Res); // Late attributes are parsed in the same scope as the function body. if (LateParsedAttrs) ParseLexedAttributeList(*LateParsedAttrs, Res, false, true); return ParseFunctionStatementBody(Res, BodyScope); } /// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides /// types for a function with a K&R-style identifier list for arguments. void Parser::ParseKNRParamDeclarations(Declarator &D) { // We know that the top-level of this declarator is a function. DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // Enter function-declaration scope, limiting any declarators to the // function prototype scope, including parameter declarators. ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | Scope::FunctionDeclarationScope | Scope::DeclScope); // Read all the argument declarations. while (isDeclarationSpecifier()) { SourceLocation DSStart = Tok.getLocation(); // Parse the common declaration-specifiers piece. DeclSpec DS(AttrFactory); ParseDeclarationSpecifiers(DS); // C99 6.9.1p6: 'each declaration in the declaration list shall have at // least one declarator'. // NOTE: GCC just makes this an ext-warn. It's not clear what it does with // the declarations though. It's trivial to ignore them, really hard to do // anything else with them. if (Tok.is(tok::semi)) { Diag(DSStart, diag::err_declaration_does_not_declare_param); ConsumeToken(); continue; } // C99 6.9.1p6: Declarations shall contain no storage-class specifiers other // than register. if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && DS.getStorageClassSpec() != DeclSpec::SCS_register) { Diag(DS.getStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) { Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } // Parse the first declarator attached to this declspec. Declarator ParmDeclarator(DS, Declarator::KNRTypeListContext); ParseDeclarator(ParmDeclarator); // Handle the full declarator list. while (1) { // If attributes are present, parse them. MaybeParseGNUAttributes(ParmDeclarator); // Ask the actions module to compute the type for this declarator. Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator); if (Param && // A missing identifier has already been diagnosed. ParmDeclarator.getIdentifier()) { // Scan the argument list looking for the correct param to apply this // type. for (unsigned i = 0; ; ++i) { // C99 6.9.1p6: those declarators shall declare only identifiers from // the identifier list. if (i == FTI.NumArgs) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param) << ParmDeclarator.getIdentifier(); break; } if (FTI.ArgInfo[i].Ident == ParmDeclarator.getIdentifier()) { // Reject redefinitions of parameters. if (FTI.ArgInfo[i].Param) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_param_redefinition) << ParmDeclarator.getIdentifier(); } else { FTI.ArgInfo[i].Param = Param; } break; } } } // If we don't have a comma, it is either the end of the list (a ';') or // an error, bail out. if (Tok.isNot(tok::comma)) break; ParmDeclarator.clear(); // Consume the comma. ParmDeclarator.setCommaLoc(ConsumeToken()); // Parse the next declarator. ParseDeclarator(ParmDeclarator); } if (ExpectAndConsumeSemi(diag::err_expected_semi_declaration)) { // Skip to end of block or statement SkipUntil(tok::semi); if (Tok.is(tok::semi)) ConsumeToken(); } } // The actions module must verify that all arguments were declared. Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation()); } /// ParseAsmStringLiteral - This is just a normal string-literal, but is not /// allowed to be a wide string, and is not subject to character translation. /// /// [GNU] asm-string-literal: /// string-literal /// Parser::ExprResult Parser::ParseAsmStringLiteral() { switch (Tok.getKind()) { case tok::string_literal: break; case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: case tok::wide_string_literal: { SourceLocation L = Tok.getLocation(); Diag(Tok, diag::err_asm_operand_wide_string_literal) << (Tok.getKind() == tok::wide_string_literal) << SourceRange(L, L); return ExprError(); } default: Diag(Tok, diag::err_expected_string_literal) << /*Source='in...'*/0 << "'asm'"; return ExprError(); } return ParseStringLiteralExpression(); } /// ParseSimpleAsm /// /// [GNU] simple-asm-expr: /// 'asm' '(' asm-string-literal ')' /// Parser::ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { assert(Tok.is(tok::kw_asm) && "Not an asm!"); SourceLocation Loc = ConsumeToken(); if (Tok.is(tok::kw_volatile)) { // Remove from the end of 'asm' to the end of 'volatile'. SourceRange RemovalRange(PP.getLocForEndOfToken(Loc), PP.getLocForEndOfToken(Tok.getLocation())); Diag(Tok, diag::warn_file_asm_volatile) << FixItHint::CreateRemoval(RemovalRange); ConsumeToken(); } BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << "asm"; return ExprError(); } ExprResult Result(ParseAsmStringLiteral()); if (Result.isInvalid()) { SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch); if (EndLoc) *EndLoc = Tok.getLocation(); ConsumeAnyToken(); } else { // Close the paren and get the location of the end bracket T.consumeClose(); if (EndLoc) *EndLoc = T.getCloseLocation(); } return Result; } /// \brief Get the TemplateIdAnnotation from the token and put it in the /// cleanup pool so that it gets destroyed when parsing the current top level /// declaration is finished. TemplateIdAnnotation *Parser::takeTemplateIdAnnotation(const Token &tok) { assert(tok.is(tok::annot_template_id) && "Expected template-id token"); TemplateIdAnnotation * Id = static_cast(tok.getAnnotationValue()); return Id; } void Parser::AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation) { // Push the current token back into the token stream (or revert it if it is // cached) and use an annotation scope token for current token. if (PP.isBacktrackEnabled()) PP.RevertCachedTokens(1); else PP.EnterToken(Tok); Tok.setKind(tok::annot_cxxscope); Tok.setAnnotationValue(Actions.SaveNestedNameSpecifierAnnotation(SS)); Tok.setAnnotationRange(SS.getRange()); // In case the tokens were cached, have Preprocessor replace them // with the annotation token. We don't need to do this if we've // just reverted back to a prior state. if (IsNewAnnotation) PP.AnnotateCachedTokens(Tok); } /// \brief Attempt to classify the name at the current token position. This may /// form a type, scope or primary expression annotation, or replace the token /// with a typo-corrected keyword. This is only appropriate when the current /// name must refer to an entity which has already been declared. /// /// \param IsAddressOfOperand Must be \c true if the name is preceded by an '&' /// and might possibly have a dependent nested name specifier. /// \param CCC Indicates how to perform typo-correction for this name. If NULL, /// no typo correction will be performed. Parser::AnnotatedNameKind Parser::TryAnnotateName(bool IsAddressOfOperand, CorrectionCandidateCallback *CCC) { assert(Tok.is(tok::identifier) || Tok.is(tok::annot_cxxscope)); const bool EnteringContext = false; const bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return ANK_Error; if (Tok.isNot(tok::identifier) || SS.isInvalid()) { if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return ANK_Unresolved; } IdentifierInfo *Name = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); // FIXME: Move the tentative declaration logic into ClassifyName so we can // typo-correct to tentatively-declared identifiers. if (isTentativelyDeclared(Name)) { // Identifier has been tentatively declared, and thus cannot be resolved as // an expression. Fall back to annotating it as a type. if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return Tok.is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl; } Token Next = NextToken(); // Look up and classify the identifier. We don't perform any typo-correction // after a scope specifier, because in general we can't recover from typos // there (eg, after correcting 'A::tempalte B::C', we would need to jump // back into scope specifier parsing). Sema::NameClassification Classification = Actions.ClassifyName(getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, SS.isEmpty() ? CCC : 0); switch (Classification.getKind()) { case Sema::NC_Error: return ANK_Error; case Sema::NC_Keyword: // The identifier was typo-corrected to a keyword. Tok.setIdentifierInfo(Name); Tok.setKind(Name->getTokenID()); PP.TypoCorrectToken(Tok); if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); // We've "annotated" this as a keyword. return ANK_Success; case Sema::NC_Unknown: // It's not something we know about. Leave it unannotated. break; case Sema::NC_Type: Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Classification.getType()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_Expression: Tok.setKind(tok::annot_primary_expr); setExprAnnotation(Tok, Classification.getExpression()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_TypeTemplate: if (Next.isNot(tok::less)) { // This may be a type template being used as a template template argument. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_TemplateName; } // Fall through. case Sema::NC_VarTemplate: case Sema::NC_FunctionTemplate: { // We have a type, variable or function template followed by '<'. ConsumeToken(); UnqualifiedId Id; Id.setIdentifier(Name, NameLoc); if (AnnotateTemplateIdToken( TemplateTy::make(Classification.getTemplateName()), Classification.getTemplateNameKind(), SS, SourceLocation(), Id)) return ANK_Error; return ANK_Success; } case Sema::NC_NestedNameSpecifier: llvm_unreachable("already parsed nested name specifier"); } // Unable to classify the name, but maybe we can annotate a scope specifier. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_Unresolved; } /// TryAnnotateTypeOrScopeToken - If the current token position is on a /// typename (possibly qualified in C++) or a C++ scope specifier not followed /// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens /// with a single annotation token representing the typename or C++ scope /// respectively. /// This simplifies handling of C++ scope specifiers and allows efficient /// backtracking without the need to re-parse and resolve nested-names and /// typenames. /// It will mainly be called when we expect to treat identifiers as typenames /// (if they are typenames). For example, in C we do not expect identifiers /// inside expressions to be treated as typenames so it will not be called /// for expressions in C. /// The benefit for C/ObjC is that a typename will be annotated and /// Actions.getTypeName will not be needed to be called again (e.g. getTypeName /// will not be called twice, once to check whether we have a declaration /// specifier, and another one to get the actual type inside /// ParseDeclarationSpecifiers). /// /// This returns true if an error occurred. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateTypeOrScopeToken(bool EnteringContext, bool NeedType) { assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)) && "Cannot be a type or scope token!"); if (Tok.is(tok::kw_typename)) { // MSVC lets you do stuff like: // typename typedef T_::D D; // // We will consume the typedef token here and put it back after we have // parsed the first identifier, transforming it into something more like: // typename T_::D typedef D; if (getLangOpts().MicrosoftMode && NextToken().is(tok::kw_typedef)) { Token TypedefToken; PP.Lex(TypedefToken); bool Result = TryAnnotateTypeOrScopeToken(EnteringContext, NeedType); PP.EnterToken(Tok); Tok = TypedefToken; if (!Result) Diag(Tok.getLocation(), diag::warn_expected_qualified_after_typename); return Result; } // Parse a C++ typename-specifier, e.g., "typename T::type". // // typename-specifier: // 'typename' '::' [opt] nested-name-specifier identifier // 'typename' '::' [opt] nested-name-specifier template [opt] // simple-template-id SourceLocation TypenameLoc = ConsumeToken(); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/ParsedType(), /*EnteringContext=*/false, 0, /*IsTypename*/true)) return true; if (!SS.isSet()) { if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id) || Tok.is(tok::annot_decltype)) { // Attempt to recover by skipping the invalid 'typename' if (Tok.is(tok::annot_decltype) || (!TryAnnotateTypeOrScopeToken(EnteringContext, NeedType) && Tok.isAnnotation())) { unsigned DiagID = diag::err_expected_qualified_after_typename; // MS compatibility: MSVC permits using known types with typename. // e.g. "typedef typename T* pointer_type" if (getLangOpts().MicrosoftExt) DiagID = diag::warn_expected_qualified_after_typename; Diag(Tok.getLocation(), DiagID); return false; } } Diag(Tok.getLocation(), diag::err_expected_qualified_after_typename); return true; } TypeResult Ty; if (Tok.is(tok::identifier)) { // FIXME: check whether the next token is '<', first! Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, *Tok.getIdentifierInfo(), Tok.getLocation()); } else if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind == TNK_Function_template) { Diag(Tok, diag::err_typename_refers_to_non_type_template) << Tok.getAnnotationRange(); return true; } ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), TemplateId->NumArgs); Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, TemplateId->TemplateKWLoc, TemplateId->Template, TemplateId->TemplateNameLoc, TemplateId->LAngleLoc, TemplateArgsPtr, TemplateId->RAngleLoc); } else { Diag(Tok, diag::err_expected_type_name_after_typename) << SS.getRange(); return true; } SourceLocation EndLoc = Tok.getLastLoc(); Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty.isInvalid() ? ParsedType() : Ty.get()); Tok.setAnnotationEndLoc(EndLoc); Tok.setLocation(TypenameLoc); PP.AnnotateCachedTokens(Tok); return false; } // Remembers whether the token was originally a scope annotation. bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus) if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; return TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, NeedType, SS, !WasScopeAnnotation); } /// \brief Try to annotate a type or scope token, having already parsed an /// optional scope specifier. \p IsNewScope should be \c true unless the scope /// specifier was extracted from an existing tok::annot_cxxscope annotation. bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(bool EnteringContext, bool NeedType, CXXScopeSpec &SS, bool IsNewScope) { if (Tok.is(tok::identifier)) { IdentifierInfo *CorrectedII = 0; // Determine whether the identifier is a type name. if (ParsedType Ty = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS, false, NextToken().is(tok::period), ParsedType(), /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/true, NeedType ? &CorrectedII : NULL)) { // A FixIt was applied as a result of typo correction if (CorrectedII) Tok.setIdentifierInfo(CorrectedII); // This is a typename. Replace the current token in-place with an // annotation type token. Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty); Tok.setAnnotationEndLoc(Tok.getLocation()); if (SS.isNotEmpty()) // it was a C++ qualified type name. Tok.setLocation(SS.getBeginLoc()); // In case the tokens were cached, have Preprocessor replace // them with the annotation token. PP.AnnotateCachedTokens(Tok); return false; } if (!getLangOpts().CPlusPlus) { // If we're in C, we can't have :: tokens at all (the lexer won't return // them). If the identifier is not a type, then it can't be scope either, // just early exit. return false; } // If this is a template-id, annotate with a template-id or type token. if (NextToken().is(tok::less)) { TemplateTy Template; UnqualifiedId TemplateName; TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); bool MemberOfUnknownSpecialization; if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/ ParsedType(), EnteringContext, Template, MemberOfUnknownSpecialization)) { // Consume the identifier. ConsumeToken(); if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), TemplateName)) { // If an unrecoverable error occurred, we need to return true here, // because the token stream is in a damaged state. We may not return // a valid identifier. return true; } } } // The current token, which is either an identifier or a // template-id, is not part of the annotation. Fall through to // push that token back into the stream and complete the C++ scope // specifier annotation. } if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind == TNK_Type_template) { // A template-id that refers to a type was parsed into a // template-id annotation in a context where we weren't allowed // to produce a type annotation token. Update the template-id // annotation token to a type annotation token now. AnnotateTemplateIdTokenAsType(); return false; } else if (TemplateId->Kind == TNK_Var_template) return false; } if (SS.isEmpty()) return false; // A C++ scope specifier that isn't followed by a typename. AnnotateScopeToken(SS, IsNewScope); return false; } /// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only /// annotates C++ scope specifiers and template-ids. This returns /// true if there was an error that could not be recovered from. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateCXXScopeToken(bool EnteringContext) { assert(getLangOpts().CPlusPlus && "Call sites of this function should be guarded by checking for C++"); assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) || Tok.is(tok::kw_decltype)) && "Cannot be a type or scope token!"); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; if (SS.isEmpty()) return false; AnnotateScopeToken(SS, true); return false; } bool Parser::isTokenEqualOrEqualTypo() { tok::TokenKind Kind = Tok.getKind(); switch (Kind) { default: return false; case tok::ampequal: // &= case tok::starequal: // *= case tok::plusequal: // += case tok::minusequal: // -= case tok::exclaimequal: // != case tok::slashequal: // /= case tok::percentequal: // %= case tok::lessequal: // <= case tok::lesslessequal: // <<= case tok::greaterequal: // >= case tok::greatergreaterequal: // >>= case tok::caretequal: // ^= case tok::pipeequal: // |= case tok::equalequal: // == Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal) << getTokenSimpleSpelling(Kind) << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "="); case tok::equal: return true; } } SourceLocation Parser::handleUnexpectedCodeCompletionToken() { assert(Tok.is(tok::code_completion)); PrevTokLocation = Tok.getLocation(); for (Scope *S = getCurScope(); S; S = S->getParent()) { if (S->getFlags() & Scope::FnScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction); cutOffParsing(); return PrevTokLocation; } if (S->getFlags() & Scope::ClassScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class); cutOffParsing(); return PrevTokLocation; } } Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace); cutOffParsing(); return PrevTokLocation; } // Anchor the Parser::FieldCallback vtable to this translation unit. // We use a spurious method instead of the destructor because // destroying FieldCallbacks can actually be slightly // performance-sensitive. void Parser::FieldCallback::_anchor() { } // Code-completion pass-through functions void Parser::CodeCompleteDirective(bool InConditional) { Actions.CodeCompletePreprocessorDirective(InConditional); } void Parser::CodeCompleteInConditionalExclusion() { Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope()); } void Parser::CodeCompleteMacroName(bool IsDefinition) { Actions.CodeCompletePreprocessorMacroName(IsDefinition); } void Parser::CodeCompletePreprocessorExpression() { Actions.CodeCompletePreprocessorExpression(); } void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned ArgumentIndex) { Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, ArgumentIndex); } void Parser::CodeCompleteNaturalLanguage() { Actions.CodeCompleteNaturalLanguage(); } bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition& Result) { assert((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists)) && "Expected '__if_exists' or '__if_not_exists'"); Result.IsIfExists = Tok.is(tok::kw___if_exists); Result.KeywordLoc = ConsumeToken(); BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << (Result.IsIfExists? "__if_exists" : "__if_not_exists"); return true; } // Parse nested-name-specifier. ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), /*EnteringContext=*/false); // Check nested-name specifier. if (Result.SS.isInvalid()) { T.skipToEnd(); return true; } // Parse the unqualified-id. SourceLocation TemplateKWLoc; // FIXME: parsed, but unused. if (ParseUnqualifiedId(Result.SS, false, true, true, ParsedType(), TemplateKWLoc, Result.Name)) { T.skipToEnd(); return true; } if (T.consumeClose()) return true; // Check if the symbol exists. switch (Actions.CheckMicrosoftIfExistsSymbol(getCurScope(), Result.KeywordLoc, Result.IsIfExists, Result.SS, Result.Name)) { case Sema::IER_Exists: Result.Behavior = Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_DoesNotExist: Result.Behavior = !Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_Dependent: Result.Behavior = IEB_Dependent; break; case Sema::IER_Error: return true; } return false; } void Parser::ParseMicrosoftIfExistsExternalDeclaration() { IfExistsCondition Result; if (ParseMicrosoftIfExistsCondition(Result)) return; BalancedDelimiterTracker Braces(*this, tok::l_brace); if (Braces.consumeOpen()) { Diag(Tok, diag::err_expected_lbrace); return; } switch (Result.Behavior) { case IEB_Parse: // Parse declarations below. break; case IEB_Dependent: llvm_unreachable("Cannot have a dependent external declaration"); case IEB_Skip: Braces.skipToEnd(); return; } // Parse the declarations. while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); DeclGroupPtrTy Result = ParseExternalDeclaration(attrs); if (Result && !getCurScope()->getParent()) Actions.getASTConsumer().HandleTopLevelDecl(Result.get()); } Braces.consumeClose(); } Parser::DeclGroupPtrTy Parser::ParseModuleImport(SourceLocation AtLoc) { assert(Tok.isObjCAtKeyword(tok::objc_import) && "Improper start to module import"); SourceLocation ImportLoc = ConsumeToken(); SmallVector, 2> Path; // Parse the module path. do { if (!Tok.is(tok::identifier)) { if (Tok.is(tok::code_completion)) { Actions.CodeCompleteModuleImport(ImportLoc, Path); ConsumeCodeCompletionToken(); SkipUntil(tok::semi); return DeclGroupPtrTy(); } Diag(Tok, diag::err_module_expected_ident); SkipUntil(tok::semi); return DeclGroupPtrTy(); } // Record this part of the module path. Path.push_back(std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation())); ConsumeToken(); if (Tok.is(tok::period)) { ConsumeToken(); continue; } break; } while (true); if (PP.hadModuleLoaderFatalFailure()) { // With a fatal failure in the module loader, we abort parsing. cutOffParsing(); return DeclGroupPtrTy(); } DeclResult Import = Actions.ActOnModuleImport(AtLoc, ImportLoc, Path); ExpectAndConsumeSemi(diag::err_module_expected_semi); if (Import.isInvalid()) return DeclGroupPtrTy(); return Actions.ConvertDeclToDeclGroup(Import.get()); } bool BalancedDelimiterTracker::diagnoseOverflow() { P.Diag(P.Tok, diag::err_bracket_depth_exceeded) << P.getLangOpts().BracketDepth; P.Diag(P.Tok, diag::note_bracket_depth); P.SkipUntil(tok::eof); return true; } bool BalancedDelimiterTracker::expectAndConsume(unsigned DiagID, const char *Msg, tok::TokenKind SkipToToc ) { LOpen = P.Tok.getLocation(); if (P.ExpectAndConsume(Kind, DiagID, Msg, SkipToToc)) return true; if (getDepth() < MaxDepth) return false; return diagnoseOverflow(); } bool BalancedDelimiterTracker::diagnoseMissingClose() { assert(!P.Tok.is(Close) && "Should have consumed closing delimiter"); const char *LHSName = "unknown"; diag::kind DID; switch (Close) { default: llvm_unreachable("Unexpected balanced token"); case tok::r_paren : LHSName = "("; DID = diag::err_expected_rparen; break; case tok::r_brace : LHSName = "{"; DID = diag::err_expected_rbrace; break; case tok::r_square: LHSName = "["; DID = diag::err_expected_rsquare; break; } P.Diag(P.Tok, DID); P.Diag(LOpen, diag::note_matching) << LHSName; // If we're not already at some kind of closing bracket, skip to our closing // token. if (P.Tok.isNot(tok::r_paren) && P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::r_square) && P.SkipUntil(Close, FinalToken, Parser::StopAtSemi | Parser::StopBeforeMatch) && P.Tok.is(Close)) LClose = P.ConsumeAnyToken(); return true; } void BalancedDelimiterTracker::skipToEnd() { P.SkipUntil(Close, Parser::StopBeforeMatch); consumeClose(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d155 6 d162 1 a162 1 const char *Msg) { d171 4 a174 9 DiagnosticBuilder DB = Diag(Loc, DiagID); DB << FixItHint::CreateReplacement(SourceRange(Loc), getTokenSimpleSpelling(ExpectedTok)); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; d181 1 d183 8 a190 14 const char *Spelling = 0; if (EndLoc.isValid()) Spelling = tok::getTokenSimpleSpelling(ExpectedTok); DiagnosticBuilder DB = Spelling ? Diag(EndLoc, DiagID) << FixItHint::CreateInsertion(EndLoc, Spelling) : Diag(Tok, DiagID); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; d192 2 d198 2 a199 5 if (TryConsumeToken(tok::semi)) return false; if (Tok.is(tok::code_completion)) { handleUnexpectedCodeCompletionToken(); d291 1 a291 1 while (Tok.isNot(tok::eof)) d300 1 a300 11 case tok::annot_pragma_openmp_end: // Stop before an OpenMP pragma boundary. case tok::annot_module_begin: case tok::annot_module_end: case tok::annot_module_include: // Stop before we change submodules. They generally indicate a "good" // place to pick up parsing again (except in the special case where // we're trying to skip to EOF). return false; d303 1 a303 1 handleUnexpectedCodeCompletionToken(); d577 1 a577 1 // Skip over the EOF token, flagging end of previous input for incremental a594 6 case tok::annot_module_begin: case tok::annot_module_end: // FIXME: Update visibility based on the submodule we're in. ConsumeToken(); return false; d709 1 a709 1 ExpectAndConsume(tok::semi, diag::err_expected_after, d1035 1 a1035 1 << DtorAttrs->getName(); d1111 1 a1111 1 if (TryConsumeToken(tok::equal)) { d1113 2 d1119 6 a1124 4 if (TryConsumeToken(tok::kw_delete, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_deleted_function : diag::ext_deleted_function); d1127 6 a1132 4 } else if (TryConsumeToken(tok::kw_default, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_function : diag::ext_defaulted_function); d1142 3 a1144 3 } else if (ExpectAndConsume(tok::semi, diag::err_expected_after, Delete ? "delete" : "default")) { SkipUntil(tok::semi); d1343 6 a1348 1 if (!Result.isInvalid()) { a1352 4 } else if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) { if (EndLoc) *EndLoc = Tok.getLocation(); ConsumeParen(); d1433 2 a1434 2 // there (eg, after correcting 'A::tempalte B::C' [sic], we would need to // jump back into scope specifier parsing). a1505 29 bool Parser::TryKeywordIdentFallback(bool DisableKeyword) { assert(!Tok.is(tok::identifier) && !Tok.isAnnotation()); Diag(Tok, diag::ext_keyword_as_ident) << PP.getSpelling(Tok) << DisableKeyword; if (DisableKeyword) { IdentifierInfo *II = Tok.getIdentifierInfo(); ContextualKeywords[II] = Tok.getKind(); II->RevertTokenIDToIdentifier(); } Tok.setKind(tok::identifier); return true; } bool Parser::TryIdentKeywordUpgrade() { assert(Tok.is(tok::identifier)); const IdentifierInfo *II = Tok.getIdentifierInfo(); assert(II->hasRevertedTokenIDToIdentifier()); // If we find that this is in fact the name of a type trait, // update the token kind in place and parse again to treat it as // the appropriate kind of type trait. llvm::SmallDenseMap::iterator Known = ContextualKeywords.find(II); if (Known == ContextualKeywords.end()) return false; Tok.setKind(Known->second); return true; } d1593 1 a1593 2 if (TemplateId->Kind != TNK_Type_template && TemplateId->Kind != TNK_Dependent_template_name) { d1717 2 a1718 1 } d1772 2 a1773 2 << Kind << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "="); d1902 1 a1902 1 Diag(Tok, diag::err_expected) << tok::l_brace; d1920 1 a1920 2 // FIXME: Support module import within __if_exists? while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { d1927 1 a1927 1 } d1983 2 a1984 2 P.cutOffParsing(); return true; d1988 2 a1989 2 const char *Msg, tok::TokenKind SkipToTok) { d1991 1 a1991 3 if (P.ExpectAndConsume(Kind, DiagID, Msg)) { if (SkipToTok != tok::unknown) P.SkipUntil(SkipToTok, Parser::StopAtSemi); d1993 1 a1993 2 } d2002 11 a2012 3 P.Diag(P.Tok, diag::err_expected) << Close; P.Diag(LOpen, diag::note_matching) << Kind; @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @a17 1 #include "clang/AST/ASTContext.h" d167 1 a167 1 getPunctuatorSpelling(ExpectedTok)); d183 1 a183 1 Spelling = tok::getPunctuatorSpelling(ExpectedTok); d249 1 a249 2 << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST, Actions.getASTContext().getPrintingPolicy()) d933 1 a933 2 if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID, Actions.getASTContext().getPrintingPolicy())) a1019 1 const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); d1022 1 a1022 2 PrevSpec, DiagID, Policy); d1213 1 a1213 1 if (TryConsumeToken(tok::semi)) { d1215 1 d1289 6 a1294 8 // Consume ';' and continue parsing. if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration)) continue; // Otherwise recover by skipping to next semi or mandatory function body. if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch)) break; TryConsumeToken(tok::semi); d1584 1 a1584 1 if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) { @ 1.1.1.4 log @Import Clang 3.5svn r201163. @ text @a110 2 MSPointersToMembers.reset(new PragmaMSPointersToMembers()); PP.AddPragmaHandler(MSPointersToMembers.get()); a485 2 PP.RemovePragmaHandler(MSPointersToMembers.get()); MSPointersToMembers.reset(); a704 3 case tok::annot_pragma_ms_pointers_to_members: HandlePragmaMSPointersToMembers(); return DeclGroupPtrTy(); d1058 1 a1058 1 if (DtorAttrs->isKnownToGCC() && d1088 6 a1093 1 FunctionDecl *FnD = DP->getAsFunction(); @ 1.1.1.5 log @Import Clang 3.5svn r202566. @ text @d15 1 d67 47 a113 1 initializePragmaHandlers(); d168 10 a177 11 { DiagnosticBuilder DB = Diag(Loc, DiagID); DB << FixItHint::CreateReplacement( SourceRange(Loc), tok::getPunctuatorSpelling(ExpectedTok)); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; } a179 1 ConsumeAnyToken(); d457 37 a493 1 resetPragmaHandlers(); a711 3 case tok::annot_pragma_ms_vtordisp: HandlePragmaMSVtorDisp(); return DeclGroupPtrTy(); d826 1 d956 1 a956 1 if (getLangOpts().CPlusPlus && isTokenStringLiteral() && d1261 1 a1261 1 if (i == FTI.NumParams) { d1267 1 a1267 1 if (FTI.Params[i].Ident == ParmDeclarator.getIdentifier()) { d1269 1 a1269 1 if (FTI.Params[i].Param) { d1274 1 a1274 1 FTI.Params[i].Param = Param; @ 1.1.1.5.2.1 log @Rebase. @ text @d36 1 a36 1 bool HandleComment(Preprocessor &PP, SourceRange Comment) override { d59 1 a59 1 Actions.CurScope = nullptr; d62 1 a62 1 CurParsedObjCImpl = nullptr; d139 1 a139 1 const char *Spelling = nullptr; d368 2 a369 1 Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); d384 1 a384 1 : CurScope(ManageFlags ? Self->getCurScope() : nullptr) { d406 2 a407 2 Actions.CurScope = nullptr; d425 1 a425 1 assert(getCurScope() == nullptr && "A scope is already active?"); d440 4 a443 4 Ident_instancetype = nullptr; Ident_final = nullptr; Ident_sealed = nullptr; Ident_override = nullptr; d453 10 a462 12 Ident_introduced = nullptr; Ident_deprecated = nullptr; Ident_obsoleted = nullptr; Ident_unavailable = nullptr; Ident__except = nullptr; Ident__exception_code = Ident__exception_info = nullptr; Ident__abnormal_termination = Ident___exception_code = nullptr; Ident___exception_info = Ident___abnormal_termination = nullptr; Ident_GetExceptionCode = Ident_GetExceptionInfo = nullptr; Ident_AbnormalTermination = nullptr; d596 1 a596 1 Decl *SingleDecl = nullptr; a633 3 case tok::annot_pragma_ms_pragma: HandlePragmaMSPragma(); return DeclGroupPtrTy(); d861 1 a861 1 const char *PrevSpec = nullptr; d904 20 d978 1 a978 1 return nullptr; d999 2 a1000 1 Actions.canDelayFunctionBody(D)) { d1029 1 a1029 1 a1040 1 // FIXME: Should we really fall through here? d1042 1 a1042 1 d1062 2 a1063 2 Actions.ActOnFinishFunctionBody(Res, nullptr, false); d1104 1 a1104 1 Actions.ActOnFinishFunctionBody(Res, nullptr); d1380 1 a1380 1 IsAddressOfOperand, SS.isEmpty() ? CCC : nullptr); d1534 1 a1534 1 nullptr, /*IsTypename*/ true)) d1617 1 a1617 1 IdentifierInfo *CorrectedII = nullptr; d1625 2 a1626 3 /*NonTrivialTypeSourceInfo*/ true, NeedType ? &CorrectedII : nullptr)) { d1916 2 a1917 1 cutOffParsing(); @ 1.1.1.6 log @Import Clang 3.5svn r209886. @ text @d36 1 a36 1 bool HandleComment(Preprocessor &PP, SourceRange Comment) override { d59 1 a59 1 Actions.CurScope = nullptr; d62 1 a62 1 CurParsedObjCImpl = nullptr; d139 1 a139 1 const char *Spelling = nullptr; d368 2 a369 1 Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); d384 1 a384 1 : CurScope(ManageFlags ? Self->getCurScope() : nullptr) { d406 2 a407 2 Actions.CurScope = nullptr; d425 1 a425 1 assert(getCurScope() == nullptr && "A scope is already active?"); d440 4 a443 4 Ident_instancetype = nullptr; Ident_final = nullptr; Ident_sealed = nullptr; Ident_override = nullptr; d453 10 a462 12 Ident_introduced = nullptr; Ident_deprecated = nullptr; Ident_obsoleted = nullptr; Ident_unavailable = nullptr; Ident__except = nullptr; Ident__exception_code = Ident__exception_info = nullptr; Ident__abnormal_termination = Ident___exception_code = nullptr; Ident___exception_info = Ident___abnormal_termination = nullptr; Ident_GetExceptionCode = Ident_GetExceptionInfo = nullptr; Ident_AbnormalTermination = nullptr; d596 1 a596 1 Decl *SingleDecl = nullptr; a633 3 case tok::annot_pragma_ms_pragma: HandlePragmaMSPragma(); return DeclGroupPtrTy(); d861 1 a861 1 const char *PrevSpec = nullptr; d904 20 d978 1 a978 1 return nullptr; d999 2 a1000 1 Actions.canDelayFunctionBody(D)) { d1029 1 a1029 1 a1040 1 // FIXME: Should we really fall through here? d1042 1 a1042 1 d1062 2 a1063 2 Actions.ActOnFinishFunctionBody(Res, nullptr, false); d1104 1 a1104 1 Actions.ActOnFinishFunctionBody(Res, nullptr); d1380 1 a1380 1 IsAddressOfOperand, SS.isEmpty() ? CCC : nullptr); d1534 1 a1534 1 nullptr, /*IsTypename*/ true)) d1617 1 a1617 1 IdentifierInfo *CorrectedII = nullptr; d1625 2 a1626 3 /*NonTrivialTypeSourceInfo*/ true, NeedType ? &CorrectedII : nullptr)) { d1916 2 a1917 1 cutOffParsing(); @ 1.1.1.7 log @Import clang 3.6svn r215315. @ text @d112 1 a112 1 StringRef Msg) { @ 1.1.1.7.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a512 7 void Parser::LateTemplateParserCleanupCallback(void *P) { // While this RAII helper doesn't bracket any actual work, the destructor will // clean up annotations that were created during ActOnEndOfTranslationUnit // when incremental processing is enabled. DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(((Parser *)P)->TemplateIds); } d545 1 a545 4 Actions.SetLateTemplateParser(LateTemplateParserCallback, PP.isIncrementalProcessingEnabled() ? LateTemplateParserCleanupCallback : nullptr, this); d627 2 a628 1 return ParseOpenMPDeclarativeDirective(); d700 2 a701 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d711 2 a712 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d723 2 a724 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d733 2 a734 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d888 1 a888 1 return ParseDeclGroup(DS, Declarator::FileContext); d925 1 a925 1 // Poison SEH identifiers so they are flagged as illegal in function bodies. d1221 9 a1229 11 ExprResult Parser::ParseAsmStringLiteral() { if (!isTokenStringLiteral()) { Diag(Tok, diag::err_expected_string_literal) << /*Source='in...'*/0 << "'asm'"; return ExprError(); } ExprResult AsmString(ParseStringLiteralExpression()); if (!AsmString.isInvalid()) { const auto *SL = cast(AsmString.get()); if (!SL->isAscii()) { d1231 2 a1232 2 << SL->isWide() << SL->getSourceRange(); d1235 4 d1240 2 a1241 1 return AsmString; d1249 1 a1249 1 ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { d1324 1 a1324 1 std::unique_ptr CCC) { d1362 3 a1364 3 Sema::NameClassification Classification = Actions.ClassifyName( getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, SS.isEmpty() ? std::move(CCC) : nullptr); d1434 1 a1434 1 assert(Tok.isNot(tok::identifier)); d1438 5 a1442 2 if (DisableKeyword) Tok.getIdentifierInfo()->RevertTokenIDToIdentifier(); d1447 15 d1485 4 a1488 5 assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) || Tok.is(tok::kw___super)) && "Cannot be a type or scope token!"); d1697 1 a1697 2 Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super)) && "Cannot be a type or scope token!"); d1742 1 a1742 2 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction); d1759 7 d1787 1 a1787 1 Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, d1809 2 a1810 3 if (getLangOpts().CPlusPlus) ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), /*EnteringContext=*/false); d1831 1 a1831 1 Result.IsIfExists, Result.SS, @ 1.1.1.8 log @Import Clang 3.6RC1 r227398. @ text @a512 7 void Parser::LateTemplateParserCleanupCallback(void *P) { // While this RAII helper doesn't bracket any actual work, the destructor will // clean up annotations that were created during ActOnEndOfTranslationUnit // when incremental processing is enabled. DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(((Parser *)P)->TemplateIds); } d545 1 a545 4 Actions.SetLateTemplateParser(LateTemplateParserCallback, PP.isIncrementalProcessingEnabled() ? LateTemplateParserCleanupCallback : nullptr, this); d627 2 a628 1 return ParseOpenMPDeclarativeDirective(); d700 2 a701 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d711 2 a712 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d723 2 a724 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d733 2 a734 1 return ParseDeclaration(Declarator::FileContext, DeclEnd, attrs); d888 1 a888 1 return ParseDeclGroup(DS, Declarator::FileContext); d925 1 a925 1 // Poison SEH identifiers so they are flagged as illegal in function bodies. d1221 9 a1229 11 ExprResult Parser::ParseAsmStringLiteral() { if (!isTokenStringLiteral()) { Diag(Tok, diag::err_expected_string_literal) << /*Source='in...'*/0 << "'asm'"; return ExprError(); } ExprResult AsmString(ParseStringLiteralExpression()); if (!AsmString.isInvalid()) { const auto *SL = cast(AsmString.get()); if (!SL->isAscii()) { d1231 2 a1232 2 << SL->isWide() << SL->getSourceRange(); d1235 4 d1240 2 a1241 1 return AsmString; d1249 1 a1249 1 ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { d1324 1 a1324 1 std::unique_ptr CCC) { d1362 3 a1364 3 Sema::NameClassification Classification = Actions.ClassifyName( getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, SS.isEmpty() ? std::move(CCC) : nullptr); d1434 1 a1434 1 assert(Tok.isNot(tok::identifier)); d1438 5 a1442 2 if (DisableKeyword) Tok.getIdentifierInfo()->RevertTokenIDToIdentifier(); d1447 15 d1485 4 a1488 5 assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) || Tok.is(tok::kw___super)) && "Cannot be a type or scope token!"); d1697 1 a1697 2 Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super)) && "Cannot be a type or scope token!"); d1742 1 a1742 2 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction); d1759 7 d1787 1 a1787 1 Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, d1809 2 a1810 3 if (getLangOpts().CPlusPlus) ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), /*EnteringContext=*/false); d1831 1 a1831 1 Result.IsIfExists, Result.SS, @ 1.1.1.9 log @Import Clang 3.8.0rc3 r261930. @ text @a40 20 /// \brief RAIIObject to destroy the contents of a SmallVector of /// TemplateIdAnnotation pointers and clear the vector. class DestroyTemplateIdAnnotationsRAIIObj { SmallVectorImpl &Container; public: DestroyTemplateIdAnnotationsRAIIObj( SmallVectorImpl &Container) : Container(Container) {} ~DestroyTemplateIdAnnotationsRAIIObj() { for (SmallVectorImpl::iterator I = Container.begin(), E = Container.end(); I != E; ++I) (*I)->Destroy(); Container.clear(); } }; a264 1 case tok::annot_pragma_openmp: a416 9 if (getLangOpts().DelayedTemplateParsing && !PP.isIncrementalProcessingEnabled() && !TemplateIds.empty()) { // If an ASTConsumer parsed delay-parsed templates in their // HandleTranslationUnit() method, TemplateIds created there were not // guarded by a DestroyTemplateIdAnnotationsRAIIObj object in // ParseTopLevelDecl(). Destroy them here. DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); } a436 4 ObjCTypeQuals[objc_nonnull] = &PP.getIdentifierTable().get("nonnull"); ObjCTypeQuals[objc_nullable] = &PP.getIdentifierTable().get("nullable"); ObjCTypeQuals[objc_null_unspecified] = &PP.getIdentifierTable().get("null_unspecified"); d446 1 a446 4 Ident_vector = nullptr; Ident_bool = nullptr; Ident_pixel = nullptr; if (getLangOpts().AltiVec || getLangOpts().ZVector) { d448 1 a450 2 if (getLangOpts().AltiVec) Ident_pixel = &PP.getIdentifierTable().get("pixel"); d493 20 a543 5 Actions.ActOnModuleBegin(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); return false; d545 1 a545 2 Actions.ActOnModuleEnd(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); a646 3 case tok::annot_pragma_dump: HandlePragmaDump(); return DeclGroupPtrTy(); a671 1 a673 9 // Check if GNU-style InlineAsm is disabled. // Empty asm string is allowed because it will not introduce // any assembly code. if (!(getLangOpts().GNUAsm || Result.isInvalid())) { const auto *SL = cast(Result.get()); if (!SL->getString().trim().empty()) Diag(StartLoc, diag::err_gnu_inline_asm_disabled); } d1037 4 a1040 11 Sema::SkipBodyInfo SkipBody; Decl *Res = Actions.ActOnStartOfFunctionDef(getCurScope(), D, TemplateInfo.TemplateParams ? *TemplateInfo.TemplateParams : MultiTemplateParamsArg(), &SkipBody); if (SkipBody.ShouldSkip) { SkipFunctionBody(); return Res; } d1051 1 d1057 2 a1058 3 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 1 /* deleted */; d1063 2 a1064 3 ? diag::warn_cxx98_compat_defaulted_deleted_function : diag::ext_defaulted_deleted_function) << 0 /* defaulted */; a1078 2 Stmt *GeneratedBody = Res ? Res->getBody() : nullptr; Actions.ActOnFinishFunctionBody(Res, GeneratedBody, false); a1105 22 void Parser::SkipFunctionBody() { if (Tok.is(tok::equal)) { SkipUntil(tok::semi); return; } bool IsFunctionTryBlock = Tok.is(tok::kw_try); if (IsFunctionTryBlock) ConsumeToken(); CachedTokens Skipped; if (ConsumeAndStoreFunctionPrologue(Skipped)) SkipMalformedDecl(); else { SkipUntil(tok::r_brace); while (IsFunctionTryBlock && Tok.is(tok::kw_catch)) { SkipUntil(tok::l_brace); SkipUntil(tok::r_brace); } } } d1386 4 a1389 2 case Sema::NC_Type: { SourceLocation BeginLoc = NameLoc; d1391 1 a1391 23 BeginLoc = SS.getBeginLoc(); /// An Objective-C object type followed by '<' is a specialization of /// a parameterized class type or a protocol-qualified type. ParsedType Ty = Classification.getType(); if (getLangOpts().ObjC1 && NextToken().is(tok::less) && (Ty.get()->isObjCObjectType() || Ty.get()->isObjCObjectPointerType())) { // Consume the name. SourceLocation IdentifierLoc = ConsumeToken(); SourceLocation NewEndLoc; TypeResult NewType = parseObjCTypeArgsAndProtocolQualifiers(IdentifierLoc, Ty, /*consumeLastToken=*/false, NewEndLoc); if (NewType.isUsable()) Ty = NewType.get(); } Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty); Tok.setAnnotationEndLoc(Tok.getLocation()); Tok.setLocation(BeginLoc); a1393 1 } d1441 1 a1441 1 Tok.getIdentifierInfo()->revertTokenIDToIdentifier(); a1599 21 SourceLocation BeginLoc = Tok.getLocation(); if (SS.isNotEmpty()) // it was a C++ qualified type name. BeginLoc = SS.getBeginLoc(); /// An Objective-C object type followed by '<' is a specialization of /// a parameterized class type or a protocol-qualified type. if (getLangOpts().ObjC1 && NextToken().is(tok::less) && (Ty.get()->isObjCObjectType() || Ty.get()->isObjCObjectPointerType())) { // Consume the name. SourceLocation IdentifierLoc = ConsumeToken(); SourceLocation NewEndLoc; TypeResult NewType = parseObjCTypeArgsAndProtocolQualifiers(IdentifierLoc, Ty, /*consumeLastToken=*/false, NewEndLoc); if (NewType.isUsable()) Ty = NewType.get(); } d1605 2 a1606 1 Tok.setLocation(BeginLoc); a1916 31 /// \brief Try recover parser when module annotation appears where it must not /// be found. /// \returns false if the recover was successful and parsing may be continued, or /// true if parser must bail out to top level and handle the token there. bool Parser::parseMisplacedModuleImport() { while (true) { switch (Tok.getKind()) { case tok::annot_module_end: // Inform caller that recovery failed, the error must be handled at upper // level. return true; case tok::annot_module_begin: Actions.diagnoseMisplacedModuleImport(reinterpret_cast( Tok.getAnnotationValue()), Tok.getLocation()); return true; case tok::annot_module_include: // Module import found where it should not be, for instance, inside a // namespace. Recover by importing the module. Actions.ActOnModuleInclude(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); // If there is another module import, process it. continue; default: return false; } } return false; } d1944 1 a1944 4 if (P.Tok.is(tok::annot_module_end)) P.Diag(P.Tok, diag::err_missing_before_module_end) << Close; else P.Diag(P.Tok, diag::err_expected) << Close; @ 1.1.1.9.2.1 log @Sync with HEAD @ text @d23 1 d81 1 a476 1 Ident_GNU_final = nullptr; a493 2 Ident_strict = nullptr; Ident_replacement = nullptr; a537 30 bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result) { // C++ Modules TS: module-declaration must be the first declaration in the // file. (There can be no preceding preprocessor directives, but we expect // the lexer to check that.) if (Tok.is(tok::kw_module)) { Result = ParseModuleDecl(); return false; } else if (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface) { // FIXME: We avoid providing this diagnostic when generating an object file // from an existing PCM file. This is not a good way to detect this // condition; we should provide a mechanism to indicate whether we've // already parsed a declaration in this translation unit and avoid calling // ParseFirstTopLevelDecl in that case. if (Actions.TUKind == TU_Module) Diag(Tok, diag::err_expected_module_interface_decl); } // C11 6.9p1 says translation units must have at least one top-level // declaration. C++ doesn't have this restriction. We also don't want to // complain if we have a precompiled header, although technically if the PCH // is empty we should still emit the (pedantic) diagnostic. bool NoTopLevelDecls = ParseTopLevelDecl(Result); if (NoTopLevelDecls && !Actions.getASTContext().getExternalSource() && !getLangOpts().CPlusPlus) Diag(diag::ext_empty_translation_unit); return NoTopLevelDecls; } d548 1 a548 1 Result = nullptr; a553 4 case tok::kw_import: Result = ParseModuleImport(SourceLocation()); return false; d591 1 d628 1 a628 1 return nullptr; d635 1 a635 1 return nullptr; d638 1 a638 1 return nullptr; d641 1 a641 1 return nullptr; d644 1 a644 1 return nullptr; d647 1 a647 1 return nullptr; d650 1 a650 1 return nullptr; d653 1 a653 1 return nullptr; d656 1 a656 1 return nullptr; d659 3 a661 5 return nullptr; case tok::annot_pragma_openmp: { AccessSpecifier AS = AS_none; return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs); } d664 1 a664 1 return nullptr; d667 1 a667 1 return nullptr; d670 1 a670 1 return nullptr; d673 1 a673 1 return nullptr; d684 1 a684 1 return nullptr; d687 1 a687 1 return nullptr; d715 1 a715 1 return nullptr; d726 1 a726 1 return nullptr; d735 1 a735 8 return nullptr; case tok::kw_export: if (getLangOpts().ModulesTS) { SingleDecl = ParseExportDeclaration(); break; } // This must be 'export template'. Parse it so we can diagnose our lack // of support. d740 1 d799 2 a800 7 return nullptr; case tok::kw_module: Diag(Tok, diag::err_unexpected_module_decl); SkipUntil(tok::semi); return nullptr; d852 5 a856 4 /// Parse either a function-definition or a declaration. We can't tell which /// we have until we read up to the compound-statement in function-definition. /// TemplateParams, if non-NULL, provides the template parameters when we're /// parsing a C++ template-declaration. a871 1 MaybeParseMicrosoftAttributes(DS.getAttributes()); d879 1 a879 1 return nullptr; d886 1 a886 3 RecordDecl *AnonRecord = nullptr; Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS, AnonRecord); a887 6 if (getLangOpts().OpenCL) Actions.setCurrentOpenCLExtensionForDecl(TheDecl); if (AnonRecord) { Decl* decls[] = {AnonRecord, TheDecl}; return Actions.BuildDeclaratorGroup(decls); } d902 1 a902 1 return nullptr; d945 1 a945 1 a1036 6 if (SkipFunctionBodies && (!DP || Actions.canSkipFunctionBody(DP)) && trySkippingFunctionBody()) { BodyScope.Exit(); return Actions.ActOnSkippedFunctionBody(DP); } a1128 7 if (SkipFunctionBodies && (!Res || Actions.canSkipFunctionBody(Res)) && trySkippingFunctionBody()) { BodyScope.Exit(); Actions.ActOnSkippedFunctionBody(Res); return Actions.ActOnFinishFunctionBody(Res, nullptr, false); } d1403 1 a1403 1 ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext)) d1407 2 a1408 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) d1421 2 a1422 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) a1474 2 else if (Tok.is(tok::eof)) // Nothing to do here, bail out... return ANK_Error; d1558 1 a1558 1 bool Parser::TryAnnotateTypeOrScopeToken() { d1575 1 a1575 1 bool Result = TryAnnotateTypeOrScopeToken(); d1591 3 a1593 3 if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr, /*EnteringContext=*/false, nullptr, /*IsTypename*/ true)) d1600 2 a1601 1 (!TryAnnotateTypeOrScopeToken() && Tok.isAnnotation())) { d1649 1 a1649 1 setTypeAnnotation(Tok, Ty.isInvalid() ? nullptr : Ty.get()); d1661 1 a1661 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext*/false)) d1664 2 a1665 1 return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation); d1671 3 a1673 1 bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, d1676 1 d1678 13 a1690 5 if (ParsedType Ty = Actions.getTypeName( *Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS, false, NextToken().is(tok::period), nullptr, /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/ true)) { a1708 2 else if (Tok.is(tok::eof)) // Nothing to do here, bail out... return false; d1737 6 a1742 5 if (TemplateNameKind TNK = Actions.isTemplateName( getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/nullptr, /*EnteringContext*/false, Template, MemberOfUnknownSpecialization)) { d1796 1 a1796 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext)) d1900 1 a1900 1 ParseOptionalCXXScopeSpecifier(Result.SS, nullptr, d1911 2 a1912 2 if (ParseUnqualifiedId(Result.SS, false, true, true, nullptr, TemplateKWLoc, Result.Name)) { d1972 1 a1979 52 /// Parse a C++ Modules TS module declaration, which appears at the beginning /// of a module interface, module partition, or module implementation file. /// /// module-declaration: [Modules TS + P0273R0] /// 'module' module-kind[opt] module-name attribute-specifier-seq[opt] ';' /// module-kind: /// 'implementation' /// 'partition' /// /// Note that the module-kind values are context-sensitive keywords. Parser::DeclGroupPtrTy Parser::ParseModuleDecl() { assert(Tok.is(tok::kw_module) && getLangOpts().ModulesTS && "should not be parsing a module declaration"); SourceLocation ModuleLoc = ConsumeToken(); // Check for a module-kind. Sema::ModuleDeclKind MDK = Sema::ModuleDeclKind::Module; if (Tok.is(tok::identifier) && NextToken().is(tok::identifier)) { if (Tok.getIdentifierInfo()->isStr("implementation")) MDK = Sema::ModuleDeclKind::Implementation; else if (Tok.getIdentifierInfo()->isStr("partition")) MDK = Sema::ModuleDeclKind::Partition; else { Diag(Tok, diag::err_unexpected_module_kind) << Tok.getIdentifierInfo(); SkipUntil(tok::semi); return nullptr; } ConsumeToken(); } SmallVector, 2> Path; if (ParseModuleName(ModuleLoc, Path, /*IsImport*/false)) return nullptr; ParsedAttributesWithRange Attrs(AttrFactory); MaybeParseCXX11Attributes(Attrs); // We don't support any module attributes yet. ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr); ExpectAndConsumeSemi(diag::err_module_expected_semi); return Actions.ActOnModuleDecl(ModuleLoc, MDK, Path); } /// Parse a module import declaration. This is essentially the same for /// Objective-C and the C++ Modules TS, except for the leading '@@' (in ObjC) /// and the trailing optional attributes (in C++). /// /// [ObjC] @@import declaration: /// '@@' 'import' module-name ';' /// [ModTS] module-import-declaration: /// 'import' module-name attribute-specifier-seq[opt] ';' d1981 1 a1981 2 assert((AtLoc.isInvalid() ? Tok.is(tok::kw_import) : Tok.isObjCAtKeyword(tok::objc_import)) && a1983 1 SourceLocation StartLoc = AtLoc.isInvalid() ? ImportLoc : AtLoc; d1986 1 a1986 33 if (ParseModuleName(ImportLoc, Path, /*IsImport*/true)) return nullptr; ParsedAttributesWithRange Attrs(AttrFactory); MaybeParseCXX11Attributes(Attrs); // We don't support any module import attributes yet. ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr); if (PP.hadModuleLoaderFatalFailure()) { // With a fatal failure in the module loader, we abort parsing. cutOffParsing(); return nullptr; } DeclResult Import = Actions.ActOnModuleImport(StartLoc, ImportLoc, Path); ExpectAndConsumeSemi(diag::err_module_expected_semi); if (Import.isInvalid()) return nullptr; return Actions.ConvertDeclToDeclGroup(Import.get()); } /// Parse a C++ Modules TS / Objective-C module name (both forms use the same /// grammar). /// /// module-name: /// module-name-qualifier[opt] identifier /// module-name-qualifier: /// module-name-qualifier[opt] identifier '.' bool Parser::ParseModuleName( SourceLocation UseLoc, SmallVectorImpl> &Path, bool IsImport) { d1988 1 a1988 1 while (true) { d1991 1 a1991 1 Actions.CodeCompleteModuleImport(UseLoc, Path); d1993 1 a1993 1 return true; d1996 1 a1996 1 Diag(Tok, diag::err_module_expected_ident) << IsImport; d1998 1 a1998 1 return true; d2004 8 d2013 5 a2017 2 if (Tok.isNot(tok::period)) return false; d2019 6 a2024 2 ConsumeToken(); } a2034 11 // If we recovered from a misplaced module begin, we expect to hit a // misplaced module end too. Stay in the current context when this // happens. if (MisplacedModuleBeginCount) { --MisplacedModuleBeginCount; Actions.ActOnModuleEnd(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); continue; } d2036 1 a2036 2 // level. This will generate the desired "missing '}' at end of module" // diagnostics on the way out. d2039 3 a2041 7 // Recover by entering the module (Sema will diagnose). Actions.ActOnModuleBegin(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); ++MisplacedModuleBeginCount; continue; d2047 1 a2047 1 Tok.getAnnotationValue())); @ 1.1.1.10 log @Import Clang pre-4.0.0 r291444. @ text @d23 1 d81 1 a476 1 Ident_GNU_final = nullptr; a493 2 Ident_strict = nullptr; Ident_replacement = nullptr; a537 30 bool Parser::ParseFirstTopLevelDecl(DeclGroupPtrTy &Result) { // C++ Modules TS: module-declaration must be the first declaration in the // file. (There can be no preceding preprocessor directives, but we expect // the lexer to check that.) if (Tok.is(tok::kw_module)) { Result = ParseModuleDecl(); return false; } else if (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface) { // FIXME: We avoid providing this diagnostic when generating an object file // from an existing PCM file. This is not a good way to detect this // condition; we should provide a mechanism to indicate whether we've // already parsed a declaration in this translation unit and avoid calling // ParseFirstTopLevelDecl in that case. if (Actions.TUKind == TU_Module) Diag(Tok, diag::err_expected_module_interface_decl); } // C11 6.9p1 says translation units must have at least one top-level // declaration. C++ doesn't have this restriction. We also don't want to // complain if we have a precompiled header, although technically if the PCH // is empty we should still emit the (pedantic) diagnostic. bool NoTopLevelDecls = ParseTopLevelDecl(Result); if (NoTopLevelDecls && !Actions.getASTContext().getExternalSource() && !getLangOpts().CPlusPlus) Diag(diag::ext_empty_translation_unit); return NoTopLevelDecls; } d548 1 a548 1 Result = nullptr; a553 4 case tok::kw_import: Result = ParseModuleImport(SourceLocation()); return false; d591 1 d628 1 a628 1 return nullptr; d635 1 a635 1 return nullptr; d638 1 a638 1 return nullptr; d641 1 a641 1 return nullptr; d644 1 a644 1 return nullptr; d647 1 a647 1 return nullptr; d650 1 a650 1 return nullptr; d653 1 a653 1 return nullptr; d656 1 a656 1 return nullptr; d659 3 a661 5 return nullptr; case tok::annot_pragma_openmp: { AccessSpecifier AS = AS_none; return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs); } d664 1 a664 1 return nullptr; d667 1 a667 1 return nullptr; d670 1 a670 1 return nullptr; d673 1 a673 1 return nullptr; d684 1 a684 1 return nullptr; d687 1 a687 1 return nullptr; d715 1 a715 1 return nullptr; d726 1 a726 1 return nullptr; d735 1 a735 8 return nullptr; case tok::kw_export: if (getLangOpts().ModulesTS) { SingleDecl = ParseExportDeclaration(); break; } // This must be 'export template'. Parse it so we can diagnose our lack // of support. d740 1 d799 2 a800 7 return nullptr; case tok::kw_module: Diag(Tok, diag::err_unexpected_module_decl); SkipUntil(tok::semi); return nullptr; d852 5 a856 4 /// Parse either a function-definition or a declaration. We can't tell which /// we have until we read up to the compound-statement in function-definition. /// TemplateParams, if non-NULL, provides the template parameters when we're /// parsing a C++ template-declaration. a871 1 MaybeParseMicrosoftAttributes(DS.getAttributes()); d879 1 a879 1 return nullptr; d886 1 a886 3 RecordDecl *AnonRecord = nullptr; Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS, AnonRecord); a887 6 if (getLangOpts().OpenCL) Actions.setCurrentOpenCLExtensionForDecl(TheDecl); if (AnonRecord) { Decl* decls[] = {AnonRecord, TheDecl}; return Actions.BuildDeclaratorGroup(decls, /*TypeMayContainAuto=*/false); } d902 1 a902 1 return nullptr; d945 1 a945 1 a1036 6 if (SkipFunctionBodies && (!DP || Actions.canSkipFunctionBody(DP)) && trySkippingFunctionBody()) { BodyScope.Exit(); return Actions.ActOnSkippedFunctionBody(DP); } a1128 7 if (SkipFunctionBodies && (!Res || Actions.canSkipFunctionBody(Res)) && trySkippingFunctionBody()) { BodyScope.Exit(); Actions.ActOnSkippedFunctionBody(Res); return Actions.ActOnFinishFunctionBody(Res, nullptr, false); } d1403 1 a1403 1 ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext)) a1474 2 else if (Tok.is(tok::eof)) // Nothing to do here, bail out... return ANK_Error; d1591 3 a1593 3 if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr, /*EnteringContext=*/false, nullptr, /*IsTypename*/ true)) d1649 1 a1649 1 setTypeAnnotation(Tok, Ty.isInvalid() ? nullptr : Ty.get()); d1661 1 a1661 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext)) d1678 9 a1686 6 if (ParsedType Ty = Actions.getTypeName( *Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS, false, NextToken().is(tok::period), nullptr, /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/ true, NeedType ? &CorrectedII : nullptr)) { a1708 2 else if (Tok.is(tok::eof)) // Nothing to do here, bail out... return false; d1737 6 a1742 5 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/nullptr, EnteringContext, Template, MemberOfUnknownSpecialization)) { d1796 1 a1796 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext)) d1900 1 a1900 1 ParseOptionalCXXScopeSpecifier(Result.SS, nullptr, d1911 2 a1912 2 if (ParseUnqualifiedId(Result.SS, false, true, true, nullptr, TemplateKWLoc, Result.Name)) { d1972 1 a1979 52 /// Parse a C++ Modules TS module declaration, which appears at the beginning /// of a module interface, module partition, or module implementation file. /// /// module-declaration: [Modules TS + P0273R0] /// 'module' module-kind[opt] module-name attribute-specifier-seq[opt] ';' /// module-kind: /// 'implementation' /// 'partition' /// /// Note that the module-kind values are context-sensitive keywords. Parser::DeclGroupPtrTy Parser::ParseModuleDecl() { assert(Tok.is(tok::kw_module) && getLangOpts().ModulesTS && "should not be parsing a module declaration"); SourceLocation ModuleLoc = ConsumeToken(); // Check for a module-kind. Sema::ModuleDeclKind MDK = Sema::ModuleDeclKind::Module; if (Tok.is(tok::identifier) && NextToken().is(tok::identifier)) { if (Tok.getIdentifierInfo()->isStr("implementation")) MDK = Sema::ModuleDeclKind::Implementation; else if (Tok.getIdentifierInfo()->isStr("partition")) MDK = Sema::ModuleDeclKind::Partition; else { Diag(Tok, diag::err_unexpected_module_kind) << Tok.getIdentifierInfo(); SkipUntil(tok::semi); return nullptr; } ConsumeToken(); } SmallVector, 2> Path; if (ParseModuleName(ModuleLoc, Path, /*IsImport*/false)) return nullptr; ParsedAttributesWithRange Attrs(AttrFactory); MaybeParseCXX11Attributes(Attrs); // We don't support any module attributes yet. ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_module_attr); ExpectAndConsumeSemi(diag::err_module_expected_semi); return Actions.ActOnModuleDecl(ModuleLoc, MDK, Path); } /// Parse a module import declaration. This is essentially the same for /// Objective-C and the C++ Modules TS, except for the leading '@@' (in ObjC) /// and the trailing optional attributes (in C++). /// /// [ObjC] @@import declaration: /// '@@' 'import' module-name ';' /// [ModTS] module-import-declaration: /// 'import' module-name attribute-specifier-seq[opt] ';' d1981 1 a1981 2 assert((AtLoc.isInvalid() ? Tok.is(tok::kw_import) : Tok.isObjCAtKeyword(tok::objc_import)) && a1983 1 SourceLocation StartLoc = AtLoc.isInvalid() ? ImportLoc : AtLoc; d1986 1 a1986 33 if (ParseModuleName(ImportLoc, Path, /*IsImport*/true)) return nullptr; ParsedAttributesWithRange Attrs(AttrFactory); MaybeParseCXX11Attributes(Attrs); // We don't support any module import attributes yet. ProhibitCXX11Attributes(Attrs, diag::err_attribute_not_import_attr); if (PP.hadModuleLoaderFatalFailure()) { // With a fatal failure in the module loader, we abort parsing. cutOffParsing(); return nullptr; } DeclResult Import = Actions.ActOnModuleImport(StartLoc, ImportLoc, Path); ExpectAndConsumeSemi(diag::err_module_expected_semi); if (Import.isInvalid()) return nullptr; return Actions.ConvertDeclToDeclGroup(Import.get()); } /// Parse a C++ Modules TS / Objective-C module name (both forms use the same /// grammar). /// /// module-name: /// module-name-qualifier[opt] identifier /// module-name-qualifier: /// module-name-qualifier[opt] identifier '.' bool Parser::ParseModuleName( SourceLocation UseLoc, SmallVectorImpl> &Path, bool IsImport) { d1988 1 a1988 1 while (true) { d1991 1 a1991 1 Actions.CodeCompleteModuleImport(UseLoc, Path); d1993 1 a1993 1 return true; d1996 1 a1996 1 Diag(Tok, diag::err_module_expected_ident) << IsImport; d1998 1 a1998 1 return true; d2004 8 d2013 5 a2017 2 if (Tok.isNot(tok::period)) return false; d2019 6 a2024 2 ConsumeToken(); } a2034 11 // If we recovered from a misplaced module begin, we expect to hit a // misplaced module end too. Stay in the current context when this // happens. if (MisplacedModuleBeginCount) { --MisplacedModuleBeginCount; Actions.ActOnModuleEnd(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); continue; } d2036 1 a2036 2 // level. This will generate the desired "missing '}' at end of module" // diagnostics on the way out. d2039 3 a2041 7 // Recover by entering the module (Sema will diagnose). Actions.ActOnModuleBegin(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); ++MisplacedModuleBeginCount; continue; d2047 1 a2047 1 Tok.getAnnotationValue())); @ 1.1.1.10.2.1 log @Sync with HEAD @ text @d941 1 a941 1 return Actions.BuildDeclaratorGroup(decls); d1475 2 a1476 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) d1489 2 a1490 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) d1628 1 a1628 1 bool Parser::TryAnnotateTypeOrScopeToken() { d1645 1 a1645 1 bool Result = TryAnnotateTypeOrScopeToken(); d1670 2 a1671 1 (!TryAnnotateTypeOrScopeToken() && Tok.isAnnotation())) { d1731 1 a1731 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext*/false)) d1734 2 a1735 1 return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation); d1741 3 a1743 1 bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, d1746 1 d1752 6 a1757 1 /*NonTrivialTypeSourceInfo*/ true)) { d1806 5 a1810 5 if (TemplateNameKind TNK = Actions.isTemplateName( getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/nullptr, /*EnteringContext*/false, Template, MemberOfUnknownSpecialization)) { @ 1.1.1.11 log @Import Clang 4.0RC1 r294123. @ text @d941 1 a941 1 return Actions.BuildDeclaratorGroup(decls); d1475 2 a1476 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) d1489 2 a1490 1 if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation)) d1628 1 a1628 1 bool Parser::TryAnnotateTypeOrScopeToken() { d1645 1 a1645 1 bool Result = TryAnnotateTypeOrScopeToken(); d1670 2 a1671 1 (!TryAnnotateTypeOrScopeToken() && Tok.isAnnotation())) { d1731 1 a1731 1 if (ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext*/false)) d1734 2 a1735 1 return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation); d1741 3 a1743 1 bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, d1746 1 d1752 6 a1757 1 /*NonTrivialTypeSourceInfo*/ true)) { d1806 5 a1810 5 if (TemplateNameKind TNK = Actions.isTemplateName( getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/nullptr, /*EnteringContext*/false, Template, MemberOfUnknownSpecialization)) { @ 1.1.1.12 log @Import clang r309604 from branches/release_50 @ text @d15 1 a19 1 #include "clang/Parse/RAIIObjectsForParser.h" d40 20 a233 15 bool Parser::expectIdentifier() { if (Tok.is(tok::identifier)) return false; if (const auto *II = Tok.getIdentifierInfo()) { if (II->isCPlusPlusKeyword(getLangOpts())) { Diag(Tok, diag::err_expected_token_instead_of_objcxx_keyword) << tok::identifier << Tok.getIdentifierInfo(); // Objective-C++: Recover by treating this keyword as a valid identifier. return false; } } Diag(Tok, diag::err_expected) << tok::identifier; return true; } d345 8 d359 1 a359 1 ConsumeAnyToken(); a495 2 Ident_language = Ident_defined_in = Ident_generated_declaration = nullptr; a529 2 PP.replayPreambleConditionalStack(); d540 16 a555 1 Actions.ActOnStartOfTranslationUnit(); a588 8 case tok::kw_export: if (NextToken().isNot(tok::kw_module)) break; LLVM_FALLTHROUGH; case tok::kw_module: Result = ParseModuleDecl(); return false; d593 1 a593 1 ConsumeAnnotationToken(); d599 1 a599 1 ConsumeAnnotationToken(); d605 1 a605 5 ConsumeAnnotationToken(); return false; case tok::annot_pragma_attribute: HandlePragmaAttribute(); a690 3 case tok::annot_pragma_fp: HandlePragmaFP(); break; a778 1 LLVM_FALLTHROUGH; a849 4 if (Tok.isEditorPlaceholder()) { ConsumeToken(); return nullptr; } a1677 2 if (Tok.isEditorPlaceholder()) return true; a1703 1 TemplateId->Name, d1745 1 a1745 2 /*NonTrivialTypeSourceInfo*/ true, /*IsClassTemplateDeductionContext*/GreaterThanIsOperator)) { a1882 1 LLVM_FALLTHROUGH; d1967 2 a1968 4 if (ParseUnqualifiedId( Result.SS, /*EnteringContext*/false, /*AllowDestructorName*/true, /*AllowConstructorName*/true, /*AllowDeductionGuide*/false, nullptr, TemplateKWLoc, Result.Name)) { d2038 5 a2042 3 /// module-declaration: [Modules TS + P0273R0 + P0629R0] /// 'export'[opt] 'module' 'partition'[opt] /// module-name attribute-specifier-seq[opt] ';' d2044 1 a2044 1 /// Note that 'partition' is a context-sensitive keyword. d2046 2 a2047 7 SourceLocation StartLoc = Tok.getLocation(); Sema::ModuleDeclKind MDK = TryConsumeToken(tok::kw_export) ? Sema::ModuleDeclKind::Module : Sema::ModuleDeclKind::Implementation; assert(Tok.is(tok::kw_module) && "not a module declaration"); d2050 12 a2061 7 if (Tok.is(tok::identifier) && NextToken().is(tok::identifier) && Tok.getIdentifierInfo()->isStr("partition")) { // If 'partition' is present, this must be a module interface unit. if (MDK != Sema::ModuleDeclKind::Module) Diag(Tok.getLocation(), diag::err_module_implementation_partition) << FixItHint::CreateInsertion(ModuleLoc, "export "); MDK = Sema::ModuleDeclKind::Partition; a2068 1 // We don't support any module attributes yet; just parse them and diagnose. d2071 1 d2076 1 a2076 1 return Actions.ActOnModuleDecl(StartLoc, ModuleLoc, MDK, Path); d2169 1 a2169 1 ConsumeAnnotationToken(); d2181 1 a2181 1 ConsumeAnnotationToken(); d2190 1 a2190 1 ConsumeAnnotationToken(); @ 1.1.1.13 log @Import clang r319952 from branches/release_50 @ text @d519 2 @ 1.1.1.13.4.1 log @Sync with HEAD @ text @a22 1 #include "llvm/Support/Path.h" d27 1 a27 1 /// A comment handler that passes comments found by the preprocessor d80 1 a80 1 /// Emits a diagnostic suggesting parentheses surrounding a d559 4 a639 3 /// /// [Modules-TS] module-import-declaration /// d701 3 a703 2 SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs, Tok.getLocation()); d745 1 a745 1 return ParseObjCAtDirectives(attrs); d756 3 a758 9 if (CurParsedObjCImpl) { // Code-complete Objective-C methods even without leading '-'/'+' prefix. Actions.CodeCompleteObjCMethodDecl(getCurScope(), /*IsInstanceMethod=*/None, /*ReturnType=*/nullptr); } Actions.CodeCompleteOrdinaryName( getCurScope(), CurParsedObjCImpl ? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); a760 3 case tok::kw_import: SingleDecl = ParseModuleImport(SourceLocation()); break; d778 1 a778 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d788 1 a788 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d799 1 a799 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d808 1 a808 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d823 2 a824 2 ParseExplicitInstantiation(DeclaratorContext::FileContext, ExternLoc, TemplateLoc, DeclEnd, attrs)); d853 1 a853 1 /// Determine whether the current token, if it occurs after a d872 1 a872 1 /// Determine whether the current token, if it occurs after a d914 1 a914 2 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DeclSpecContext::DSC_top_level); d918 2 a919 2 if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition( DS, AS, DeclSpecContext::DSC_top_level)) d925 1 a925 25 auto LengthOfTSTToken = [](DeclSpec::TST TKind) { assert(DeclSpec::isDeclRep(TKind)); switch(TKind) { case DeclSpec::TST_class: return 5; case DeclSpec::TST_struct: return 6; case DeclSpec::TST_union: return 5; case DeclSpec::TST_enum: return 4; case DeclSpec::TST_interface: return 9; default: llvm_unreachable("we only expect to get the length of the class/struct/union/enum"); } }; // Suggest correct location to fix '[[attrib]] struct' to 'struct [[attrib]]' SourceLocation CorrectLocationForAttributes = DeclSpec::isDeclRep(DS.getTypeSpecType()) ? DS.getTypeSpecTypeLoc().getLocWithOffset( LengthOfTSTToken(DS.getTypeSpecType())) : SourceLocation(); ProhibitAttributes(attrs, CorrectLocationForAttributes); d975 1 a975 1 Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::FileContext); d979 1 a979 1 return ParseDeclGroup(DS, DeclaratorContext::FileContext); d1059 9 a1067 4 for (const ParsedAttr &AL : D.getAttributes()) if (AL.isKnownToGCC() && !AL.isCXX11Attribute()) Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL.getName(); d1076 2 a1077 3 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1107 1 a1107 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1125 1 a1125 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1281 1 a1281 1 Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeListContext); d1418 1 a1418 1 /// Get the TemplateIdAnnotation from the token and put it in the d1446 1 a1446 1 /// Attempt to classify the name at the current token position. This may d1731 1 a1731 1 /// Try to annotate a type or scope token, having already parsed an d1742 2 a1743 2 /*NonTrivialTypeSourceInfo*/true, /*IsClassTemplateDeductionContext*/true)) { d1969 1 a1969 1 &TemplateKWLoc, Result.Name)) { d2048 1 a2048 1 ? Sema::ModuleDeclKind::Interface d2057 1 a2057 1 if (MDK != Sema::ModuleDeclKind::Interface) d2086 1 a2086 1 Decl *Parser::ParseModuleImport(SourceLocation AtLoc) { a2089 1 bool IsObjCAtImport = Tok.isObjCAtKeyword(tok::objc_import); d2113 1 a2113 11 // Using '@@import' in framework headers requires modules to be enabled so that // the header is parseable. Emit a warning to make the user aware. if (IsObjCAtImport && AtLoc.isValid()) { auto &SrcMgr = PP.getSourceManager(); auto *FE = SrcMgr.getFileEntryForID(SrcMgr.getFileID(AtLoc)); if (FE && llvm::sys::path::parent_path(FE->getDir()->getName()) .endswith(".framework")) Diags.Report(AtLoc, diag::warn_atimport_in_framework_header); } return Import.get(); d2152 1 a2152 1 /// Try recover parser when module annotation appears where it must not d2217 1 a2217 1 if (getDepth() < P.getLangOpts().BracketDepth) @ 1.1.1.13.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.13.2.1 log @Sync with HEAD @ text @a22 1 #include "llvm/Support/Path.h" d27 1 a27 1 /// A comment handler that passes comments found by the preprocessor d80 1 a80 1 /// Emits a diagnostic suggesting parentheses surrounding a d559 4 a639 3 /// /// [Modules-TS] module-import-declaration /// d701 3 a703 2 SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs, Tok.getLocation()); d745 1 a745 1 return ParseObjCAtDirectives(attrs); d756 3 a758 9 if (CurParsedObjCImpl) { // Code-complete Objective-C methods even without leading '-'/'+' prefix. Actions.CodeCompleteObjCMethodDecl(getCurScope(), /*IsInstanceMethod=*/None, /*ReturnType=*/nullptr); } Actions.CodeCompleteOrdinaryName( getCurScope(), CurParsedObjCImpl ? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); a760 3 case tok::kw_import: SingleDecl = ParseModuleImport(SourceLocation()); break; d778 1 a778 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d788 1 a788 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d799 1 a799 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d808 1 a808 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d823 2 a824 2 ParseExplicitInstantiation(DeclaratorContext::FileContext, ExternLoc, TemplateLoc, DeclEnd, attrs)); d853 1 a853 1 /// Determine whether the current token, if it occurs after a d872 1 a872 1 /// Determine whether the current token, if it occurs after a d914 1 a914 2 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DeclSpecContext::DSC_top_level); d918 2 a919 2 if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition( DS, AS, DeclSpecContext::DSC_top_level)) d925 1 a925 25 auto LengthOfTSTToken = [](DeclSpec::TST TKind) { assert(DeclSpec::isDeclRep(TKind)); switch(TKind) { case DeclSpec::TST_class: return 5; case DeclSpec::TST_struct: return 6; case DeclSpec::TST_union: return 5; case DeclSpec::TST_enum: return 4; case DeclSpec::TST_interface: return 9; default: llvm_unreachable("we only expect to get the length of the class/struct/union/enum"); } }; // Suggest correct location to fix '[[attrib]] struct' to 'struct [[attrib]]' SourceLocation CorrectLocationForAttributes = DeclSpec::isDeclRep(DS.getTypeSpecType()) ? DS.getTypeSpecTypeLoc().getLocWithOffset( LengthOfTSTToken(DS.getTypeSpecType())) : SourceLocation(); ProhibitAttributes(attrs, CorrectLocationForAttributes); d975 1 a975 1 Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::FileContext); d979 1 a979 1 return ParseDeclGroup(DS, DeclaratorContext::FileContext); d1059 9 a1067 4 for (const ParsedAttr &AL : D.getAttributes()) if (AL.isKnownToGCC() && !AL.isCXX11Attribute()) Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL.getName(); d1076 2 a1077 3 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1107 1 a1107 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1125 1 a1125 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1281 1 a1281 1 Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeListContext); d1418 1 a1418 1 /// Get the TemplateIdAnnotation from the token and put it in the d1446 1 a1446 1 /// Attempt to classify the name at the current token position. This may d1731 1 a1731 1 /// Try to annotate a type or scope token, having already parsed an d1742 2 a1743 2 /*NonTrivialTypeSourceInfo*/true, /*IsClassTemplateDeductionContext*/true)) { d1969 1 a1969 1 &TemplateKWLoc, Result.Name)) { d2048 1 a2048 1 ? Sema::ModuleDeclKind::Interface d2057 1 a2057 1 if (MDK != Sema::ModuleDeclKind::Interface) d2086 1 a2086 1 Decl *Parser::ParseModuleImport(SourceLocation AtLoc) { a2089 1 bool IsObjCAtImport = Tok.isObjCAtKeyword(tok::objc_import); d2113 1 a2113 11 // Using '@@import' in framework headers requires modules to be enabled so that // the header is parseable. Emit a warning to make the user aware. if (IsObjCAtImport && AtLoc.isValid()) { auto &SrcMgr = PP.getSourceManager(); auto *FE = SrcMgr.getFileEntryForID(SrcMgr.getFileID(AtLoc)); if (FE && llvm::sys::path::parent_path(FE->getDir()->getName()) .endswith(".framework")) Diags.Report(AtLoc, diag::warn_atimport_in_framework_header); } return Import.get(); d2152 1 a2152 1 /// Try recover parser when module annotation appears where it must not d2217 1 a2217 1 if (getDepth() < P.getLangOpts().BracketDepth) @ 1.1.1.14 log @Import clang r337282 from trunk @ text @a22 1 #include "llvm/Support/Path.h" d27 1 a27 1 /// A comment handler that passes comments found by the preprocessor d80 1 a80 1 /// Emits a diagnostic suggesting parentheses surrounding a d559 4 a639 3 /// /// [Modules-TS] module-import-declaration /// d701 3 a703 2 SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs, Tok.getLocation()); d745 1 a745 1 return ParseObjCAtDirectives(attrs); d756 3 a758 9 if (CurParsedObjCImpl) { // Code-complete Objective-C methods even without leading '-'/'+' prefix. Actions.CodeCompleteObjCMethodDecl(getCurScope(), /*IsInstanceMethod=*/None, /*ReturnType=*/nullptr); } Actions.CodeCompleteOrdinaryName( getCurScope(), CurParsedObjCImpl ? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); a760 3 case tok::kw_import: SingleDecl = ParseModuleImport(SourceLocation()); break; d778 1 a778 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d788 1 a788 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d799 1 a799 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d808 1 a808 1 return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs); d823 2 a824 2 ParseExplicitInstantiation(DeclaratorContext::FileContext, ExternLoc, TemplateLoc, DeclEnd, attrs)); d853 1 a853 1 /// Determine whether the current token, if it occurs after a d872 1 a872 1 /// Determine whether the current token, if it occurs after a d914 1 a914 2 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DeclSpecContext::DSC_top_level); d918 2 a919 2 if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition( DS, AS, DeclSpecContext::DSC_top_level)) d925 1 a925 25 auto LengthOfTSTToken = [](DeclSpec::TST TKind) { assert(DeclSpec::isDeclRep(TKind)); switch(TKind) { case DeclSpec::TST_class: return 5; case DeclSpec::TST_struct: return 6; case DeclSpec::TST_union: return 5; case DeclSpec::TST_enum: return 4; case DeclSpec::TST_interface: return 9; default: llvm_unreachable("we only expect to get the length of the class/struct/union/enum"); } }; // Suggest correct location to fix '[[attrib]] struct' to 'struct [[attrib]]' SourceLocation CorrectLocationForAttributes = DeclSpec::isDeclRep(DS.getTypeSpecType()) ? DS.getTypeSpecTypeLoc().getLocWithOffset( LengthOfTSTToken(DS.getTypeSpecType())) : SourceLocation(); ProhibitAttributes(attrs, CorrectLocationForAttributes); d975 1 a975 1 Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::FileContext); d979 1 a979 1 return ParseDeclGroup(DS, DeclaratorContext::FileContext); d1059 9 a1067 4 for (const ParsedAttr &AL : D.getAttributes()) if (AL.isKnownToGCC() && !AL.isCXX11Attribute()) Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL.getName(); d1076 2 a1077 3 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1107 1 a1107 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1125 1 a1125 2 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1281 1 a1281 1 Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeListContext); d1418 1 a1418 1 /// Get the TemplateIdAnnotation from the token and put it in the d1446 1 a1446 1 /// Attempt to classify the name at the current token position. This may d1731 1 a1731 1 /// Try to annotate a type or scope token, having already parsed an d1742 2 a1743 2 /*NonTrivialTypeSourceInfo*/true, /*IsClassTemplateDeductionContext*/true)) { d1969 1 a1969 1 &TemplateKWLoc, Result.Name)) { d2048 1 a2048 1 ? Sema::ModuleDeclKind::Interface d2057 1 a2057 1 if (MDK != Sema::ModuleDeclKind::Interface) d2086 1 a2086 1 Decl *Parser::ParseModuleImport(SourceLocation AtLoc) { a2089 1 bool IsObjCAtImport = Tok.isObjCAtKeyword(tok::objc_import); d2113 1 a2113 11 // Using '@@import' in framework headers requires modules to be enabled so that // the header is parseable. Emit a warning to make the user aware. if (IsObjCAtImport && AtLoc.isValid()) { auto &SrcMgr = PP.getSourceManager(); auto *FE = SrcMgr.getFileEntryForID(SrcMgr.getFileID(AtLoc)); if (FE && llvm::sys::path::parent_path(FE->getDir()->getName()) .endswith(".framework")) Diags.Report(AtLoc, diag::warn_atimport_in_framework_header); } return Import.get(); d2152 1 a2152 1 /// Try recover parser when module annotation appears where it must not d2217 1 a2217 1 if (getDepth() < P.getLangOpts().BracketDepth) @ 1.1.1.15 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.7.4.1 log @file Parser.cpp was added on branch tls-maxphys on 2014-08-19 23:47:29 +0000 @ text @d1 1980 @ 1.1.1.7.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1980 //===--- Parser.cpp - C Language Family Parser ----------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the Parser interfaces. // //===----------------------------------------------------------------------===// #include "clang/Parse/Parser.h" #include "RAIIObjectsForParser.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclTemplate.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "llvm/Support/raw_ostream.h" using namespace clang; namespace { /// \brief A comment handler that passes comments found by the preprocessor /// to the parser action. class ActionCommentHandler : public CommentHandler { Sema &S; public: explicit ActionCommentHandler(Sema &S) : S(S) { } bool HandleComment(Preprocessor &PP, SourceRange Comment) override { S.ActOnComment(Comment); return false; } }; } // end anonymous namespace IdentifierInfo *Parser::getSEHExceptKeyword() { // __except is accepted as a (contextual) keyword if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland)) Ident__except = PP.getIdentifierInfo("__except"); return Ident__except; } Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies) : PP(pp), Actions(actions), Diags(PP.getDiagnostics()), GreaterThanIsOperator(true), ColonIsSacred(false), InMessageExpression(false), TemplateParameterDepth(0), ParsingInObjCContainer(false) { SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies; Tok.startToken(); Tok.setKind(tok::eof); Actions.CurScope = nullptr; NumCachedScopes = 0; ParenCount = BracketCount = BraceCount = 0; CurParsedObjCImpl = nullptr; // Add #pragma handlers. These are removed and destroyed in the // destructor. initializePragmaHandlers(); CommentSemaHandler.reset(new ActionCommentHandler(actions)); PP.addCommentHandler(CommentSemaHandler.get()); PP.setCodeCompletionHandler(*this); } DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) { return Diags.Report(Loc, DiagID); } DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) { return Diag(Tok.getLocation(), DiagID); } /// \brief Emits a diagnostic suggesting parentheses surrounding a /// given range. /// /// \param Loc The location where we'll emit the diagnostic. /// \param DK The kind of diagnostic to emit. /// \param ParenRange Source range enclosing code that should be parenthesized. void Parser::SuggestParentheses(SourceLocation Loc, unsigned DK, SourceRange ParenRange) { SourceLocation EndLoc = PP.getLocForEndOfToken(ParenRange.getEnd()); if (!ParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { // We can't display the parentheses, so just dig the // warning/error and return. Diag(Loc, DK); return; } Diag(Loc, DK) << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") << FixItHint::CreateInsertion(EndLoc, ")"); } static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok) { switch (ExpectedTok) { case tok::semi: return Tok.is(tok::colon) || Tok.is(tok::comma); // : or , for ; default: return false; } } bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID, StringRef Msg) { if (Tok.is(ExpectedTok) || Tok.is(tok::code_completion)) { ConsumeAnyToken(); return false; } // Detect common single-character typos and resume. if (IsCommonTypo(ExpectedTok, Tok)) { SourceLocation Loc = Tok.getLocation(); { DiagnosticBuilder DB = Diag(Loc, DiagID); DB << FixItHint::CreateReplacement( SourceRange(Loc), tok::getPunctuatorSpelling(ExpectedTok)); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; } // Pretend there wasn't a problem. ConsumeAnyToken(); return false; } SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); const char *Spelling = nullptr; if (EndLoc.isValid()) Spelling = tok::getPunctuatorSpelling(ExpectedTok); DiagnosticBuilder DB = Spelling ? Diag(EndLoc, DiagID) << FixItHint::CreateInsertion(EndLoc, Spelling) : Diag(Tok, DiagID); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; return true; } bool Parser::ExpectAndConsumeSemi(unsigned DiagID) { if (TryConsumeToken(tok::semi)) return false; if (Tok.is(tok::code_completion)) { handleUnexpectedCodeCompletionToken(); return false; } if ((Tok.is(tok::r_paren) || Tok.is(tok::r_square)) && NextToken().is(tok::semi)) { Diag(Tok, diag::err_extraneous_token_before_semi) << PP.getSpelling(Tok) << FixItHint::CreateRemoval(Tok.getLocation()); ConsumeAnyToken(); // The ')' or ']'. ConsumeToken(); // The ';'. return false; } return ExpectAndConsume(tok::semi, DiagID); } void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST) { if (!Tok.is(tok::semi)) return; bool HadMultipleSemis = false; SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc = Tok.getLocation(); ConsumeToken(); while ((Tok.is(tok::semi) && !Tok.isAtStartOfLine())) { HadMultipleSemis = true; EndLoc = Tok.getLocation(); ConsumeToken(); } // C++11 allows extra semicolons at namespace scope, but not in any of the // other contexts. if (Kind == OutsideFunction && getLangOpts().CPlusPlus) { if (getLangOpts().CPlusPlus11) Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else Diag(StartLoc, diag::ext_extra_semi_cxx11) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); return; } if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis) Diag(StartLoc, diag::ext_extra_semi) << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST, Actions.getASTContext().getPrintingPolicy()) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else // A single semicolon is valid after a member function definition. Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); } //===----------------------------------------------------------------------===// // Error recovery. //===----------------------------------------------------------------------===// static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R) { return (static_cast(L) & static_cast(R)) != 0; } /// SkipUntil - Read tokens until we get to the specified token, then consume /// it (unless no flag StopBeforeMatch). Because we cannot guarantee that the /// token will ever occur, this skips to the next token, or to some likely /// good stopping point. If StopAtSemi is true, skipping will stop at a ';' /// character. /// /// If SkipUntil finds the specified token, it returns true, otherwise it /// returns false. bool Parser::SkipUntil(ArrayRef Toks, SkipUntilFlags Flags) { // We always want this function to skip at least one token if the first token // isn't T and if not at EOF. bool isFirstTokenSkipped = true; while (1) { // If we found one of the tokens, stop and return true. for (unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) { if (Tok.is(Toks[i])) { if (HasFlagsSet(Flags, StopBeforeMatch)) { // Noop, don't consume the token. } else { ConsumeAnyToken(); } return true; } } // Important special case: The caller has given up and just wants us to // skip the rest of the file. Do this without recursing, since we can // get here precisely because the caller detected too much recursion. if (Toks.size() == 1 && Toks[0] == tok::eof && !HasFlagsSet(Flags, StopAtSemi) && !HasFlagsSet(Flags, StopAtCodeCompletion)) { while (Tok.isNot(tok::eof)) ConsumeAnyToken(); return true; } switch (Tok.getKind()) { case tok::eof: // Ran out of tokens. return false; case tok::annot_pragma_openmp_end: // Stop before an OpenMP pragma boundary. case tok::annot_module_begin: case tok::annot_module_end: case tok::annot_module_include: // Stop before we change submodules. They generally indicate a "good" // place to pick up parsing again (except in the special case where // we're trying to skip to EOF). return false; case tok::code_completion: if (!HasFlagsSet(Flags, StopAtCodeCompletion)) handleUnexpectedCodeCompletionToken(); return false; case tok::l_paren: // Recursively skip properly-nested parens. ConsumeParen(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_paren, StopAtCodeCompletion); else SkipUntil(tok::r_paren); break; case tok::l_square: // Recursively skip properly-nested square brackets. ConsumeBracket(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_square, StopAtCodeCompletion); else SkipUntil(tok::r_square); break; case tok::l_brace: // Recursively skip properly-nested braces. ConsumeBrace(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_brace, StopAtCodeCompletion); else SkipUntil(tok::r_brace); break; // Okay, we found a ']' or '}' or ')', which we think should be balanced. // Since the user wasn't looking for this token (if they were, it would // already be handled), this isn't balanced. If there is a LHS token at a // higher level, we will assume that this matches the unbalanced token // and return it. Otherwise, this is a spurious RHS token, which we skip. case tok::r_paren: if (ParenCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeParen(); break; case tok::r_square: if (BracketCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBracket(); break; case tok::r_brace: if (BraceCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBrace(); break; case tok::string_literal: case tok::wide_string_literal: case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: ConsumeStringToken(); break; case tok::semi: if (HasFlagsSet(Flags, StopAtSemi)) return false; // FALL THROUGH. default: // Skip this token. ConsumeToken(); break; } isFirstTokenSkipped = false; } } //===----------------------------------------------------------------------===// // Scope manipulation //===----------------------------------------------------------------------===// /// EnterScope - Start a new scope. void Parser::EnterScope(unsigned ScopeFlags) { if (NumCachedScopes) { Scope *N = ScopeCache[--NumCachedScopes]; N->Init(getCurScope(), ScopeFlags); Actions.CurScope = N; } else { Actions.CurScope = new Scope(getCurScope(), ScopeFlags, Diags); } } /// ExitScope - Pop a scope off the scope stack. void Parser::ExitScope() { assert(getCurScope() && "Scope imbalance!"); // Inform the actions module that this scope is going away if there are any // decls in it. Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); Scope *OldScope = getCurScope(); Actions.CurScope = OldScope->getParent(); if (NumCachedScopes == ScopeCacheSize) delete OldScope; else ScopeCache[NumCachedScopes++] = OldScope; } /// Set the flags for the current scope to ScopeFlags. If ManageFlags is false, /// this object does nothing. Parser::ParseScopeFlags::ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags) : CurScope(ManageFlags ? Self->getCurScope() : nullptr) { if (CurScope) { OldFlags = CurScope->getFlags(); CurScope->setFlags(ScopeFlags); } } /// Restore the flags for the current scope to what they were before this /// object overrode them. Parser::ParseScopeFlags::~ParseScopeFlags() { if (CurScope) CurScope->setFlags(OldFlags); } //===----------------------------------------------------------------------===// // C99 6.9: External Definitions. //===----------------------------------------------------------------------===// Parser::~Parser() { // If we still have scopes active, delete the scope tree. delete getCurScope(); Actions.CurScope = nullptr; // Free the scope cache. for (unsigned i = 0, e = NumCachedScopes; i != e; ++i) delete ScopeCache[i]; resetPragmaHandlers(); PP.removeCommentHandler(CommentSemaHandler.get()); PP.clearCodeCompletionHandler(); assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?"); } /// Initialize - Warm up the parser. /// void Parser::Initialize() { // Create the translation unit scope. Install it as the current scope. assert(getCurScope() == nullptr && "A scope is already active?"); EnterScope(Scope::DeclScope); Actions.ActOnTranslationUnitScope(getCurScope()); // Initialization for Objective-C context sensitive keywords recognition. // Referenced in Parser::ParseObjCTypeQualifierList. if (getLangOpts().ObjC1) { ObjCTypeQuals[objc_in] = &PP.getIdentifierTable().get("in"); ObjCTypeQuals[objc_out] = &PP.getIdentifierTable().get("out"); ObjCTypeQuals[objc_inout] = &PP.getIdentifierTable().get("inout"); ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway"); ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy"); ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref"); } Ident_instancetype = nullptr; Ident_final = nullptr; Ident_sealed = nullptr; Ident_override = nullptr; Ident_super = &PP.getIdentifierTable().get("super"); if (getLangOpts().AltiVec) { Ident_vector = &PP.getIdentifierTable().get("vector"); Ident_pixel = &PP.getIdentifierTable().get("pixel"); Ident_bool = &PP.getIdentifierTable().get("bool"); } Ident_introduced = nullptr; Ident_deprecated = nullptr; Ident_obsoleted = nullptr; Ident_unavailable = nullptr; Ident__except = nullptr; Ident__exception_code = Ident__exception_info = nullptr; Ident__abnormal_termination = Ident___exception_code = nullptr; Ident___exception_info = Ident___abnormal_termination = nullptr; Ident_GetExceptionCode = Ident_GetExceptionInfo = nullptr; Ident_AbnormalTermination = nullptr; if(getLangOpts().Borland) { Ident__exception_info = PP.getIdentifierInfo("_exception_info"); Ident___exception_info = PP.getIdentifierInfo("__exception_info"); Ident_GetExceptionInfo = PP.getIdentifierInfo("GetExceptionInformation"); Ident__exception_code = PP.getIdentifierInfo("_exception_code"); Ident___exception_code = PP.getIdentifierInfo("__exception_code"); Ident_GetExceptionCode = PP.getIdentifierInfo("GetExceptionCode"); Ident__abnormal_termination = PP.getIdentifierInfo("_abnormal_termination"); Ident___abnormal_termination = PP.getIdentifierInfo("__abnormal_termination"); Ident_AbnormalTermination = PP.getIdentifierInfo("AbnormalTermination"); PP.SetPoisonReason(Ident__exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident___exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block); PP.SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter); PP.SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block); } Actions.Initialize(); // Prime the lexer look-ahead. ConsumeToken(); } namespace { /// \brief RAIIObject to destroy the contents of a SmallVector of /// TemplateIdAnnotation pointers and clear the vector. class DestroyTemplateIdAnnotationsRAIIObj { SmallVectorImpl &Container; public: DestroyTemplateIdAnnotationsRAIIObj(SmallVectorImpl &Container) : Container(Container) {} ~DestroyTemplateIdAnnotationsRAIIObj() { for (SmallVectorImpl::iterator I = Container.begin(), E = Container.end(); I != E; ++I) (*I)->Destroy(); Container.clear(); } }; } /// ParseTopLevelDecl - Parse one top-level declaration, return whatever the /// action tells us to. This returns true if the EOF was encountered. bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); // Skip over the EOF token, flagging end of previous input for incremental // processing if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof)) ConsumeToken(); Result = DeclGroupPtrTy(); switch (Tok.getKind()) { case tok::annot_pragma_unused: HandlePragmaUnused(); return false; case tok::annot_module_include: Actions.ActOnModuleInclude(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); return false; case tok::annot_module_begin: case tok::annot_module_end: // FIXME: Update visibility based on the submodule we're in. ConsumeToken(); return false; case tok::eof: // Late template parsing can begin. if (getLangOpts().DelayedTemplateParsing) Actions.SetLateTemplateParser(LateTemplateParserCallback, this); if (!PP.isIncrementalProcessingEnabled()) Actions.ActOnEndOfTranslationUnit(); //else don't tell Sema that we ended parsing: more input might come. return true; default: break; } ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); Result = ParseExternalDeclaration(attrs); return false; } /// ParseExternalDeclaration: /// /// external-declaration: [C99 6.9], declaration: [C++ dcl.dcl] /// function-definition /// declaration /// [GNU] asm-definition /// [GNU] __extension__ external-declaration /// [OBJC] objc-class-definition /// [OBJC] objc-class-declaration /// [OBJC] objc-alias-declaration /// [OBJC] objc-protocol-definition /// [OBJC] objc-method-definition /// [OBJC] @@end /// [C++] linkage-specification /// [GNU] asm-definition: /// simple-asm-expr ';' /// [C++11] empty-declaration /// [C++11] attribute-declaration /// /// [C++11] empty-declaration: /// ';' /// /// [C++0x/GNU] 'extern' 'template' declaration Parser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); ParenBraceBracketBalancer BalancerRAIIObj(*this); if (PP.isCodeCompletionReached()) { cutOffParsing(); return DeclGroupPtrTy(); } Decl *SingleDecl = nullptr; switch (Tok.getKind()) { case tok::annot_pragma_vis: HandlePragmaVisibility(); return DeclGroupPtrTy(); case tok::annot_pragma_pack: HandlePragmaPack(); return DeclGroupPtrTy(); case tok::annot_pragma_msstruct: HandlePragmaMSStruct(); return DeclGroupPtrTy(); case tok::annot_pragma_align: HandlePragmaAlign(); return DeclGroupPtrTy(); case tok::annot_pragma_weak: HandlePragmaWeak(); return DeclGroupPtrTy(); case tok::annot_pragma_weakalias: HandlePragmaWeakAlias(); return DeclGroupPtrTy(); case tok::annot_pragma_redefine_extname: HandlePragmaRedefineExtname(); return DeclGroupPtrTy(); case tok::annot_pragma_fp_contract: HandlePragmaFPContract(); return DeclGroupPtrTy(); case tok::annot_pragma_opencl_extension: HandlePragmaOpenCLExtension(); return DeclGroupPtrTy(); case tok::annot_pragma_openmp: ParseOpenMPDeclarativeDirective(); return DeclGroupPtrTy(); case tok::annot_pragma_ms_pointers_to_members: HandlePragmaMSPointersToMembers(); return DeclGroupPtrTy(); case tok::annot_pragma_ms_vtordisp: HandlePragmaMSVtorDisp(); return DeclGroupPtrTy(); case tok::annot_pragma_ms_pragma: HandlePragmaMSPragma(); return DeclGroupPtrTy(); case tok::semi: // Either a C++11 empty-declaration or attribute-declaration. SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs.getList(), Tok.getLocation()); ConsumeExtraSemi(OutsideFunction); break; case tok::r_brace: Diag(Tok, diag::err_extraneous_closing_brace); ConsumeBrace(); return DeclGroupPtrTy(); case tok::eof: Diag(Tok, diag::err_expected_external_declaration); return DeclGroupPtrTy(); case tok::kw___extension__: { // __extension__ silences extension warnings in the subexpression. ExtensionRAIIObject O(Diags); // Use RAII to do this. ConsumeToken(); return ParseExternalDeclaration(attrs); } case tok::kw_asm: { ProhibitAttributes(attrs); SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc; ExprResult Result(ParseSimpleAsm(&EndLoc)); ExpectAndConsume(tok::semi, diag::err_expected_after, "top-level asm block"); if (Result.isInvalid()) return DeclGroupPtrTy(); SingleDecl = Actions.ActOnFileScopeAsmDecl(Result.get(), StartLoc, EndLoc); break; } case tok::at: return ParseObjCAtDirectives(); case tok::minus: case tok::plus: if (!getLangOpts().ObjC1) { Diag(Tok, diag::err_expected_external_declaration); ConsumeToken(); return DeclGroupPtrTy(); } SingleDecl = ParseObjCMethodDefinition(); break; case tok::code_completion: Actions.CodeCompleteOrdinaryName(getCurScope(), CurParsedObjCImpl? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); cutOffParsing(); return DeclGroupPtrTy(); case tok::kw_using: case tok::kw_namespace: case tok::kw_typedef: case tok::kw_template: case tok::kw_export: // As in 'export template' case tok::kw_static_assert: case tok::kw__Static_assert: // A function definition cannot start with any of these keywords. { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } case tok::kw_static: // Parse (then ignore) 'static' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 0; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } goto dont_know; case tok::kw_inline: if (getLangOpts().CPlusPlus) { tok::TokenKind NextKind = NextToken().getKind(); // Inline namespaces. Allowed as an extension even in C++03. if (NextKind == tok::kw_namespace) { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } // Parse (then ignore) 'inline' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (NextKind == tok::kw_template) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 1; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } } goto dont_know; case tok::kw_extern: if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { // Extern templates SourceLocation ExternLoc = ConsumeToken(); SourceLocation TemplateLoc = ConsumeToken(); Diag(ExternLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_extern_template : diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc); SourceLocation DeclEnd; return Actions.ConvertDeclToDeclGroup( ParseExplicitInstantiation(Declarator::FileContext, ExternLoc, TemplateLoc, DeclEnd)); } goto dont_know; case tok::kw___if_exists: case tok::kw___if_not_exists: ParseMicrosoftIfExistsExternalDeclaration(); return DeclGroupPtrTy(); default: dont_know: // We can't tell whether this is a function-definition or declaration yet. return ParseDeclarationOrFunctionDefinition(attrs, DS); } // This routine returns a DeclGroup, if the thing we parsed only contains a // single decl, convert it now. return Actions.ConvertDeclToDeclGroup(SingleDecl); } /// \brief Determine whether the current token, if it occurs after a /// declarator, continues a declaration or declaration list. bool Parser::isDeclarationAfterDeclarator() { // Check for '= delete' or '= default' if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); if (KW.is(tok::kw_default) || KW.is(tok::kw_delete)) return false; } return Tok.is(tok::equal) || // int X()= -> not a function def Tok.is(tok::comma) || // int X(), -> not a function def Tok.is(tok::semi) || // int X(); -> not a function def Tok.is(tok::kw_asm) || // int X() __asm__ -> not a function def Tok.is(tok::kw___attribute) || // int X() __attr__ -> not a function def (getLangOpts().CPlusPlus && Tok.is(tok::l_paren)); // int X(0) -> not a function def [C++] } /// \brief Determine whether the current token, if it occurs after a /// declarator, indicates the start of a function definition. bool Parser::isStartOfFunctionDefinition(const ParsingDeclarator &Declarator) { assert(Declarator.isFunctionDeclarator() && "Isn't a function declarator"); if (Tok.is(tok::l_brace)) // int X() {} return true; // Handle K&R C argument lists: int X(f) int f; {} if (!getLangOpts().CPlusPlus && Declarator.getFunctionTypeInfo().isKNRPrototype()) return isDeclarationSpecifier(); if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); return KW.is(tok::kw_default) || KW.is(tok::kw_delete); } return Tok.is(tok::colon) || // X() : Base() {} (used for ctors) Tok.is(tok::kw_try); // X() try { ... } } /// ParseDeclarationOrFunctionDefinition - Parse either a function-definition or /// a declaration. We can't tell which we have until we read up to the /// compound-statement in function-definition. TemplateParams, if /// non-NULL, provides the template parameters when we're parsing a /// C++ template-declaration. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// /// declaration: [C99 6.7] /// declaration-specifiers init-declarator-list[opt] ';' /// [!C99] init-declarator-list ';' [TODO: warn in c99 mode] /// [OMP] threadprivate-directive [TODO] /// Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs, ParsingDeclSpec &DS, AccessSpecifier AS) { // Parse the common declaration-specifiers piece. ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC_top_level); // If we had a free-standing type definition with a missing semicolon, we // may get this far before the problem becomes obvious. if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition(DS, AS, DSC_top_level)) return DeclGroupPtrTy(); // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" // declaration-specifiers init-declarator-list[opt] ';' if (Tok.is(tok::semi)) { ProhibitAttributes(attrs); ConsumeToken(); Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS); DS.complete(TheDecl); return Actions.ConvertDeclToDeclGroup(TheDecl); } DS.takeAttributesFrom(attrs); // ObjC2 allows prefix attributes on class interfaces and protocols. // FIXME: This still needs better diagnostics. We should only accept // attributes here, no types, etc. if (getLangOpts().ObjC2 && Tok.is(tok::at)) { SourceLocation AtLoc = ConsumeToken(); // the "@@" if (!Tok.isObjCAtKeyword(tok::objc_interface) && !Tok.isObjCAtKeyword(tok::objc_protocol)) { Diag(Tok, diag::err_objc_unexpected_attr); SkipUntil(tok::semi); // FIXME: better skip? return DeclGroupPtrTy(); } DS.abort(); const char *PrevSpec = nullptr; unsigned DiagID; if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID, Actions.getASTContext().getPrintingPolicy())) Diag(AtLoc, DiagID) << PrevSpec; if (Tok.isObjCAtKeyword(tok::objc_protocol)) return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes()); return Actions.ConvertDeclToDeclGroup( ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes())); } // If the declspec consisted only of 'extern' and we have a string // literal following it, this must be a C++ linkage specifier like // 'extern "C"'. if (getLangOpts().CPlusPlus && isTokenStringLiteral() && DS.getStorageClassSpec() == DeclSpec::SCS_extern && DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) { Decl *TheDecl = ParseLinkage(DS, Declarator::FileContext); return Actions.ConvertDeclToDeclGroup(TheDecl); } return ParseDeclGroup(DS, Declarator::FileContext, true); } Parser::DeclGroupPtrTy Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS, AccessSpecifier AS) { if (DS) { return ParseDeclOrFunctionDefInternal(attrs, *DS, AS); } else { ParsingDeclSpec PDS(*this); // Must temporarily exit the objective-c container scope for // parsing c constructs and re-enter objc container scope // afterwards. ObjCDeclContextSwitch ObjCDC(*this); return ParseDeclOrFunctionDefInternal(attrs, PDS, AS); } } /// ParseFunctionDefinition - We parsed and verified that the specified /// Declarator is well formed. If this is a K&R-style function, read the /// parameters declaration-list, then start the compound-statement. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator ctor-initializer[opt] /// function-body /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator function-try-block /// Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) { // Poison the SEH identifiers so they are flagged as illegal in function bodies PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true); const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // If this is C90 and the declspecs were completely missing, fudge in an // implicit int. We do this here because this is the only place where // declaration-specifiers are completely optional in the grammar. if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) { const char *PrevSpec; unsigned DiagID; const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int, D.getIdentifierLoc(), PrevSpec, DiagID, Policy); D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin()); } // If this declaration was formed with a K&R-style identifier list for the // arguments, parse declarations for all of the args next. // int foo(a,b) int a; float b; {} if (FTI.isKNRPrototype()) ParseKNRParamDeclarations(D); // We should have either an opening brace or, in a C++ constructor, // we may have a colon. if (Tok.isNot(tok::l_brace) && (!getLangOpts().CPlusPlus || (Tok.isNot(tok::colon) && Tok.isNot(tok::kw_try) && Tok.isNot(tok::equal)))) { Diag(Tok, diag::err_expected_fn_body); // Skip over garbage, until we get to '{'. Don't eat the '{'. SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); // If we didn't find the '{', bail out. if (Tok.isNot(tok::l_brace)) return nullptr; } // Check to make sure that any normal attributes are allowed to be on // a definition. Late parsed attributes are checked at the end. if (Tok.isNot(tok::equal)) { AttributeList *DtorAttrs = D.getAttributes(); while (DtorAttrs) { if (DtorAttrs->isKnownToGCC() && !DtorAttrs->isCXX11Attribute()) { Diag(DtorAttrs->getLoc(), diag::warn_attribute_on_function_definition) << DtorAttrs->getName(); } DtorAttrs = DtorAttrs->getNext(); } } // In delayed template parsing mode, for function template we consume the // tokens and store them for late parsing at the end of the translation unit. if (getLangOpts().DelayedTemplateParsing && Tok.isNot(tok::equal) && TemplateInfo.Kind == ParsedTemplateInfo::Template && Actions.canDelayFunctionBody(D)) { MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams); ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *DP = Actions.HandleDeclarator(ParentScope, D, TemplateParameterLists); D.complete(DP); D.getMutableDeclSpec().abort(); CachedTokens Toks; LexTemplateFunctionForLateParsing(Toks); if (DP) { FunctionDecl *FnD = DP->getAsFunction(); Actions.CheckForFunctionRedefinition(FnD); Actions.MarkAsLateParsedTemplate(FnD, DP, Toks); } return DP; } else if (CurParsedObjCImpl && !TemplateInfo.TemplateParams && (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || Tok.is(tok::colon)) && Actions.CurContext->isTranslationUnit()) { ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); D.complete(FuncDecl); D.getMutableDeclSpec().abort(); if (FuncDecl) { // Consume the tokens and store them for later parsing. StashAwayMethodOrFunctionBodyTokens(FuncDecl); CurParsedObjCImpl->HasCFunction = true; return FuncDecl; } // FIXME: Should we really fall through here? } // Enter a scope for the function body. ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); // Tell the actions module that we have entered a function definition with the // specified Declarator for the function. Decl *Res = TemplateInfo.TemplateParams? Actions.ActOnStartOfFunctionTemplateDef(getCurScope(), *TemplateInfo.TemplateParams, D) : Actions.ActOnStartOfFunctionDef(getCurScope(), D); // Break out of the ParsingDeclarator context before we parse the body. D.complete(Res); // Break out of the ParsingDeclSpec context, too. This const_cast is // safe because we're always the sole owner. D.getMutableDeclSpec().abort(); if (TryConsumeToken(tok::equal)) { assert(getLangOpts().CPlusPlus && "Only C++ function definitions have '='"); Actions.ActOnFinishFunctionBody(Res, nullptr, false); bool Delete = false; SourceLocation KWLoc; if (TryConsumeToken(tok::kw_delete, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_deleted_function : diag::ext_deleted_function); Actions.SetDeclDeleted(Res, KWLoc); Delete = true; } else if (TryConsumeToken(tok::kw_default, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_function : diag::ext_defaulted_function); Actions.SetDeclDefaulted(Res, KWLoc); } else { llvm_unreachable("function definition after = not 'delete' or 'default'"); } if (Tok.is(tok::comma)) { Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) << Delete; SkipUntil(tok::semi); } else if (ExpectAndConsume(tok::semi, diag::err_expected_after, Delete ? "delete" : "default")) { SkipUntil(tok::semi); } return Res; } if (Tok.is(tok::kw_try)) return ParseFunctionTryBlock(Res, BodyScope); // If we have a colon, then we're probably parsing a C++ // ctor-initializer. if (Tok.is(tok::colon)) { ParseConstructorInitializer(Res); // Recover from error. if (!Tok.is(tok::l_brace)) { BodyScope.Exit(); Actions.ActOnFinishFunctionBody(Res, nullptr); return Res; } } else Actions.ActOnDefaultCtorInitializers(Res); // Late attributes are parsed in the same scope as the function body. if (LateParsedAttrs) ParseLexedAttributeList(*LateParsedAttrs, Res, false, true); return ParseFunctionStatementBody(Res, BodyScope); } /// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides /// types for a function with a K&R-style identifier list for arguments. void Parser::ParseKNRParamDeclarations(Declarator &D) { // We know that the top-level of this declarator is a function. DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // Enter function-declaration scope, limiting any declarators to the // function prototype scope, including parameter declarators. ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | Scope::FunctionDeclarationScope | Scope::DeclScope); // Read all the argument declarations. while (isDeclarationSpecifier()) { SourceLocation DSStart = Tok.getLocation(); // Parse the common declaration-specifiers piece. DeclSpec DS(AttrFactory); ParseDeclarationSpecifiers(DS); // C99 6.9.1p6: 'each declaration in the declaration list shall have at // least one declarator'. // NOTE: GCC just makes this an ext-warn. It's not clear what it does with // the declarations though. It's trivial to ignore them, really hard to do // anything else with them. if (TryConsumeToken(tok::semi)) { Diag(DSStart, diag::err_declaration_does_not_declare_param); continue; } // C99 6.9.1p6: Declarations shall contain no storage-class specifiers other // than register. if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && DS.getStorageClassSpec() != DeclSpec::SCS_register) { Diag(DS.getStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) { Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } // Parse the first declarator attached to this declspec. Declarator ParmDeclarator(DS, Declarator::KNRTypeListContext); ParseDeclarator(ParmDeclarator); // Handle the full declarator list. while (1) { // If attributes are present, parse them. MaybeParseGNUAttributes(ParmDeclarator); // Ask the actions module to compute the type for this declarator. Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator); if (Param && // A missing identifier has already been diagnosed. ParmDeclarator.getIdentifier()) { // Scan the argument list looking for the correct param to apply this // type. for (unsigned i = 0; ; ++i) { // C99 6.9.1p6: those declarators shall declare only identifiers from // the identifier list. if (i == FTI.NumParams) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param) << ParmDeclarator.getIdentifier(); break; } if (FTI.Params[i].Ident == ParmDeclarator.getIdentifier()) { // Reject redefinitions of parameters. if (FTI.Params[i].Param) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_param_redefinition) << ParmDeclarator.getIdentifier(); } else { FTI.Params[i].Param = Param; } break; } } } // If we don't have a comma, it is either the end of the list (a ';') or // an error, bail out. if (Tok.isNot(tok::comma)) break; ParmDeclarator.clear(); // Consume the comma. ParmDeclarator.setCommaLoc(ConsumeToken()); // Parse the next declarator. ParseDeclarator(ParmDeclarator); } // Consume ';' and continue parsing. if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration)) continue; // Otherwise recover by skipping to next semi or mandatory function body. if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch)) break; TryConsumeToken(tok::semi); } // The actions module must verify that all arguments were declared. Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation()); } /// ParseAsmStringLiteral - This is just a normal string-literal, but is not /// allowed to be a wide string, and is not subject to character translation. /// /// [GNU] asm-string-literal: /// string-literal /// Parser::ExprResult Parser::ParseAsmStringLiteral() { switch (Tok.getKind()) { case tok::string_literal: break; case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: case tok::wide_string_literal: { SourceLocation L = Tok.getLocation(); Diag(Tok, diag::err_asm_operand_wide_string_literal) << (Tok.getKind() == tok::wide_string_literal) << SourceRange(L, L); return ExprError(); } default: Diag(Tok, diag::err_expected_string_literal) << /*Source='in...'*/0 << "'asm'"; return ExprError(); } return ParseStringLiteralExpression(); } /// ParseSimpleAsm /// /// [GNU] simple-asm-expr: /// 'asm' '(' asm-string-literal ')' /// Parser::ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { assert(Tok.is(tok::kw_asm) && "Not an asm!"); SourceLocation Loc = ConsumeToken(); if (Tok.is(tok::kw_volatile)) { // Remove from the end of 'asm' to the end of 'volatile'. SourceRange RemovalRange(PP.getLocForEndOfToken(Loc), PP.getLocForEndOfToken(Tok.getLocation())); Diag(Tok, diag::warn_file_asm_volatile) << FixItHint::CreateRemoval(RemovalRange); ConsumeToken(); } BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << "asm"; return ExprError(); } ExprResult Result(ParseAsmStringLiteral()); if (!Result.isInvalid()) { // Close the paren and get the location of the end bracket T.consumeClose(); if (EndLoc) *EndLoc = T.getCloseLocation(); } else if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) { if (EndLoc) *EndLoc = Tok.getLocation(); ConsumeParen(); } return Result; } /// \brief Get the TemplateIdAnnotation from the token and put it in the /// cleanup pool so that it gets destroyed when parsing the current top level /// declaration is finished. TemplateIdAnnotation *Parser::takeTemplateIdAnnotation(const Token &tok) { assert(tok.is(tok::annot_template_id) && "Expected template-id token"); TemplateIdAnnotation * Id = static_cast(tok.getAnnotationValue()); return Id; } void Parser::AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation) { // Push the current token back into the token stream (or revert it if it is // cached) and use an annotation scope token for current token. if (PP.isBacktrackEnabled()) PP.RevertCachedTokens(1); else PP.EnterToken(Tok); Tok.setKind(tok::annot_cxxscope); Tok.setAnnotationValue(Actions.SaveNestedNameSpecifierAnnotation(SS)); Tok.setAnnotationRange(SS.getRange()); // In case the tokens were cached, have Preprocessor replace them // with the annotation token. We don't need to do this if we've // just reverted back to a prior state. if (IsNewAnnotation) PP.AnnotateCachedTokens(Tok); } /// \brief Attempt to classify the name at the current token position. This may /// form a type, scope or primary expression annotation, or replace the token /// with a typo-corrected keyword. This is only appropriate when the current /// name must refer to an entity which has already been declared. /// /// \param IsAddressOfOperand Must be \c true if the name is preceded by an '&' /// and might possibly have a dependent nested name specifier. /// \param CCC Indicates how to perform typo-correction for this name. If NULL, /// no typo correction will be performed. Parser::AnnotatedNameKind Parser::TryAnnotateName(bool IsAddressOfOperand, CorrectionCandidateCallback *CCC) { assert(Tok.is(tok::identifier) || Tok.is(tok::annot_cxxscope)); const bool EnteringContext = false; const bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return ANK_Error; if (Tok.isNot(tok::identifier) || SS.isInvalid()) { if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return ANK_Unresolved; } IdentifierInfo *Name = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); // FIXME: Move the tentative declaration logic into ClassifyName so we can // typo-correct to tentatively-declared identifiers. if (isTentativelyDeclared(Name)) { // Identifier has been tentatively declared, and thus cannot be resolved as // an expression. Fall back to annotating it as a type. if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return Tok.is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl; } Token Next = NextToken(); // Look up and classify the identifier. We don't perform any typo-correction // after a scope specifier, because in general we can't recover from typos // there (eg, after correcting 'A::tempalte B::C' [sic], we would need to // jump back into scope specifier parsing). Sema::NameClassification Classification = Actions.ClassifyName(getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, SS.isEmpty() ? CCC : nullptr); switch (Classification.getKind()) { case Sema::NC_Error: return ANK_Error; case Sema::NC_Keyword: // The identifier was typo-corrected to a keyword. Tok.setIdentifierInfo(Name); Tok.setKind(Name->getTokenID()); PP.TypoCorrectToken(Tok); if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); // We've "annotated" this as a keyword. return ANK_Success; case Sema::NC_Unknown: // It's not something we know about. Leave it unannotated. break; case Sema::NC_Type: Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Classification.getType()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_Expression: Tok.setKind(tok::annot_primary_expr); setExprAnnotation(Tok, Classification.getExpression()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_TypeTemplate: if (Next.isNot(tok::less)) { // This may be a type template being used as a template template argument. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_TemplateName; } // Fall through. case Sema::NC_VarTemplate: case Sema::NC_FunctionTemplate: { // We have a type, variable or function template followed by '<'. ConsumeToken(); UnqualifiedId Id; Id.setIdentifier(Name, NameLoc); if (AnnotateTemplateIdToken( TemplateTy::make(Classification.getTemplateName()), Classification.getTemplateNameKind(), SS, SourceLocation(), Id)) return ANK_Error; return ANK_Success; } case Sema::NC_NestedNameSpecifier: llvm_unreachable("already parsed nested name specifier"); } // Unable to classify the name, but maybe we can annotate a scope specifier. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_Unresolved; } bool Parser::TryKeywordIdentFallback(bool DisableKeyword) { assert(!Tok.is(tok::identifier) && !Tok.isAnnotation()); Diag(Tok, diag::ext_keyword_as_ident) << PP.getSpelling(Tok) << DisableKeyword; if (DisableKeyword) { IdentifierInfo *II = Tok.getIdentifierInfo(); ContextualKeywords[II] = Tok.getKind(); II->RevertTokenIDToIdentifier(); } Tok.setKind(tok::identifier); return true; } bool Parser::TryIdentKeywordUpgrade() { assert(Tok.is(tok::identifier)); const IdentifierInfo *II = Tok.getIdentifierInfo(); assert(II->hasRevertedTokenIDToIdentifier()); // If we find that this is in fact the name of a type trait, // update the token kind in place and parse again to treat it as // the appropriate kind of type trait. llvm::SmallDenseMap::iterator Known = ContextualKeywords.find(II); if (Known == ContextualKeywords.end()) return false; Tok.setKind(Known->second); return true; } /// TryAnnotateTypeOrScopeToken - If the current token position is on a /// typename (possibly qualified in C++) or a C++ scope specifier not followed /// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens /// with a single annotation token representing the typename or C++ scope /// respectively. /// This simplifies handling of C++ scope specifiers and allows efficient /// backtracking without the need to re-parse and resolve nested-names and /// typenames. /// It will mainly be called when we expect to treat identifiers as typenames /// (if they are typenames). For example, in C we do not expect identifiers /// inside expressions to be treated as typenames so it will not be called /// for expressions in C. /// The benefit for C/ObjC is that a typename will be annotated and /// Actions.getTypeName will not be needed to be called again (e.g. getTypeName /// will not be called twice, once to check whether we have a declaration /// specifier, and another one to get the actual type inside /// ParseDeclarationSpecifiers). /// /// This returns true if an error occurred. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateTypeOrScopeToken(bool EnteringContext, bool NeedType) { assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)) && "Cannot be a type or scope token!"); if (Tok.is(tok::kw_typename)) { // MSVC lets you do stuff like: // typename typedef T_::D D; // // We will consume the typedef token here and put it back after we have // parsed the first identifier, transforming it into something more like: // typename T_::D typedef D; if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) { Token TypedefToken; PP.Lex(TypedefToken); bool Result = TryAnnotateTypeOrScopeToken(EnteringContext, NeedType); PP.EnterToken(Tok); Tok = TypedefToken; if (!Result) Diag(Tok.getLocation(), diag::warn_expected_qualified_after_typename); return Result; } // Parse a C++ typename-specifier, e.g., "typename T::type". // // typename-specifier: // 'typename' '::' [opt] nested-name-specifier identifier // 'typename' '::' [opt] nested-name-specifier template [opt] // simple-template-id SourceLocation TypenameLoc = ConsumeToken(); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/ParsedType(), /*EnteringContext=*/false, nullptr, /*IsTypename*/ true)) return true; if (!SS.isSet()) { if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id) || Tok.is(tok::annot_decltype)) { // Attempt to recover by skipping the invalid 'typename' if (Tok.is(tok::annot_decltype) || (!TryAnnotateTypeOrScopeToken(EnteringContext, NeedType) && Tok.isAnnotation())) { unsigned DiagID = diag::err_expected_qualified_after_typename; // MS compatibility: MSVC permits using known types with typename. // e.g. "typedef typename T* pointer_type" if (getLangOpts().MicrosoftExt) DiagID = diag::warn_expected_qualified_after_typename; Diag(Tok.getLocation(), DiagID); return false; } } Diag(Tok.getLocation(), diag::err_expected_qualified_after_typename); return true; } TypeResult Ty; if (Tok.is(tok::identifier)) { // FIXME: check whether the next token is '<', first! Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, *Tok.getIdentifierInfo(), Tok.getLocation()); } else if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind != TNK_Type_template && TemplateId->Kind != TNK_Dependent_template_name) { Diag(Tok, diag::err_typename_refers_to_non_type_template) << Tok.getAnnotationRange(); return true; } ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), TemplateId->NumArgs); Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, TemplateId->TemplateKWLoc, TemplateId->Template, TemplateId->TemplateNameLoc, TemplateId->LAngleLoc, TemplateArgsPtr, TemplateId->RAngleLoc); } else { Diag(Tok, diag::err_expected_type_name_after_typename) << SS.getRange(); return true; } SourceLocation EndLoc = Tok.getLastLoc(); Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty.isInvalid() ? ParsedType() : Ty.get()); Tok.setAnnotationEndLoc(EndLoc); Tok.setLocation(TypenameLoc); PP.AnnotateCachedTokens(Tok); return false; } // Remembers whether the token was originally a scope annotation. bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus) if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; return TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, NeedType, SS, !WasScopeAnnotation); } /// \brief Try to annotate a type or scope token, having already parsed an /// optional scope specifier. \p IsNewScope should be \c true unless the scope /// specifier was extracted from an existing tok::annot_cxxscope annotation. bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(bool EnteringContext, bool NeedType, CXXScopeSpec &SS, bool IsNewScope) { if (Tok.is(tok::identifier)) { IdentifierInfo *CorrectedII = nullptr; // Determine whether the identifier is a type name. if (ParsedType Ty = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS, false, NextToken().is(tok::period), ParsedType(), /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/ true, NeedType ? &CorrectedII : nullptr)) { // A FixIt was applied as a result of typo correction if (CorrectedII) Tok.setIdentifierInfo(CorrectedII); // This is a typename. Replace the current token in-place with an // annotation type token. Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty); Tok.setAnnotationEndLoc(Tok.getLocation()); if (SS.isNotEmpty()) // it was a C++ qualified type name. Tok.setLocation(SS.getBeginLoc()); // In case the tokens were cached, have Preprocessor replace // them with the annotation token. PP.AnnotateCachedTokens(Tok); return false; } if (!getLangOpts().CPlusPlus) { // If we're in C, we can't have :: tokens at all (the lexer won't return // them). If the identifier is not a type, then it can't be scope either, // just early exit. return false; } // If this is a template-id, annotate with a template-id or type token. if (NextToken().is(tok::less)) { TemplateTy Template; UnqualifiedId TemplateName; TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); bool MemberOfUnknownSpecialization; if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/ ParsedType(), EnteringContext, Template, MemberOfUnknownSpecialization)) { // Consume the identifier. ConsumeToken(); if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), TemplateName)) { // If an unrecoverable error occurred, we need to return true here, // because the token stream is in a damaged state. We may not return // a valid identifier. return true; } } } // The current token, which is either an identifier or a // template-id, is not part of the annotation. Fall through to // push that token back into the stream and complete the C++ scope // specifier annotation. } if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind == TNK_Type_template) { // A template-id that refers to a type was parsed into a // template-id annotation in a context where we weren't allowed // to produce a type annotation token. Update the template-id // annotation token to a type annotation token now. AnnotateTemplateIdTokenAsType(); return false; } } if (SS.isEmpty()) return false; // A C++ scope specifier that isn't followed by a typename. AnnotateScopeToken(SS, IsNewScope); return false; } /// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only /// annotates C++ scope specifiers and template-ids. This returns /// true if there was an error that could not be recovered from. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateCXXScopeToken(bool EnteringContext) { assert(getLangOpts().CPlusPlus && "Call sites of this function should be guarded by checking for C++"); assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) || Tok.is(tok::kw_decltype)) && "Cannot be a type or scope token!"); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; if (SS.isEmpty()) return false; AnnotateScopeToken(SS, true); return false; } bool Parser::isTokenEqualOrEqualTypo() { tok::TokenKind Kind = Tok.getKind(); switch (Kind) { default: return false; case tok::ampequal: // &= case tok::starequal: // *= case tok::plusequal: // += case tok::minusequal: // -= case tok::exclaimequal: // != case tok::slashequal: // /= case tok::percentequal: // %= case tok::lessequal: // <= case tok::lesslessequal: // <<= case tok::greaterequal: // >= case tok::greatergreaterequal: // >>= case tok::caretequal: // ^= case tok::pipeequal: // |= case tok::equalequal: // == Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal) << Kind << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "="); case tok::equal: return true; } } SourceLocation Parser::handleUnexpectedCodeCompletionToken() { assert(Tok.is(tok::code_completion)); PrevTokLocation = Tok.getLocation(); for (Scope *S = getCurScope(); S; S = S->getParent()) { if (S->getFlags() & Scope::FnScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction); cutOffParsing(); return PrevTokLocation; } if (S->getFlags() & Scope::ClassScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class); cutOffParsing(); return PrevTokLocation; } } Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace); cutOffParsing(); return PrevTokLocation; } // Anchor the Parser::FieldCallback vtable to this translation unit. // We use a spurious method instead of the destructor because // destroying FieldCallbacks can actually be slightly // performance-sensitive. void Parser::FieldCallback::_anchor() { } // Code-completion pass-through functions void Parser::CodeCompleteDirective(bool InConditional) { Actions.CodeCompletePreprocessorDirective(InConditional); } void Parser::CodeCompleteInConditionalExclusion() { Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope()); } void Parser::CodeCompleteMacroName(bool IsDefinition) { Actions.CodeCompletePreprocessorMacroName(IsDefinition); } void Parser::CodeCompletePreprocessorExpression() { Actions.CodeCompletePreprocessorExpression(); } void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned ArgumentIndex) { Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, ArgumentIndex); } void Parser::CodeCompleteNaturalLanguage() { Actions.CodeCompleteNaturalLanguage(); } bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition& Result) { assert((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists)) && "Expected '__if_exists' or '__if_not_exists'"); Result.IsIfExists = Tok.is(tok::kw___if_exists); Result.KeywordLoc = ConsumeToken(); BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << (Result.IsIfExists? "__if_exists" : "__if_not_exists"); return true; } // Parse nested-name-specifier. ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), /*EnteringContext=*/false); // Check nested-name specifier. if (Result.SS.isInvalid()) { T.skipToEnd(); return true; } // Parse the unqualified-id. SourceLocation TemplateKWLoc; // FIXME: parsed, but unused. if (ParseUnqualifiedId(Result.SS, false, true, true, ParsedType(), TemplateKWLoc, Result.Name)) { T.skipToEnd(); return true; } if (T.consumeClose()) return true; // Check if the symbol exists. switch (Actions.CheckMicrosoftIfExistsSymbol(getCurScope(), Result.KeywordLoc, Result.IsIfExists, Result.SS, Result.Name)) { case Sema::IER_Exists: Result.Behavior = Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_DoesNotExist: Result.Behavior = !Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_Dependent: Result.Behavior = IEB_Dependent; break; case Sema::IER_Error: return true; } return false; } void Parser::ParseMicrosoftIfExistsExternalDeclaration() { IfExistsCondition Result; if (ParseMicrosoftIfExistsCondition(Result)) return; BalancedDelimiterTracker Braces(*this, tok::l_brace); if (Braces.consumeOpen()) { Diag(Tok, diag::err_expected) << tok::l_brace; return; } switch (Result.Behavior) { case IEB_Parse: // Parse declarations below. break; case IEB_Dependent: llvm_unreachable("Cannot have a dependent external declaration"); case IEB_Skip: Braces.skipToEnd(); return; } // Parse the declarations. // FIXME: Support module import within __if_exists? while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); DeclGroupPtrTy Result = ParseExternalDeclaration(attrs); if (Result && !getCurScope()->getParent()) Actions.getASTConsumer().HandleTopLevelDecl(Result.get()); } Braces.consumeClose(); } Parser::DeclGroupPtrTy Parser::ParseModuleImport(SourceLocation AtLoc) { assert(Tok.isObjCAtKeyword(tok::objc_import) && "Improper start to module import"); SourceLocation ImportLoc = ConsumeToken(); SmallVector, 2> Path; // Parse the module path. do { if (!Tok.is(tok::identifier)) { if (Tok.is(tok::code_completion)) { Actions.CodeCompleteModuleImport(ImportLoc, Path); cutOffParsing(); return DeclGroupPtrTy(); } Diag(Tok, diag::err_module_expected_ident); SkipUntil(tok::semi); return DeclGroupPtrTy(); } // Record this part of the module path. Path.push_back(std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation())); ConsumeToken(); if (Tok.is(tok::period)) { ConsumeToken(); continue; } break; } while (true); if (PP.hadModuleLoaderFatalFailure()) { // With a fatal failure in the module loader, we abort parsing. cutOffParsing(); return DeclGroupPtrTy(); } DeclResult Import = Actions.ActOnModuleImport(AtLoc, ImportLoc, Path); ExpectAndConsumeSemi(diag::err_module_expected_semi); if (Import.isInvalid()) return DeclGroupPtrTy(); return Actions.ConvertDeclToDeclGroup(Import.get()); } bool BalancedDelimiterTracker::diagnoseOverflow() { P.Diag(P.Tok, diag::err_bracket_depth_exceeded) << P.getLangOpts().BracketDepth; P.Diag(P.Tok, diag::note_bracket_depth); P.cutOffParsing(); return true; } bool BalancedDelimiterTracker::expectAndConsume(unsigned DiagID, const char *Msg, tok::TokenKind SkipToTok) { LOpen = P.Tok.getLocation(); if (P.ExpectAndConsume(Kind, DiagID, Msg)) { if (SkipToTok != tok::unknown) P.SkipUntil(SkipToTok, Parser::StopAtSemi); return true; } if (getDepth() < MaxDepth) return false; return diagnoseOverflow(); } bool BalancedDelimiterTracker::diagnoseMissingClose() { assert(!P.Tok.is(Close) && "Should have consumed closing delimiter"); P.Diag(P.Tok, diag::err_expected) << Close; P.Diag(LOpen, diag::note_matching) << Kind; // If we're not already at some kind of closing bracket, skip to our closing // token. if (P.Tok.isNot(tok::r_paren) && P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::r_square) && P.SkipUntil(Close, FinalToken, Parser::StopAtSemi | Parser::StopBeforeMatch) && P.Tok.is(Close)) LClose = P.ConsumeAnyToken(); return true; } void BalancedDelimiterTracker::skipToEnd() { P.SkipUntil(Close, Parser::StopBeforeMatch); consumeClose(); } @ 1.1.1.5.4.1 log @file Parser.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:29 +0000 @ text @d1 1996 @ 1.1.1.5.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1996 //===--- Parser.cpp - C Language Family Parser ----------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the Parser interfaces. // //===----------------------------------------------------------------------===// #include "clang/Parse/Parser.h" #include "RAIIObjectsForParser.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclTemplate.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "llvm/Support/raw_ostream.h" using namespace clang; namespace { /// \brief A comment handler that passes comments found by the preprocessor /// to the parser action. class ActionCommentHandler : public CommentHandler { Sema &S; public: explicit ActionCommentHandler(Sema &S) : S(S) { } virtual bool HandleComment(Preprocessor &PP, SourceRange Comment) { S.ActOnComment(Comment); return false; } }; } // end anonymous namespace IdentifierInfo *Parser::getSEHExceptKeyword() { // __except is accepted as a (contextual) keyword if (!Ident__except && (getLangOpts().MicrosoftExt || getLangOpts().Borland)) Ident__except = PP.getIdentifierInfo("__except"); return Ident__except; } Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies) : PP(pp), Actions(actions), Diags(PP.getDiagnostics()), GreaterThanIsOperator(true), ColonIsSacred(false), InMessageExpression(false), TemplateParameterDepth(0), ParsingInObjCContainer(false) { SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies; Tok.startToken(); Tok.setKind(tok::eof); Actions.CurScope = 0; NumCachedScopes = 0; ParenCount = BracketCount = BraceCount = 0; CurParsedObjCImpl = 0; // Add #pragma handlers. These are removed and destroyed in the // destructor. initializePragmaHandlers(); CommentSemaHandler.reset(new ActionCommentHandler(actions)); PP.addCommentHandler(CommentSemaHandler.get()); PP.setCodeCompletionHandler(*this); } DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) { return Diags.Report(Loc, DiagID); } DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) { return Diag(Tok.getLocation(), DiagID); } /// \brief Emits a diagnostic suggesting parentheses surrounding a /// given range. /// /// \param Loc The location where we'll emit the diagnostic. /// \param DK The kind of diagnostic to emit. /// \param ParenRange Source range enclosing code that should be parenthesized. void Parser::SuggestParentheses(SourceLocation Loc, unsigned DK, SourceRange ParenRange) { SourceLocation EndLoc = PP.getLocForEndOfToken(ParenRange.getEnd()); if (!ParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { // We can't display the parentheses, so just dig the // warning/error and return. Diag(Loc, DK); return; } Diag(Loc, DK) << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") << FixItHint::CreateInsertion(EndLoc, ")"); } static bool IsCommonTypo(tok::TokenKind ExpectedTok, const Token &Tok) { switch (ExpectedTok) { case tok::semi: return Tok.is(tok::colon) || Tok.is(tok::comma); // : or , for ; default: return false; } } bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID, const char *Msg) { if (Tok.is(ExpectedTok) || Tok.is(tok::code_completion)) { ConsumeAnyToken(); return false; } // Detect common single-character typos and resume. if (IsCommonTypo(ExpectedTok, Tok)) { SourceLocation Loc = Tok.getLocation(); { DiagnosticBuilder DB = Diag(Loc, DiagID); DB << FixItHint::CreateReplacement( SourceRange(Loc), tok::getPunctuatorSpelling(ExpectedTok)); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; } // Pretend there wasn't a problem. ConsumeAnyToken(); return false; } SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); const char *Spelling = 0; if (EndLoc.isValid()) Spelling = tok::getPunctuatorSpelling(ExpectedTok); DiagnosticBuilder DB = Spelling ? Diag(EndLoc, DiagID) << FixItHint::CreateInsertion(EndLoc, Spelling) : Diag(Tok, DiagID); if (DiagID == diag::err_expected) DB << ExpectedTok; else if (DiagID == diag::err_expected_after) DB << Msg << ExpectedTok; else DB << Msg; return true; } bool Parser::ExpectAndConsumeSemi(unsigned DiagID) { if (TryConsumeToken(tok::semi)) return false; if (Tok.is(tok::code_completion)) { handleUnexpectedCodeCompletionToken(); return false; } if ((Tok.is(tok::r_paren) || Tok.is(tok::r_square)) && NextToken().is(tok::semi)) { Diag(Tok, diag::err_extraneous_token_before_semi) << PP.getSpelling(Tok) << FixItHint::CreateRemoval(Tok.getLocation()); ConsumeAnyToken(); // The ')' or ']'. ConsumeToken(); // The ';'. return false; } return ExpectAndConsume(tok::semi, DiagID); } void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST) { if (!Tok.is(tok::semi)) return; bool HadMultipleSemis = false; SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc = Tok.getLocation(); ConsumeToken(); while ((Tok.is(tok::semi) && !Tok.isAtStartOfLine())) { HadMultipleSemis = true; EndLoc = Tok.getLocation(); ConsumeToken(); } // C++11 allows extra semicolons at namespace scope, but not in any of the // other contexts. if (Kind == OutsideFunction && getLangOpts().CPlusPlus) { if (getLangOpts().CPlusPlus11) Diag(StartLoc, diag::warn_cxx98_compat_top_level_semi) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else Diag(StartLoc, diag::ext_extra_semi_cxx11) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); return; } if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis) Diag(StartLoc, diag::ext_extra_semi) << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST, Actions.getASTContext().getPrintingPolicy()) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); else // A single semicolon is valid after a member function definition. Diag(StartLoc, diag::warn_extra_semi_after_mem_fn_def) << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); } //===----------------------------------------------------------------------===// // Error recovery. //===----------------------------------------------------------------------===// static bool HasFlagsSet(Parser::SkipUntilFlags L, Parser::SkipUntilFlags R) { return (static_cast(L) & static_cast(R)) != 0; } /// SkipUntil - Read tokens until we get to the specified token, then consume /// it (unless no flag StopBeforeMatch). Because we cannot guarantee that the /// token will ever occur, this skips to the next token, or to some likely /// good stopping point. If StopAtSemi is true, skipping will stop at a ';' /// character. /// /// If SkipUntil finds the specified token, it returns true, otherwise it /// returns false. bool Parser::SkipUntil(ArrayRef Toks, SkipUntilFlags Flags) { // We always want this function to skip at least one token if the first token // isn't T and if not at EOF. bool isFirstTokenSkipped = true; while (1) { // If we found one of the tokens, stop and return true. for (unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) { if (Tok.is(Toks[i])) { if (HasFlagsSet(Flags, StopBeforeMatch)) { // Noop, don't consume the token. } else { ConsumeAnyToken(); } return true; } } // Important special case: The caller has given up and just wants us to // skip the rest of the file. Do this without recursing, since we can // get here precisely because the caller detected too much recursion. if (Toks.size() == 1 && Toks[0] == tok::eof && !HasFlagsSet(Flags, StopAtSemi) && !HasFlagsSet(Flags, StopAtCodeCompletion)) { while (Tok.isNot(tok::eof)) ConsumeAnyToken(); return true; } switch (Tok.getKind()) { case tok::eof: // Ran out of tokens. return false; case tok::annot_pragma_openmp_end: // Stop before an OpenMP pragma boundary. case tok::annot_module_begin: case tok::annot_module_end: case tok::annot_module_include: // Stop before we change submodules. They generally indicate a "good" // place to pick up parsing again (except in the special case where // we're trying to skip to EOF). return false; case tok::code_completion: if (!HasFlagsSet(Flags, StopAtCodeCompletion)) handleUnexpectedCodeCompletionToken(); return false; case tok::l_paren: // Recursively skip properly-nested parens. ConsumeParen(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_paren, StopAtCodeCompletion); else SkipUntil(tok::r_paren); break; case tok::l_square: // Recursively skip properly-nested square brackets. ConsumeBracket(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_square, StopAtCodeCompletion); else SkipUntil(tok::r_square); break; case tok::l_brace: // Recursively skip properly-nested braces. ConsumeBrace(); if (HasFlagsSet(Flags, StopAtCodeCompletion)) SkipUntil(tok::r_brace, StopAtCodeCompletion); else SkipUntil(tok::r_brace); break; // Okay, we found a ']' or '}' or ')', which we think should be balanced. // Since the user wasn't looking for this token (if they were, it would // already be handled), this isn't balanced. If there is a LHS token at a // higher level, we will assume that this matches the unbalanced token // and return it. Otherwise, this is a spurious RHS token, which we skip. case tok::r_paren: if (ParenCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeParen(); break; case tok::r_square: if (BracketCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBracket(); break; case tok::r_brace: if (BraceCount && !isFirstTokenSkipped) return false; // Matches something. ConsumeBrace(); break; case tok::string_literal: case tok::wide_string_literal: case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: ConsumeStringToken(); break; case tok::semi: if (HasFlagsSet(Flags, StopAtSemi)) return false; // FALL THROUGH. default: // Skip this token. ConsumeToken(); break; } isFirstTokenSkipped = false; } } //===----------------------------------------------------------------------===// // Scope manipulation //===----------------------------------------------------------------------===// /// EnterScope - Start a new scope. void Parser::EnterScope(unsigned ScopeFlags) { if (NumCachedScopes) { Scope *N = ScopeCache[--NumCachedScopes]; N->Init(getCurScope(), ScopeFlags); Actions.CurScope = N; } else { Actions.CurScope = new Scope(getCurScope(), ScopeFlags, Diags); } } /// ExitScope - Pop a scope off the scope stack. void Parser::ExitScope() { assert(getCurScope() && "Scope imbalance!"); // Inform the actions module that this scope is going away if there are any // decls in it. if (!getCurScope()->decl_empty()) Actions.ActOnPopScope(Tok.getLocation(), getCurScope()); Scope *OldScope = getCurScope(); Actions.CurScope = OldScope->getParent(); if (NumCachedScopes == ScopeCacheSize) delete OldScope; else ScopeCache[NumCachedScopes++] = OldScope; } /// Set the flags for the current scope to ScopeFlags. If ManageFlags is false, /// this object does nothing. Parser::ParseScopeFlags::ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags) : CurScope(ManageFlags ? Self->getCurScope() : 0) { if (CurScope) { OldFlags = CurScope->getFlags(); CurScope->setFlags(ScopeFlags); } } /// Restore the flags for the current scope to what they were before this /// object overrode them. Parser::ParseScopeFlags::~ParseScopeFlags() { if (CurScope) CurScope->setFlags(OldFlags); } //===----------------------------------------------------------------------===// // C99 6.9: External Definitions. //===----------------------------------------------------------------------===// Parser::~Parser() { // If we still have scopes active, delete the scope tree. delete getCurScope(); Actions.CurScope = 0; // Free the scope cache. for (unsigned i = 0, e = NumCachedScopes; i != e; ++i) delete ScopeCache[i]; resetPragmaHandlers(); PP.removeCommentHandler(CommentSemaHandler.get()); PP.clearCodeCompletionHandler(); assert(TemplateIds.empty() && "Still alive TemplateIdAnnotations around?"); } /// Initialize - Warm up the parser. /// void Parser::Initialize() { // Create the translation unit scope. Install it as the current scope. assert(getCurScope() == 0 && "A scope is already active?"); EnterScope(Scope::DeclScope); Actions.ActOnTranslationUnitScope(getCurScope()); // Initialization for Objective-C context sensitive keywords recognition. // Referenced in Parser::ParseObjCTypeQualifierList. if (getLangOpts().ObjC1) { ObjCTypeQuals[objc_in] = &PP.getIdentifierTable().get("in"); ObjCTypeQuals[objc_out] = &PP.getIdentifierTable().get("out"); ObjCTypeQuals[objc_inout] = &PP.getIdentifierTable().get("inout"); ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway"); ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy"); ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref"); } Ident_instancetype = 0; Ident_final = 0; Ident_sealed = 0; Ident_override = 0; Ident_super = &PP.getIdentifierTable().get("super"); if (getLangOpts().AltiVec) { Ident_vector = &PP.getIdentifierTable().get("vector"); Ident_pixel = &PP.getIdentifierTable().get("pixel"); Ident_bool = &PP.getIdentifierTable().get("bool"); } Ident_introduced = 0; Ident_deprecated = 0; Ident_obsoleted = 0; Ident_unavailable = 0; Ident__except = 0; Ident__exception_code = Ident__exception_info = Ident__abnormal_termination = 0; Ident___exception_code = Ident___exception_info = Ident___abnormal_termination = 0; Ident_GetExceptionCode = Ident_GetExceptionInfo = Ident_AbnormalTermination = 0; if(getLangOpts().Borland) { Ident__exception_info = PP.getIdentifierInfo("_exception_info"); Ident___exception_info = PP.getIdentifierInfo("__exception_info"); Ident_GetExceptionInfo = PP.getIdentifierInfo("GetExceptionInformation"); Ident__exception_code = PP.getIdentifierInfo("_exception_code"); Ident___exception_code = PP.getIdentifierInfo("__exception_code"); Ident_GetExceptionCode = PP.getIdentifierInfo("GetExceptionCode"); Ident__abnormal_termination = PP.getIdentifierInfo("_abnormal_termination"); Ident___abnormal_termination = PP.getIdentifierInfo("__abnormal_termination"); Ident_AbnormalTermination = PP.getIdentifierInfo("AbnormalTermination"); PP.SetPoisonReason(Ident__exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident___exception_code,diag::err_seh___except_block); PP.SetPoisonReason(Ident_GetExceptionCode,diag::err_seh___except_block); PP.SetPoisonReason(Ident__exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident___exception_info,diag::err_seh___except_filter); PP.SetPoisonReason(Ident_GetExceptionInfo,diag::err_seh___except_filter); PP.SetPoisonReason(Ident__abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident___abnormal_termination,diag::err_seh___finally_block); PP.SetPoisonReason(Ident_AbnormalTermination,diag::err_seh___finally_block); } Actions.Initialize(); // Prime the lexer look-ahead. ConsumeToken(); } namespace { /// \brief RAIIObject to destroy the contents of a SmallVector of /// TemplateIdAnnotation pointers and clear the vector. class DestroyTemplateIdAnnotationsRAIIObj { SmallVectorImpl &Container; public: DestroyTemplateIdAnnotationsRAIIObj(SmallVectorImpl &Container) : Container(Container) {} ~DestroyTemplateIdAnnotationsRAIIObj() { for (SmallVectorImpl::iterator I = Container.begin(), E = Container.end(); I != E; ++I) (*I)->Destroy(); Container.clear(); } }; } /// ParseTopLevelDecl - Parse one top-level declaration, return whatever the /// action tells us to. This returns true if the EOF was encountered. bool Parser::ParseTopLevelDecl(DeclGroupPtrTy &Result) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); // Skip over the EOF token, flagging end of previous input for incremental // processing if (PP.isIncrementalProcessingEnabled() && Tok.is(tok::eof)) ConsumeToken(); Result = DeclGroupPtrTy(); switch (Tok.getKind()) { case tok::annot_pragma_unused: HandlePragmaUnused(); return false; case tok::annot_module_include: Actions.ActOnModuleInclude(Tok.getLocation(), reinterpret_cast( Tok.getAnnotationValue())); ConsumeToken(); return false; case tok::annot_module_begin: case tok::annot_module_end: // FIXME: Update visibility based on the submodule we're in. ConsumeToken(); return false; case tok::eof: // Late template parsing can begin. if (getLangOpts().DelayedTemplateParsing) Actions.SetLateTemplateParser(LateTemplateParserCallback, this); if (!PP.isIncrementalProcessingEnabled()) Actions.ActOnEndOfTranslationUnit(); //else don't tell Sema that we ended parsing: more input might come. return true; default: break; } ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); Result = ParseExternalDeclaration(attrs); return false; } /// ParseExternalDeclaration: /// /// external-declaration: [C99 6.9], declaration: [C++ dcl.dcl] /// function-definition /// declaration /// [GNU] asm-definition /// [GNU] __extension__ external-declaration /// [OBJC] objc-class-definition /// [OBJC] objc-class-declaration /// [OBJC] objc-alias-declaration /// [OBJC] objc-protocol-definition /// [OBJC] objc-method-definition /// [OBJC] @@end /// [C++] linkage-specification /// [GNU] asm-definition: /// simple-asm-expr ';' /// [C++11] empty-declaration /// [C++11] attribute-declaration /// /// [C++11] empty-declaration: /// ';' /// /// [C++0x/GNU] 'extern' 'template' declaration Parser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS) { DestroyTemplateIdAnnotationsRAIIObj CleanupRAII(TemplateIds); ParenBraceBracketBalancer BalancerRAIIObj(*this); if (PP.isCodeCompletionReached()) { cutOffParsing(); return DeclGroupPtrTy(); } Decl *SingleDecl = 0; switch (Tok.getKind()) { case tok::annot_pragma_vis: HandlePragmaVisibility(); return DeclGroupPtrTy(); case tok::annot_pragma_pack: HandlePragmaPack(); return DeclGroupPtrTy(); case tok::annot_pragma_msstruct: HandlePragmaMSStruct(); return DeclGroupPtrTy(); case tok::annot_pragma_align: HandlePragmaAlign(); return DeclGroupPtrTy(); case tok::annot_pragma_weak: HandlePragmaWeak(); return DeclGroupPtrTy(); case tok::annot_pragma_weakalias: HandlePragmaWeakAlias(); return DeclGroupPtrTy(); case tok::annot_pragma_redefine_extname: HandlePragmaRedefineExtname(); return DeclGroupPtrTy(); case tok::annot_pragma_fp_contract: HandlePragmaFPContract(); return DeclGroupPtrTy(); case tok::annot_pragma_opencl_extension: HandlePragmaOpenCLExtension(); return DeclGroupPtrTy(); case tok::annot_pragma_openmp: ParseOpenMPDeclarativeDirective(); return DeclGroupPtrTy(); case tok::annot_pragma_ms_pointers_to_members: HandlePragmaMSPointersToMembers(); return DeclGroupPtrTy(); case tok::annot_pragma_ms_vtordisp: HandlePragmaMSVtorDisp(); return DeclGroupPtrTy(); case tok::semi: // Either a C++11 empty-declaration or attribute-declaration. SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(), attrs.getList(), Tok.getLocation()); ConsumeExtraSemi(OutsideFunction); break; case tok::r_brace: Diag(Tok, diag::err_extraneous_closing_brace); ConsumeBrace(); return DeclGroupPtrTy(); case tok::eof: Diag(Tok, diag::err_expected_external_declaration); return DeclGroupPtrTy(); case tok::kw___extension__: { // __extension__ silences extension warnings in the subexpression. ExtensionRAIIObject O(Diags); // Use RAII to do this. ConsumeToken(); return ParseExternalDeclaration(attrs); } case tok::kw_asm: { ProhibitAttributes(attrs); SourceLocation StartLoc = Tok.getLocation(); SourceLocation EndLoc; ExprResult Result(ParseSimpleAsm(&EndLoc)); ExpectAndConsume(tok::semi, diag::err_expected_after, "top-level asm block"); if (Result.isInvalid()) return DeclGroupPtrTy(); SingleDecl = Actions.ActOnFileScopeAsmDecl(Result.get(), StartLoc, EndLoc); break; } case tok::at: return ParseObjCAtDirectives(); case tok::minus: case tok::plus: if (!getLangOpts().ObjC1) { Diag(Tok, diag::err_expected_external_declaration); ConsumeToken(); return DeclGroupPtrTy(); } SingleDecl = ParseObjCMethodDefinition(); break; case tok::code_completion: Actions.CodeCompleteOrdinaryName(getCurScope(), CurParsedObjCImpl? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace); cutOffParsing(); return DeclGroupPtrTy(); case tok::kw_using: case tok::kw_namespace: case tok::kw_typedef: case tok::kw_template: case tok::kw_export: // As in 'export template' case tok::kw_static_assert: case tok::kw__Static_assert: // A function definition cannot start with any of these keywords. { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } case tok::kw_static: // Parse (then ignore) 'static' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 0; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } goto dont_know; case tok::kw_inline: if (getLangOpts().CPlusPlus) { tok::TokenKind NextKind = NextToken().getKind(); // Inline namespaces. Allowed as an extension even in C++03. if (NextKind == tok::kw_namespace) { SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } // Parse (then ignore) 'inline' prior to a template instantiation. This is // a GCC extension that we intentionally do not support. if (NextKind == tok::kw_template) { Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored) << 1; SourceLocation DeclEnd; StmtVector Stmts; return ParseDeclaration(Stmts, Declarator::FileContext, DeclEnd, attrs); } } goto dont_know; case tok::kw_extern: if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) { // Extern templates SourceLocation ExternLoc = ConsumeToken(); SourceLocation TemplateLoc = ConsumeToken(); Diag(ExternLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_extern_template : diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc); SourceLocation DeclEnd; return Actions.ConvertDeclToDeclGroup( ParseExplicitInstantiation(Declarator::FileContext, ExternLoc, TemplateLoc, DeclEnd)); } goto dont_know; case tok::kw___if_exists: case tok::kw___if_not_exists: ParseMicrosoftIfExistsExternalDeclaration(); return DeclGroupPtrTy(); default: dont_know: // We can't tell whether this is a function-definition or declaration yet. return ParseDeclarationOrFunctionDefinition(attrs, DS); } // This routine returns a DeclGroup, if the thing we parsed only contains a // single decl, convert it now. return Actions.ConvertDeclToDeclGroup(SingleDecl); } /// \brief Determine whether the current token, if it occurs after a /// declarator, continues a declaration or declaration list. bool Parser::isDeclarationAfterDeclarator() { // Check for '= delete' or '= default' if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); if (KW.is(tok::kw_default) || KW.is(tok::kw_delete)) return false; } return Tok.is(tok::equal) || // int X()= -> not a function def Tok.is(tok::comma) || // int X(), -> not a function def Tok.is(tok::semi) || // int X(); -> not a function def Tok.is(tok::kw_asm) || // int X() __asm__ -> not a function def Tok.is(tok::kw___attribute) || // int X() __attr__ -> not a function def (getLangOpts().CPlusPlus && Tok.is(tok::l_paren)); // int X(0) -> not a function def [C++] } /// \brief Determine whether the current token, if it occurs after a /// declarator, indicates the start of a function definition. bool Parser::isStartOfFunctionDefinition(const ParsingDeclarator &Declarator) { assert(Declarator.isFunctionDeclarator() && "Isn't a function declarator"); if (Tok.is(tok::l_brace)) // int X() {} return true; // Handle K&R C argument lists: int X(f) int f; {} if (!getLangOpts().CPlusPlus && Declarator.getFunctionTypeInfo().isKNRPrototype()) return isDeclarationSpecifier(); if (getLangOpts().CPlusPlus && Tok.is(tok::equal)) { const Token &KW = NextToken(); return KW.is(tok::kw_default) || KW.is(tok::kw_delete); } return Tok.is(tok::colon) || // X() : Base() {} (used for ctors) Tok.is(tok::kw_try); // X() try { ... } } /// ParseDeclarationOrFunctionDefinition - Parse either a function-definition or /// a declaration. We can't tell which we have until we read up to the /// compound-statement in function-definition. TemplateParams, if /// non-NULL, provides the template parameters when we're parsing a /// C++ template-declaration. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// /// declaration: [C99 6.7] /// declaration-specifiers init-declarator-list[opt] ';' /// [!C99] init-declarator-list ';' [TODO: warn in c99 mode] /// [OMP] threadprivate-directive [TODO] /// Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs, ParsingDeclSpec &DS, AccessSpecifier AS) { // Parse the common declaration-specifiers piece. ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC_top_level); // If we had a free-standing type definition with a missing semicolon, we // may get this far before the problem becomes obvious. if (DS.hasTagDefinition() && DiagnoseMissingSemiAfterTagDefinition(DS, AS, DSC_top_level)) return DeclGroupPtrTy(); // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" // declaration-specifiers init-declarator-list[opt] ';' if (Tok.is(tok::semi)) { ProhibitAttributes(attrs); ConsumeToken(); Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS, DS); DS.complete(TheDecl); return Actions.ConvertDeclToDeclGroup(TheDecl); } DS.takeAttributesFrom(attrs); // ObjC2 allows prefix attributes on class interfaces and protocols. // FIXME: This still needs better diagnostics. We should only accept // attributes here, no types, etc. if (getLangOpts().ObjC2 && Tok.is(tok::at)) { SourceLocation AtLoc = ConsumeToken(); // the "@@" if (!Tok.isObjCAtKeyword(tok::objc_interface) && !Tok.isObjCAtKeyword(tok::objc_protocol)) { Diag(Tok, diag::err_objc_unexpected_attr); SkipUntil(tok::semi); // FIXME: better skip? return DeclGroupPtrTy(); } DS.abort(); const char *PrevSpec = 0; unsigned DiagID; if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID, Actions.getASTContext().getPrintingPolicy())) Diag(AtLoc, DiagID) << PrevSpec; if (Tok.isObjCAtKeyword(tok::objc_protocol)) return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes()); return Actions.ConvertDeclToDeclGroup( ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes())); } // If the declspec consisted only of 'extern' and we have a string // literal following it, this must be a C++ linkage specifier like // 'extern "C"'. if (getLangOpts().CPlusPlus && isTokenStringLiteral() && DS.getStorageClassSpec() == DeclSpec::SCS_extern && DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) { Decl *TheDecl = ParseLinkage(DS, Declarator::FileContext); return Actions.ConvertDeclToDeclGroup(TheDecl); } return ParseDeclGroup(DS, Declarator::FileContext, true); } Parser::DeclGroupPtrTy Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs, ParsingDeclSpec *DS, AccessSpecifier AS) { if (DS) { return ParseDeclOrFunctionDefInternal(attrs, *DS, AS); } else { ParsingDeclSpec PDS(*this); // Must temporarily exit the objective-c container scope for // parsing c constructs and re-enter objc container scope // afterwards. ObjCDeclContextSwitch ObjCDC(*this); return ParseDeclOrFunctionDefInternal(attrs, PDS, AS); } } static inline bool isFunctionDeclaratorRequiringReturnTypeDeduction( const Declarator &D) { if (!D.isFunctionDeclarator() || !D.getDeclSpec().containsPlaceholderType()) return false; for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { unsigned chunkIndex = E - I - 1; const DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); if (DeclType.Kind == DeclaratorChunk::Function) { const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; if (!FTI.hasTrailingReturnType()) return true; QualType TrailingRetType = FTI.getTrailingReturnType().get(); return TrailingRetType->getCanonicalTypeInternal() ->getContainedAutoType(); } } return false; } /// ParseFunctionDefinition - We parsed and verified that the specified /// Declarator is well formed. If this is a K&R-style function, read the /// parameters declaration-list, then start the compound-statement. /// /// function-definition: [C99 6.9.1] /// decl-specs declarator declaration-list[opt] compound-statement /// [C90] function-definition: [C99 6.7.1] - implicit int result /// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator ctor-initializer[opt] /// function-body /// [C++] function-definition: [C++ 8.4] /// decl-specifier-seq[opt] declarator function-try-block /// Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) { // Poison the SEH identifiers so they are flagged as illegal in function bodies PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true); const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // If this is C90 and the declspecs were completely missing, fudge in an // implicit int. We do this here because this is the only place where // declaration-specifiers are completely optional in the grammar. if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) { const char *PrevSpec; unsigned DiagID; const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy(); D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int, D.getIdentifierLoc(), PrevSpec, DiagID, Policy); D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin()); } // If this declaration was formed with a K&R-style identifier list for the // arguments, parse declarations for all of the args next. // int foo(a,b) int a; float b; {} if (FTI.isKNRPrototype()) ParseKNRParamDeclarations(D); // We should have either an opening brace or, in a C++ constructor, // we may have a colon. if (Tok.isNot(tok::l_brace) && (!getLangOpts().CPlusPlus || (Tok.isNot(tok::colon) && Tok.isNot(tok::kw_try) && Tok.isNot(tok::equal)))) { Diag(Tok, diag::err_expected_fn_body); // Skip over garbage, until we get to '{'. Don't eat the '{'. SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch); // If we didn't find the '{', bail out. if (Tok.isNot(tok::l_brace)) return 0; } // Check to make sure that any normal attributes are allowed to be on // a definition. Late parsed attributes are checked at the end. if (Tok.isNot(tok::equal)) { AttributeList *DtorAttrs = D.getAttributes(); while (DtorAttrs) { if (DtorAttrs->isKnownToGCC() && !DtorAttrs->isCXX11Attribute()) { Diag(DtorAttrs->getLoc(), diag::warn_attribute_on_function_definition) << DtorAttrs->getName(); } DtorAttrs = DtorAttrs->getNext(); } } // In delayed template parsing mode, for function template we consume the // tokens and store them for late parsing at the end of the translation unit. if (getLangOpts().DelayedTemplateParsing && Tok.isNot(tok::equal) && TemplateInfo.Kind == ParsedTemplateInfo::Template && !D.getDeclSpec().isConstexprSpecified() && !isFunctionDeclaratorRequiringReturnTypeDeduction(D)) { MultiTemplateParamsArg TemplateParameterLists(*TemplateInfo.TemplateParams); ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *DP = Actions.HandleDeclarator(ParentScope, D, TemplateParameterLists); D.complete(DP); D.getMutableDeclSpec().abort(); CachedTokens Toks; LexTemplateFunctionForLateParsing(Toks); if (DP) { FunctionDecl *FnD = DP->getAsFunction(); Actions.CheckForFunctionRedefinition(FnD); Actions.MarkAsLateParsedTemplate(FnD, DP, Toks); } return DP; } else if (CurParsedObjCImpl && !TemplateInfo.TemplateParams && (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || Tok.is(tok::colon)) && Actions.CurContext->isTranslationUnit()) { ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); D.setFunctionDefinitionKind(FDK_Definition); Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); D.complete(FuncDecl); D.getMutableDeclSpec().abort(); if (FuncDecl) { // Consume the tokens and store them for later parsing. StashAwayMethodOrFunctionBodyTokens(FuncDecl); CurParsedObjCImpl->HasCFunction = true; return FuncDecl; } } // Enter a scope for the function body. ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); // Tell the actions module that we have entered a function definition with the // specified Declarator for the function. Decl *Res = TemplateInfo.TemplateParams? Actions.ActOnStartOfFunctionTemplateDef(getCurScope(), *TemplateInfo.TemplateParams, D) : Actions.ActOnStartOfFunctionDef(getCurScope(), D); // Break out of the ParsingDeclarator context before we parse the body. D.complete(Res); // Break out of the ParsingDeclSpec context, too. This const_cast is // safe because we're always the sole owner. D.getMutableDeclSpec().abort(); if (TryConsumeToken(tok::equal)) { assert(getLangOpts().CPlusPlus && "Only C++ function definitions have '='"); Actions.ActOnFinishFunctionBody(Res, 0, false); bool Delete = false; SourceLocation KWLoc; if (TryConsumeToken(tok::kw_delete, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_deleted_function : diag::ext_deleted_function); Actions.SetDeclDeleted(Res, KWLoc); Delete = true; } else if (TryConsumeToken(tok::kw_default, KWLoc)) { Diag(KWLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_defaulted_function : diag::ext_defaulted_function); Actions.SetDeclDefaulted(Res, KWLoc); } else { llvm_unreachable("function definition after = not 'delete' or 'default'"); } if (Tok.is(tok::comma)) { Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) << Delete; SkipUntil(tok::semi); } else if (ExpectAndConsume(tok::semi, diag::err_expected_after, Delete ? "delete" : "default")) { SkipUntil(tok::semi); } return Res; } if (Tok.is(tok::kw_try)) return ParseFunctionTryBlock(Res, BodyScope); // If we have a colon, then we're probably parsing a C++ // ctor-initializer. if (Tok.is(tok::colon)) { ParseConstructorInitializer(Res); // Recover from error. if (!Tok.is(tok::l_brace)) { BodyScope.Exit(); Actions.ActOnFinishFunctionBody(Res, 0); return Res; } } else Actions.ActOnDefaultCtorInitializers(Res); // Late attributes are parsed in the same scope as the function body. if (LateParsedAttrs) ParseLexedAttributeList(*LateParsedAttrs, Res, false, true); return ParseFunctionStatementBody(Res, BodyScope); } /// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides /// types for a function with a K&R-style identifier list for arguments. void Parser::ParseKNRParamDeclarations(Declarator &D) { // We know that the top-level of this declarator is a function. DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); // Enter function-declaration scope, limiting any declarators to the // function prototype scope, including parameter declarators. ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope | Scope::FunctionDeclarationScope | Scope::DeclScope); // Read all the argument declarations. while (isDeclarationSpecifier()) { SourceLocation DSStart = Tok.getLocation(); // Parse the common declaration-specifiers piece. DeclSpec DS(AttrFactory); ParseDeclarationSpecifiers(DS); // C99 6.9.1p6: 'each declaration in the declaration list shall have at // least one declarator'. // NOTE: GCC just makes this an ext-warn. It's not clear what it does with // the declarations though. It's trivial to ignore them, really hard to do // anything else with them. if (TryConsumeToken(tok::semi)) { Diag(DSStart, diag::err_declaration_does_not_declare_param); continue; } // C99 6.9.1p6: Declarations shall contain no storage-class specifiers other // than register. if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && DS.getStorageClassSpec() != DeclSpec::SCS_register) { Diag(DS.getStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } if (DS.getThreadStorageClassSpec() != DeclSpec::TSCS_unspecified) { Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_storage_class_in_func_decl); DS.ClearStorageClassSpecs(); } // Parse the first declarator attached to this declspec. Declarator ParmDeclarator(DS, Declarator::KNRTypeListContext); ParseDeclarator(ParmDeclarator); // Handle the full declarator list. while (1) { // If attributes are present, parse them. MaybeParseGNUAttributes(ParmDeclarator); // Ask the actions module to compute the type for this declarator. Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator); if (Param && // A missing identifier has already been diagnosed. ParmDeclarator.getIdentifier()) { // Scan the argument list looking for the correct param to apply this // type. for (unsigned i = 0; ; ++i) { // C99 6.9.1p6: those declarators shall declare only identifiers from // the identifier list. if (i == FTI.NumParams) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param) << ParmDeclarator.getIdentifier(); break; } if (FTI.Params[i].Ident == ParmDeclarator.getIdentifier()) { // Reject redefinitions of parameters. if (FTI.Params[i].Param) { Diag(ParmDeclarator.getIdentifierLoc(), diag::err_param_redefinition) << ParmDeclarator.getIdentifier(); } else { FTI.Params[i].Param = Param; } break; } } } // If we don't have a comma, it is either the end of the list (a ';') or // an error, bail out. if (Tok.isNot(tok::comma)) break; ParmDeclarator.clear(); // Consume the comma. ParmDeclarator.setCommaLoc(ConsumeToken()); // Parse the next declarator. ParseDeclarator(ParmDeclarator); } // Consume ';' and continue parsing. if (!ExpectAndConsumeSemi(diag::err_expected_semi_declaration)) continue; // Otherwise recover by skipping to next semi or mandatory function body. if (SkipUntil(tok::l_brace, StopAtSemi | StopBeforeMatch)) break; TryConsumeToken(tok::semi); } // The actions module must verify that all arguments were declared. Actions.ActOnFinishKNRParamDeclarations(getCurScope(), D, Tok.getLocation()); } /// ParseAsmStringLiteral - This is just a normal string-literal, but is not /// allowed to be a wide string, and is not subject to character translation. /// /// [GNU] asm-string-literal: /// string-literal /// Parser::ExprResult Parser::ParseAsmStringLiteral() { switch (Tok.getKind()) { case tok::string_literal: break; case tok::utf8_string_literal: case tok::utf16_string_literal: case tok::utf32_string_literal: case tok::wide_string_literal: { SourceLocation L = Tok.getLocation(); Diag(Tok, diag::err_asm_operand_wide_string_literal) << (Tok.getKind() == tok::wide_string_literal) << SourceRange(L, L); return ExprError(); } default: Diag(Tok, diag::err_expected_string_literal) << /*Source='in...'*/0 << "'asm'"; return ExprError(); } return ParseStringLiteralExpression(); } /// ParseSimpleAsm /// /// [GNU] simple-asm-expr: /// 'asm' '(' asm-string-literal ')' /// Parser::ExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) { assert(Tok.is(tok::kw_asm) && "Not an asm!"); SourceLocation Loc = ConsumeToken(); if (Tok.is(tok::kw_volatile)) { // Remove from the end of 'asm' to the end of 'volatile'. SourceRange RemovalRange(PP.getLocForEndOfToken(Loc), PP.getLocForEndOfToken(Tok.getLocation())); Diag(Tok, diag::warn_file_asm_volatile) << FixItHint::CreateRemoval(RemovalRange); ConsumeToken(); } BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << "asm"; return ExprError(); } ExprResult Result(ParseAsmStringLiteral()); if (!Result.isInvalid()) { // Close the paren and get the location of the end bracket T.consumeClose(); if (EndLoc) *EndLoc = T.getCloseLocation(); } else if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch)) { if (EndLoc) *EndLoc = Tok.getLocation(); ConsumeParen(); } return Result; } /// \brief Get the TemplateIdAnnotation from the token and put it in the /// cleanup pool so that it gets destroyed when parsing the current top level /// declaration is finished. TemplateIdAnnotation *Parser::takeTemplateIdAnnotation(const Token &tok) { assert(tok.is(tok::annot_template_id) && "Expected template-id token"); TemplateIdAnnotation * Id = static_cast(tok.getAnnotationValue()); return Id; } void Parser::AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation) { // Push the current token back into the token stream (or revert it if it is // cached) and use an annotation scope token for current token. if (PP.isBacktrackEnabled()) PP.RevertCachedTokens(1); else PP.EnterToken(Tok); Tok.setKind(tok::annot_cxxscope); Tok.setAnnotationValue(Actions.SaveNestedNameSpecifierAnnotation(SS)); Tok.setAnnotationRange(SS.getRange()); // In case the tokens were cached, have Preprocessor replace them // with the annotation token. We don't need to do this if we've // just reverted back to a prior state. if (IsNewAnnotation) PP.AnnotateCachedTokens(Tok); } /// \brief Attempt to classify the name at the current token position. This may /// form a type, scope or primary expression annotation, or replace the token /// with a typo-corrected keyword. This is only appropriate when the current /// name must refer to an entity which has already been declared. /// /// \param IsAddressOfOperand Must be \c true if the name is preceded by an '&' /// and might possibly have a dependent nested name specifier. /// \param CCC Indicates how to perform typo-correction for this name. If NULL, /// no typo correction will be performed. Parser::AnnotatedNameKind Parser::TryAnnotateName(bool IsAddressOfOperand, CorrectionCandidateCallback *CCC) { assert(Tok.is(tok::identifier) || Tok.is(tok::annot_cxxscope)); const bool EnteringContext = false; const bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return ANK_Error; if (Tok.isNot(tok::identifier) || SS.isInvalid()) { if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return ANK_Unresolved; } IdentifierInfo *Name = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); // FIXME: Move the tentative declaration logic into ClassifyName so we can // typo-correct to tentatively-declared identifiers. if (isTentativelyDeclared(Name)) { // Identifier has been tentatively declared, and thus cannot be resolved as // an expression. Fall back to annotating it as a type. if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, false, SS, !WasScopeAnnotation)) return ANK_Error; return Tok.is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl; } Token Next = NextToken(); // Look up and classify the identifier. We don't perform any typo-correction // after a scope specifier, because in general we can't recover from typos // there (eg, after correcting 'A::tempalte B::C' [sic], we would need to // jump back into scope specifier parsing). Sema::NameClassification Classification = Actions.ClassifyName(getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand, SS.isEmpty() ? CCC : 0); switch (Classification.getKind()) { case Sema::NC_Error: return ANK_Error; case Sema::NC_Keyword: // The identifier was typo-corrected to a keyword. Tok.setIdentifierInfo(Name); Tok.setKind(Name->getTokenID()); PP.TypoCorrectToken(Tok); if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); // We've "annotated" this as a keyword. return ANK_Success; case Sema::NC_Unknown: // It's not something we know about. Leave it unannotated. break; case Sema::NC_Type: Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Classification.getType()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_Expression: Tok.setKind(tok::annot_primary_expr); setExprAnnotation(Tok, Classification.getExpression()); Tok.setAnnotationEndLoc(NameLoc); if (SS.isNotEmpty()) Tok.setLocation(SS.getBeginLoc()); PP.AnnotateCachedTokens(Tok); return ANK_Success; case Sema::NC_TypeTemplate: if (Next.isNot(tok::less)) { // This may be a type template being used as a template template argument. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_TemplateName; } // Fall through. case Sema::NC_VarTemplate: case Sema::NC_FunctionTemplate: { // We have a type, variable or function template followed by '<'. ConsumeToken(); UnqualifiedId Id; Id.setIdentifier(Name, NameLoc); if (AnnotateTemplateIdToken( TemplateTy::make(Classification.getTemplateName()), Classification.getTemplateNameKind(), SS, SourceLocation(), Id)) return ANK_Error; return ANK_Success; } case Sema::NC_NestedNameSpecifier: llvm_unreachable("already parsed nested name specifier"); } // Unable to classify the name, but maybe we can annotate a scope specifier. if (SS.isNotEmpty()) AnnotateScopeToken(SS, !WasScopeAnnotation); return ANK_Unresolved; } bool Parser::TryKeywordIdentFallback(bool DisableKeyword) { assert(!Tok.is(tok::identifier) && !Tok.isAnnotation()); Diag(Tok, diag::ext_keyword_as_ident) << PP.getSpelling(Tok) << DisableKeyword; if (DisableKeyword) { IdentifierInfo *II = Tok.getIdentifierInfo(); ContextualKeywords[II] = Tok.getKind(); II->RevertTokenIDToIdentifier(); } Tok.setKind(tok::identifier); return true; } bool Parser::TryIdentKeywordUpgrade() { assert(Tok.is(tok::identifier)); const IdentifierInfo *II = Tok.getIdentifierInfo(); assert(II->hasRevertedTokenIDToIdentifier()); // If we find that this is in fact the name of a type trait, // update the token kind in place and parse again to treat it as // the appropriate kind of type trait. llvm::SmallDenseMap::iterator Known = ContextualKeywords.find(II); if (Known == ContextualKeywords.end()) return false; Tok.setKind(Known->second); return true; } /// TryAnnotateTypeOrScopeToken - If the current token position is on a /// typename (possibly qualified in C++) or a C++ scope specifier not followed /// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens /// with a single annotation token representing the typename or C++ scope /// respectively. /// This simplifies handling of C++ scope specifiers and allows efficient /// backtracking without the need to re-parse and resolve nested-names and /// typenames. /// It will mainly be called when we expect to treat identifiers as typenames /// (if they are typenames). For example, in C we do not expect identifiers /// inside expressions to be treated as typenames so it will not be called /// for expressions in C. /// The benefit for C/ObjC is that a typename will be annotated and /// Actions.getTypeName will not be needed to be called again (e.g. getTypeName /// will not be called twice, once to check whether we have a declaration /// specifier, and another one to get the actual type inside /// ParseDeclarationSpecifiers). /// /// This returns true if an error occurred. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateTypeOrScopeToken(bool EnteringContext, bool NeedType) { assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id)) && "Cannot be a type or scope token!"); if (Tok.is(tok::kw_typename)) { // MSVC lets you do stuff like: // typename typedef T_::D D; // // We will consume the typedef token here and put it back after we have // parsed the first identifier, transforming it into something more like: // typename T_::D typedef D; if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) { Token TypedefToken; PP.Lex(TypedefToken); bool Result = TryAnnotateTypeOrScopeToken(EnteringContext, NeedType); PP.EnterToken(Tok); Tok = TypedefToken; if (!Result) Diag(Tok.getLocation(), diag::warn_expected_qualified_after_typename); return Result; } // Parse a C++ typename-specifier, e.g., "typename T::type". // // typename-specifier: // 'typename' '::' [opt] nested-name-specifier identifier // 'typename' '::' [opt] nested-name-specifier template [opt] // simple-template-id SourceLocation TypenameLoc = ConsumeToken(); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/ParsedType(), /*EnteringContext=*/false, 0, /*IsTypename*/true)) return true; if (!SS.isSet()) { if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id) || Tok.is(tok::annot_decltype)) { // Attempt to recover by skipping the invalid 'typename' if (Tok.is(tok::annot_decltype) || (!TryAnnotateTypeOrScopeToken(EnteringContext, NeedType) && Tok.isAnnotation())) { unsigned DiagID = diag::err_expected_qualified_after_typename; // MS compatibility: MSVC permits using known types with typename. // e.g. "typedef typename T* pointer_type" if (getLangOpts().MicrosoftExt) DiagID = diag::warn_expected_qualified_after_typename; Diag(Tok.getLocation(), DiagID); return false; } } Diag(Tok.getLocation(), diag::err_expected_qualified_after_typename); return true; } TypeResult Ty; if (Tok.is(tok::identifier)) { // FIXME: check whether the next token is '<', first! Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, *Tok.getIdentifierInfo(), Tok.getLocation()); } else if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind != TNK_Type_template && TemplateId->Kind != TNK_Dependent_template_name) { Diag(Tok, diag::err_typename_refers_to_non_type_template) << Tok.getAnnotationRange(); return true; } ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), TemplateId->NumArgs); Ty = Actions.ActOnTypenameType(getCurScope(), TypenameLoc, SS, TemplateId->TemplateKWLoc, TemplateId->Template, TemplateId->TemplateNameLoc, TemplateId->LAngleLoc, TemplateArgsPtr, TemplateId->RAngleLoc); } else { Diag(Tok, diag::err_expected_type_name_after_typename) << SS.getRange(); return true; } SourceLocation EndLoc = Tok.getLastLoc(); Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty.isInvalid() ? ParsedType() : Ty.get()); Tok.setAnnotationEndLoc(EndLoc); Tok.setLocation(TypenameLoc); PP.AnnotateCachedTokens(Tok); return false; } // Remembers whether the token was originally a scope annotation. bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope); CXXScopeSpec SS; if (getLangOpts().CPlusPlus) if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; return TryAnnotateTypeOrScopeTokenAfterScopeSpec(EnteringContext, NeedType, SS, !WasScopeAnnotation); } /// \brief Try to annotate a type or scope token, having already parsed an /// optional scope specifier. \p IsNewScope should be \c true unless the scope /// specifier was extracted from an existing tok::annot_cxxscope annotation. bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(bool EnteringContext, bool NeedType, CXXScopeSpec &SS, bool IsNewScope) { if (Tok.is(tok::identifier)) { IdentifierInfo *CorrectedII = 0; // Determine whether the identifier is a type name. if (ParsedType Ty = Actions.getTypeName(*Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS, false, NextToken().is(tok::period), ParsedType(), /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/true, NeedType ? &CorrectedII : NULL)) { // A FixIt was applied as a result of typo correction if (CorrectedII) Tok.setIdentifierInfo(CorrectedII); // This is a typename. Replace the current token in-place with an // annotation type token. Tok.setKind(tok::annot_typename); setTypeAnnotation(Tok, Ty); Tok.setAnnotationEndLoc(Tok.getLocation()); if (SS.isNotEmpty()) // it was a C++ qualified type name. Tok.setLocation(SS.getBeginLoc()); // In case the tokens were cached, have Preprocessor replace // them with the annotation token. PP.AnnotateCachedTokens(Tok); return false; } if (!getLangOpts().CPlusPlus) { // If we're in C, we can't have :: tokens at all (the lexer won't return // them). If the identifier is not a type, then it can't be scope either, // just early exit. return false; } // If this is a template-id, annotate with a template-id or type token. if (NextToken().is(tok::less)) { TemplateTy Template; UnqualifiedId TemplateName; TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); bool MemberOfUnknownSpecialization; if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false, TemplateName, /*ObjectType=*/ ParsedType(), EnteringContext, Template, MemberOfUnknownSpecialization)) { // Consume the identifier. ConsumeToken(); if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(), TemplateName)) { // If an unrecoverable error occurred, we need to return true here, // because the token stream is in a damaged state. We may not return // a valid identifier. return true; } } } // The current token, which is either an identifier or a // template-id, is not part of the annotation. Fall through to // push that token back into the stream and complete the C++ scope // specifier annotation. } if (Tok.is(tok::annot_template_id)) { TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); if (TemplateId->Kind == TNK_Type_template) { // A template-id that refers to a type was parsed into a // template-id annotation in a context where we weren't allowed // to produce a type annotation token. Update the template-id // annotation token to a type annotation token now. AnnotateTemplateIdTokenAsType(); return false; } } if (SS.isEmpty()) return false; // A C++ scope specifier that isn't followed by a typename. AnnotateScopeToken(SS, IsNewScope); return false; } /// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only /// annotates C++ scope specifiers and template-ids. This returns /// true if there was an error that could not be recovered from. /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. bool Parser::TryAnnotateCXXScopeToken(bool EnteringContext) { assert(getLangOpts().CPlusPlus && "Call sites of this function should be guarded by checking for C++"); assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) || Tok.is(tok::kw_decltype)) && "Cannot be a type or scope token!"); CXXScopeSpec SS; if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext)) return true; if (SS.isEmpty()) return false; AnnotateScopeToken(SS, true); return false; } bool Parser::isTokenEqualOrEqualTypo() { tok::TokenKind Kind = Tok.getKind(); switch (Kind) { default: return false; case tok::ampequal: // &= case tok::starequal: // *= case tok::plusequal: // += case tok::minusequal: // -= case tok::exclaimequal: // != case tok::slashequal: // /= case tok::percentequal: // %= case tok::lessequal: // <= case tok::lesslessequal: // <<= case tok::greaterequal: // >= case tok::greatergreaterequal: // >>= case tok::caretequal: // ^= case tok::pipeequal: // |= case tok::equalequal: // == Diag(Tok, diag::err_invalid_token_after_declarator_suggest_equal) << Kind << FixItHint::CreateReplacement(SourceRange(Tok.getLocation()), "="); case tok::equal: return true; } } SourceLocation Parser::handleUnexpectedCodeCompletionToken() { assert(Tok.is(tok::code_completion)); PrevTokLocation = Tok.getLocation(); for (Scope *S = getCurScope(); S; S = S->getParent()) { if (S->getFlags() & Scope::FnScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction); cutOffParsing(); return PrevTokLocation; } if (S->getFlags() & Scope::ClassScope) { Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class); cutOffParsing(); return PrevTokLocation; } } Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace); cutOffParsing(); return PrevTokLocation; } // Anchor the Parser::FieldCallback vtable to this translation unit. // We use a spurious method instead of the destructor because // destroying FieldCallbacks can actually be slightly // performance-sensitive. void Parser::FieldCallback::_anchor() { } // Code-completion pass-through functions void Parser::CodeCompleteDirective(bool InConditional) { Actions.CodeCompletePreprocessorDirective(InConditional); } void Parser::CodeCompleteInConditionalExclusion() { Actions.CodeCompleteInPreprocessorConditionalExclusion(getCurScope()); } void Parser::CodeCompleteMacroName(bool IsDefinition) { Actions.CodeCompletePreprocessorMacroName(IsDefinition); } void Parser::CodeCompletePreprocessorExpression() { Actions.CodeCompletePreprocessorExpression(); } void Parser::CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned ArgumentIndex) { Actions.CodeCompletePreprocessorMacroArgument(getCurScope(), Macro, MacroInfo, ArgumentIndex); } void Parser::CodeCompleteNaturalLanguage() { Actions.CodeCompleteNaturalLanguage(); } bool Parser::ParseMicrosoftIfExistsCondition(IfExistsCondition& Result) { assert((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists)) && "Expected '__if_exists' or '__if_not_exists'"); Result.IsIfExists = Tok.is(tok::kw___if_exists); Result.KeywordLoc = ConsumeToken(); BalancedDelimiterTracker T(*this, tok::l_paren); if (T.consumeOpen()) { Diag(Tok, diag::err_expected_lparen_after) << (Result.IsIfExists? "__if_exists" : "__if_not_exists"); return true; } // Parse nested-name-specifier. ParseOptionalCXXScopeSpecifier(Result.SS, ParsedType(), /*EnteringContext=*/false); // Check nested-name specifier. if (Result.SS.isInvalid()) { T.skipToEnd(); return true; } // Parse the unqualified-id. SourceLocation TemplateKWLoc; // FIXME: parsed, but unused. if (ParseUnqualifiedId(Result.SS, false, true, true, ParsedType(), TemplateKWLoc, Result.Name)) { T.skipToEnd(); return true; } if (T.consumeClose()) return true; // Check if the symbol exists. switch (Actions.CheckMicrosoftIfExistsSymbol(getCurScope(), Result.KeywordLoc, Result.IsIfExists, Result.SS, Result.Name)) { case Sema::IER_Exists: Result.Behavior = Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_DoesNotExist: Result.Behavior = !Result.IsIfExists ? IEB_Parse : IEB_Skip; break; case Sema::IER_Dependent: Result.Behavior = IEB_Dependent; break; case Sema::IER_Error: return true; } return false; } void Parser::ParseMicrosoftIfExistsExternalDeclaration() { IfExistsCondition Result; if (ParseMicrosoftIfExistsCondition(Result)) return; BalancedDelimiterTracker Braces(*this, tok::l_brace); if (Braces.consumeOpen()) { Diag(Tok, diag::err_expected) << tok::l_brace; return; } switch (Result.Behavior) { case IEB_Parse: // Parse declarations below. break; case IEB_Dependent: llvm_unreachable("Cannot have a dependent external declaration"); case IEB_Skip: Braces.skipToEnd(); return; } // Parse the declarations. // FIXME: Support module import within __if_exists? while (Tok.isNot(tok::r_brace) && !isEofOrEom()) { ParsedAttributesWithRange attrs(AttrFactory); MaybeParseCXX11Attributes(attrs); MaybeParseMicrosoftAttributes(attrs); DeclGroupPtrTy Result = ParseExternalDeclaration(attrs); if (Result && !getCurScope()->getParent()) Actions.getASTConsumer().HandleTopLevelDecl(Result.get()); } Braces.consumeClose(); } Parser::DeclGroupPtrTy Parser::ParseModuleImport(SourceLocation AtLoc) { assert(Tok.isObjCAtKeyword(tok::objc_import) && "Improper start to module import"); SourceLocation ImportLoc = ConsumeToken(); SmallVector, 2> Path; // Parse the module path. do { if (!Tok.is(tok::identifier)) { if (Tok.is(tok::code_completion)) { Actions.CodeCompleteModuleImport(ImportLoc, Path); ConsumeCodeCompletionToken(); SkipUntil(tok::semi); return DeclGroupPtrTy(); } Diag(Tok, diag::err_module_expected_ident); SkipUntil(tok::semi); return DeclGroupPtrTy(); } // Record this part of the module path. Path.push_back(std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation())); ConsumeToken(); if (Tok.is(tok::period)) { ConsumeToken(); continue; } break; } while (true); if (PP.hadModuleLoaderFatalFailure()) { // With a fatal failure in the module loader, we abort parsing. cutOffParsing(); return DeclGroupPtrTy(); } DeclResult Import = Actions.ActOnModuleImport(AtLoc, ImportLoc, Path); ExpectAndConsumeSemi(diag::err_module_expected_semi); if (Import.isInvalid()) return DeclGroupPtrTy(); return Actions.ConvertDeclToDeclGroup(Import.get()); } bool BalancedDelimiterTracker::diagnoseOverflow() { P.Diag(P.Tok, diag::err_bracket_depth_exceeded) << P.getLangOpts().BracketDepth; P.Diag(P.Tok, diag::note_bracket_depth); P.cutOffParsing(); return true; } bool BalancedDelimiterTracker::expectAndConsume(unsigned DiagID, const char *Msg, tok::TokenKind SkipToTok) { LOpen = P.Tok.getLocation(); if (P.ExpectAndConsume(Kind, DiagID, Msg)) { if (SkipToTok != tok::unknown) P.SkipUntil(SkipToTok, Parser::StopAtSemi); return true; } if (getDepth() < MaxDepth) return false; return diagnoseOverflow(); } bool BalancedDelimiterTracker::diagnoseMissingClose() { assert(!P.Tok.is(Close) && "Should have consumed closing delimiter"); P.Diag(P.Tok, diag::err_expected) << Close; P.Diag(LOpen, diag::note_matching) << Kind; // If we're not already at some kind of closing bracket, skip to our closing // token. if (P.Tok.isNot(tok::r_paren) && P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::r_square) && P.SkipUntil(Close, FinalToken, Parser::StopAtSemi | Parser::StopBeforeMatch) && P.Tok.is(Close)) LClose = P.ConsumeAnyToken(); return true; } void BalancedDelimiterTracker::skipToEnd() { P.SkipUntil(Close, Parser::StopBeforeMatch); consumeClose(); } @