Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

namespace clang {

  class PragmaHandler;

  class Scope;

  class BalancedDelimiterTracker;

  class CorrectionCandidateCallback;

  class DeclGroupRef;

  class DiagnosticBuilder;

  struct LoopHint;

  class Parser;

  class ParsingDeclRAIIObject;

  class ParsingDeclSpec;

  class ParsingDeclarator;

  class ParsingFieldDeclarator;

  class ColonProtectionRAIIObject;

  class InMessageExpressionRAIIObject;

  class PoisonSEHIdentifiersRAIIObject;

  class OMPClause;

  class ObjCTypeParamList;

  struct OMPTraitProperty;

  struct OMPTraitSelector;

  struct OMPTraitSet;

  class OMPTraitInfo;

 

class Parser : public CodeCompletionHandler {

  friend class ColonProtectionRAIIObject;

  friend class ParsingOpenMPDirectiveRAII;

  friend class InMessageExpressionRAIIObject;

  friend class OffsetOfStateRAIIObject;

  friend class PoisonSEHIdentifiersRAIIObject;

  friend class ObjCDeclContextSwitch;

  friend class ParenBraceBracketBalancer;

  friend class BalancedDelimiterTracker;

 

  Preprocessor &PP;

 

  /// Tok - The current token we are peeking ahead.  All parsing methods assume

  /// that this is valid.

  Token Tok;

 

  // PrevTokLocation - The location of the token we previously

  // consumed. This token is used for diagnostics where we expected to

  // see a token following another token (e.g., the ';' at the end of

  // a statement).

  SourceLocation PrevTokLocation;

 

  /// Tracks an expected type for the current token when parsing an expression.

  /// Used by code completion for ranking.

  PreferredTypeBuilder PreferredType;

 

  unsigned short ParenCount = 0, BracketCount = 0, BraceCount = 0;

  unsigned short MisplacedModuleBeginCount = 0;

 

  /// Actions - These are the callbacks we invoke as we parse various constructs

  /// in the file.

  Sema &Actions;

 

  DiagnosticsEngine &Diags;

 

  /// ScopeCache - Cache scopes to reduce malloc traffic.

  enum { ScopeCacheSize = 16 };

  unsigned NumCachedScopes;

  Scope *ScopeCache[ScopeCacheSize];

 

  /// Identifiers used for SEH handling in Borland. These are only

  /// allowed in particular circumstances

  // __except block

  IdentifierInfo *Ident__exception_code,

                 *Ident___exception_code,

                 *Ident_GetExceptionCode;

  // __except filter expression

  IdentifierInfo *Ident__exception_info,

                 *Ident___exception_info,

                 *Ident_GetExceptionInfo;

  // __finally

  IdentifierInfo *Ident__abnormal_termination,

                 *Ident___abnormal_termination,

                 *Ident_AbnormalTermination;

 

  /// Contextual keywords for Microsoft extensions.

  IdentifierInfo *Ident__except;

  mutable IdentifierInfo *Ident_sealed;

  mutable IdentifierInfo *Ident_abstract;

 

  /// Ident_super - IdentifierInfo for "super", to support fast

  /// comparison.

  IdentifierInfo *Ident_super;

  /// Ident_vector, Ident_bool, Ident_Bool - cached IdentifierInfos for "vector"

  /// and "bool" fast comparison.  Only present if AltiVec or ZVector are

  /// enabled.

  IdentifierInfo *Ident_vector;

  IdentifierInfo *Ident_bool;

  IdentifierInfo *Ident_Bool;

  /// Ident_pixel - cached IdentifierInfos for "pixel" fast comparison.

  /// Only present if AltiVec enabled.

  IdentifierInfo *Ident_pixel;

 

  /// Objective-C contextual keywords.

  IdentifierInfo *Ident_instancetype;

 

  /// Identifier for "introduced".

  IdentifierInfo *Ident_introduced;

 

  /// Identifier for "deprecated".

  IdentifierInfo *Ident_deprecated;

 

  /// Identifier for "obsoleted".

  IdentifierInfo *Ident_obsoleted;

 

  /// Identifier for "unavailable".

  IdentifierInfo *Ident_unavailable;

 

  /// Identifier for "message".

  IdentifierInfo *Ident_message;

 

  /// Identifier for "strict".

  IdentifierInfo *Ident_strict;

 

  /// Identifier for "replacement".

  IdentifierInfo *Ident_replacement;

 

  /// Identifiers used by the 'external_source_symbol' attribute.

  IdentifierInfo *Ident_language, *Ident_defined_in,

      *Ident_generated_declaration;

 

  /// C++11 contextual keywords.

  mutable IdentifierInfo *Ident_final;

  mutable IdentifierInfo *Ident_GNU_final;

  mutable IdentifierInfo *Ident_override;

 

  // C++2a contextual keywords.

  mutable IdentifierInfo *Ident_import;

  mutable IdentifierInfo *Ident_module;

 

  // C++ type trait keywords that can be reverted to identifiers and still be

  // used as type traits.

  llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;

 

  std::unique_ptr<PragmaHandler> AlignHandler;

  std::unique_ptr<PragmaHandler> GCCVisibilityHandler;

  std::unique_ptr<PragmaHandler> OptionsHandler;

  std::unique_ptr<PragmaHandler> PackHandler;

  std::unique_ptr<PragmaHandler> MSStructHandler;

  std::unique_ptr<PragmaHandler> UnusedHandler;

  std::unique_ptr<PragmaHandler> WeakHandler;

  std::unique_ptr<PragmaHandler> RedefineExtnameHandler;

  std::unique_ptr<PragmaHandler> FPContractHandler;

  std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;

  std::unique_ptr<PragmaHandler> OpenMPHandler;

  std::unique_ptr<PragmaHandler> PCSectionHandler;

  std::unique_ptr<PragmaHandler> MSCommentHandler;

  std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;

  std::unique_ptr<PragmaHandler> FPEvalMethodHandler;

  std::unique_ptr<PragmaHandler> FloatControlHandler;

  std::unique_ptr<PragmaHandler> MSPointersToMembers;

  std::unique_ptr<PragmaHandler> MSVtorDisp;

  std::unique_ptr<PragmaHandler> MSInitSeg;

  std::unique_ptr<PragmaHandler> MSDataSeg;

  std::unique_ptr<PragmaHandler> MSBSSSeg;

  std::unique_ptr<PragmaHandler> MSConstSeg;

  std::unique_ptr<PragmaHandler> MSCodeSeg;

  std::unique_ptr<PragmaHandler> MSSection;

  std::unique_ptr<PragmaHandler> MSStrictGuardStackCheck;

  std::unique_ptr<PragmaHandler> MSRuntimeChecks;

  std::unique_ptr<PragmaHandler> MSIntrinsic;

  std::unique_ptr<PragmaHandler> MSFunction;

  std::unique_ptr<PragmaHandler> MSOptimize;

  std::unique_ptr<PragmaHandler> MSFenvAccess;

  std::unique_ptr<PragmaHandler> MSAllocText;

  std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;

  std::unique_ptr<PragmaHandler> OptimizeHandler;

  std::unique_ptr<PragmaHandler> LoopHintHandler;

  std::unique_ptr<PragmaHandler> UnrollHintHandler;

  std::unique_ptr<PragmaHandler> NoUnrollHintHandler;

  std::unique_ptr<PragmaHandler> UnrollAndJamHintHandler;

  std::unique_ptr<PragmaHandler> NoUnrollAndJamHintHandler;

  std::unique_ptr<PragmaHandler> FPHandler;

  std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;

  std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;

  std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;

  std::unique_ptr<PragmaHandler> STDCUnknownHandler;

  std::unique_ptr<PragmaHandler> AttributePragmaHandler;

  std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;

  std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;

  std::unique_ptr<PragmaHandler> RISCVPragmaHandler;

 

  std::unique_ptr<CommentHandler> CommentSemaHandler;

 

  /// Whether the '>' token acts as an operator or not. This will be

  /// true except when we are parsing an expression within a C++

  /// template argument list, where the '>' closes the template

  /// argument list.

  bool GreaterThanIsOperator;

 

  /// ColonIsSacred - When this is false, we aggressively try to recover from

  /// code like "foo : bar" as if it were a typo for "foo :: bar".  This is not

  /// safe in case statements and a few other things.  This is managed by the

  /// ColonProtectionRAIIObject RAII object.

  bool ColonIsSacred;

 

  /// Parsing OpenMP directive mode.

  bool OpenMPDirectiveParsing = false;

 

  /// When true, we are directly inside an Objective-C message

  /// send expression.

  ///

  /// This is managed by the \c InMessageExpressionRAIIObject class, and

  /// should not be set directly.

  bool InMessageExpression;

 

  /// Gets set to true after calling ProduceSignatureHelp, it is for a

  /// workaround to make sure ProduceSignatureHelp is only called at the deepest

  /// function call.

  bool CalledSignatureHelp = false;

 

  Sema::OffsetOfKind OffsetOfState = Sema::OffsetOfKind::OOK_Outside;

 

  /// The "depth" of the template parameters currently being parsed.

  unsigned TemplateParameterDepth;

 

  /// Current kind of OpenMP clause

  OpenMPClauseKind OMPClauseKind = llvm::omp::OMPC_unknown;

 

  /// RAII class that manages the template parameter depth.

  class TemplateParameterDepthRAII {

    unsigned &Depth;

    unsigned AddedLevels;

  public:

    explicit TemplateParameterDepthRAII(unsigned &Depth)

      : Depth(Depth), AddedLevels(0) {}

 

    ~TemplateParameterDepthRAII() {

      Depth -= AddedLevels;

    }

 

    void operator++() {

      ++Depth;

      ++AddedLevels;

    }

    void addDepth(unsigned D) {

      Depth += D;

      AddedLevels += D;

    }

    void setAddedDepth(unsigned D) {

      Depth = Depth - AddedLevels + D;

      AddedLevels = D;

    }

 

    unsigned getDepth() const { return Depth; }

    unsigned getOriginalDepth() const { return Depth - AddedLevels; }

  };

 

  /// Factory object for creating ParsedAttr objects.

  AttributeFactory AttrFactory;

 

  /// Gathers and cleans up TemplateIdAnnotations when parsing of a

  /// top-level declaration is finished.

  SmallVector<TemplateIdAnnotation *, 16> TemplateIds;

 

  void MaybeDestroyTemplateIds() {

    if (!TemplateIds.empty() &&

        (Tok.is(tok::eof) || !PP.mightHavePendingAnnotationTokens()))

      DestroyTemplateIds();

  }

  void DestroyTemplateIds();

 

  /// RAII object to destroy TemplateIdAnnotations where possible, from a

  /// likely-good position during parsing.

  struct DestroyTemplateIdAnnotationsRAIIObj {

    Parser &Self;

 

    DestroyTemplateIdAnnotationsRAIIObj(Parser &Self) : Self(Self) {}

    ~DestroyTemplateIdAnnotationsRAIIObj() { Self.MaybeDestroyTemplateIds(); }

  };

 

  /// Identifiers which have been declared within a tentative parse.

  SmallVector<IdentifierInfo *, 8> TentativelyDeclaredIdentifiers;

 

  /// Tracker for '<' tokens that might have been intended to be treated as an

  /// angle bracket instead of a less-than comparison.

  ///

  /// This happens when the user intends to form a template-id, but typoes the

  /// template-name or forgets a 'template' keyword for a dependent template

  /// name.

  ///

  /// We track these locations from the point where we see a '<' with a

  /// name-like expression on its left until we see a '>' or '>>' that might

  /// match it.

  struct AngleBracketTracker {

    /// Flags used to rank candidate template names when there is more than one

    /// '<' in a scope.

    enum Priority : unsigned short {

      /// A non-dependent name that is a potential typo for a template name.

      PotentialTypo = 0x0,

      /// A dependent name that might instantiate to a template-name.

      DependentName = 0x2,

 

      /// A space appears before the '<' token.

      SpaceBeforeLess = 0x0,

      /// No space before the '<' token

      NoSpaceBeforeLess = 0x1,

 

      LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue*/ DependentName)

    };

 

    struct Loc {

      Expr *TemplateName;

      SourceLocation LessLoc;

      AngleBracketTracker::Priority Priority;

      unsigned short ParenCount, BracketCount, BraceCount;

 

      bool isActive(Parser &P) const {

        return P.ParenCount == ParenCount && P.BracketCount == BracketCount &&

               P.BraceCount == BraceCount;

      }

 

      bool isActiveOrNested(Parser &P) const {

        return isActive(P) || P.ParenCount > ParenCount ||

               P.BracketCount > BracketCount || P.BraceCount > BraceCount;

      }

    };

 

    SmallVector<Loc, 8> Locs;

 

    /// Add an expression that might have been intended to be a template name.

    /// In the case of ambiguity, we arbitrarily select the innermost such

    /// expression, for example in 'foo < bar < baz', 'bar' is the current

    /// candidate. No attempt is made to track that 'foo' is also a candidate

    /// for the case where we see a second suspicious '>' token.

    void add(Parser &P, Expr *TemplateName, SourceLocation LessLoc,

             Priority Prio) {

      if (!Locs.empty() && Locs.back().isActive(P)) {

        if (Locs.back().Priority <= Prio) {

          Locs.back().TemplateName = TemplateName;

          Locs.back().LessLoc = LessLoc;

          Locs.back().Priority = Prio;

        }

      } else {

        Locs.push_back({TemplateName, LessLoc, Prio,

                        P.ParenCount, P.BracketCount, P.BraceCount});

      }

    }

 

    /// Mark the current potential missing template location as having been

    /// handled (this happens if we pass a "corresponding" '>' or '>>' token

    /// or leave a bracket scope).

    void clear(Parser &P) {

      while (!Locs.empty() && Locs.back().isActiveOrNested(P))

        Locs.pop_back();

    }

 

    /// Get the current enclosing expression that might hve been intended to be

    /// a template name.

    Loc *getCurrent(Parser &P) {

      if (!Locs.empty() && Locs.back().isActive(P))

        return &Locs.back();

      return nullptr;

    }

  };

 

  AngleBracketTracker AngleBrackets;

 

  IdentifierInfo *getSEHExceptKeyword();

 

  /// True if we are within an Objective-C container while parsing C-like decls.

  ///

  /// This is necessary because Sema thinks we have left the container

  /// to parse the C-like decls, meaning Actions.getObjCDeclContext() will

  /// be NULL.

  bool ParsingInObjCContainer;

 

  /// Whether to skip parsing of function bodies.

  ///

  /// This option can be used, for example, to speed up searches for

  /// declarations/definitions when indexing.

  bool SkipFunctionBodies;

 

  /// The location of the expression statement that is being parsed right now.

  /// Used to determine if an expression that is being parsed is a statement or

  /// just a regular sub-expression.

  SourceLocation ExprStatementTokLoc;

 

  /// Flags describing a context in which we're parsing a statement.

  enum class ParsedStmtContext {

    /// This context permits declarations in language modes where declarations

    /// are not statements.

    AllowDeclarationsInC = 0x1,

    /// This context permits standalone OpenMP directives.

    AllowStandaloneOpenMPDirectives = 0x2,

    /// This context is at the top level of a GNU statement expression.

    InStmtExpr = 0x4,

 

    /// The context of a regular substatement.

    SubStmt = 0,

    /// The context of a compound-statement.

    Compound = AllowDeclarationsInC | AllowStandaloneOpenMPDirectives,

 

    LLVM_MARK_AS_BITMASK_ENUM(InStmtExpr)

  };

 

  /// Act on an expression statement that might be the last statement in a

  /// GNU statement expression. Checks whether we are actually at the end of

  /// a statement expression and builds a suitable expression statement.

  StmtResult handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx);

 

  Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);

  ~Parser() override;

 

  const LangOptions &getLangOpts() const { return PP.getLangOpts(); }

  const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }

  Preprocessor &getPreprocessor() const { return PP; }

  Sema &getActions() const { return Actions; }

  AttributeFactory &getAttrFactory() { return AttrFactory; }

 

  const Token &getCurToken() const { return Tok; }

  Scope *getCurScope() const { return Actions.getCurScope(); }

  void incrementMSManglingNumber() const {

    return Actions.incrementMSManglingNumber();

  }

 

  ObjCContainerDecl *getObjCDeclContext() const {

    return Actions.getObjCDeclContext();

  }

 

  // Type forwarding.  All of these are statically 'void*', but they may all be

  // different actual classes based on the actions in place.

  typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;

  typedef OpaquePtr<TemplateName> TemplateTy;

 

  typedef SmallVector<TemplateParameterList *, 4> TemplateParameterLists;

 

  typedef Sema::FullExprArg FullExprArg;

 

  /// A SmallVector of statements.

  typedef SmallVector<Stmt *, 32> StmtVector;

 

  // Parsing methods.

 

  /// Initialize - Warm up the parser.

  ///

  void Initialize();

 

  /// Parse the first top-level declaration in a translation unit.

  bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result,

                              Sema::ModuleImportState &ImportState);

 

  /// ParseTopLevelDecl - Parse one top-level declaration. Returns true if

  /// the EOF was encountered.

  bool ParseTopLevelDecl(DeclGroupPtrTy &Result,

                         Sema::ModuleImportState &ImportState);

  bool ParseTopLevelDecl() {

    DeclGroupPtrTy Result;

    Sema::ModuleImportState IS = Sema::ModuleImportState::NotACXX20Module;

    return ParseTopLevelDecl(Result, IS);

  }

 

  /// ConsumeToken - Consume the current 'peek token' and lex the next one.

  /// This does not work with special tokens: string literals, code completion,

  /// annotation tokens and balanced tokens must be handled using the specific

  /// consume methods.

  /// Returns the location of the consumed token.

  SourceLocation ConsumeToken() {

    assert(!isTokenSpecial() &&

           "Should consume special tokens with Consume*Token");

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  bool TryConsumeToken(tok::TokenKind Expected) {

    if (Tok.isNot(Expected))

      return false;

    assert(!isTokenSpecial() &&

           "Should consume special tokens with Consume*Token");

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return true;

  }

 

  bool TryConsumeToken(tok::TokenKind Expected, SourceLocation &Loc) {

    if (!TryConsumeToken(Expected))

      return false;

    Loc = PrevTokLocation;

    return true;

  }

 

  /// ConsumeAnyToken - Dispatch to the right Consume* method based on the

  /// current token type.  This should only be used in cases where the type of

  /// the token really isn't known, e.g. in error recovery.

  SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok = false) {

    if (isTokenParen())

      return ConsumeParen();

    if (isTokenBracket())

      return ConsumeBracket();

    if (isTokenBrace())

      return ConsumeBrace();

    if (isTokenStringLiteral())

      return ConsumeStringToken();

    if (Tok.is(tok::code_completion))

      return ConsumeCodeCompletionTok ? ConsumeCodeCompletionToken()

                                      : handleUnexpectedCodeCompletionToken();

    if (Tok.isAnnotation())

      return ConsumeAnnotationToken();

    return ConsumeToken();

  }

 

 

  SourceLocation getEndOfPreviousToken() {

    return PP.getLocForEndOfToken(PrevTokLocation);

  }

 

  /// Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds

  /// to the given nullability kind.

  IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability) {

    return Actions.getNullabilityKeyword(nullability);

  }

 

  //===--------------------------------------------------------------------===//

  // Low-Level token peeking and consumption methods.

  //

 

  /// isTokenParen - Return true if the cur token is '(' or ')'.

  bool isTokenParen() const {

    return Tok.isOneOf(tok::l_paren, tok::r_paren);

  }

  /// isTokenBracket - Return true if the cur token is '[' or ']'.

  bool isTokenBracket() const {

    return Tok.isOneOf(tok::l_square, tok::r_square);

  }

  /// isTokenBrace - Return true if the cur token is '{' or '}'.

  bool isTokenBrace() const {

    return Tok.isOneOf(tok::l_brace, tok::r_brace);

  }

  /// isTokenStringLiteral - True if this token is a string-literal.

  bool isTokenStringLiteral() const {

    return tok::isStringLiteral(Tok.getKind());

  }

  /// isTokenSpecial - True if this token requires special consumption methods.

  bool isTokenSpecial() const {

    return isTokenStringLiteral() || isTokenParen() || isTokenBracket() ||

           isTokenBrace() || Tok.is(tok::code_completion) || Tok.isAnnotation();

  }

 

  /// Returns true if the current token is '=' or is a type of '='.

  /// For typos, give a fixit to '='

  bool isTokenEqualOrEqualTypo();

 

  /// Return the current token to the token stream and make the given

  /// token the current token.

  void UnconsumeToken(Token &Consumed) {

      Token Next = Tok;

      PP.EnterToken(Consumed, /*IsReinject*/true);

      PP.Lex(Tok);

      PP.EnterToken(Next, /*IsReinject*/true);

  }

 

  SourceLocation ConsumeAnnotationToken() {

    assert(Tok.isAnnotation() && "wrong consume method");

    SourceLocation Loc = Tok.getLocation();

    PrevTokLocation = Tok.getAnnotationEndLoc();

    PP.Lex(Tok);

    return Loc;

  }

 

  /// ConsumeParen - This consume method keeps the paren count up-to-date.

  ///

  SourceLocation ConsumeParen() {

    assert(isTokenParen() && "wrong consume method");

    if (Tok.getKind() == tok::l_paren)

      ++ParenCount;

    else if (ParenCount) {

      AngleBrackets.clear(*this);

      --ParenCount;       // Don't let unbalanced )'s drive the count negative.

    }

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  /// ConsumeBracket - This consume method keeps the bracket count up-to-date.

  ///

  SourceLocation ConsumeBracket() {

    assert(isTokenBracket() && "wrong consume method");

    if (Tok.getKind() == tok::l_square)

      ++BracketCount;

    else if (BracketCount) {

      AngleBrackets.clear(*this);

      --BracketCount;     // Don't let unbalanced ]'s drive the count negative.

    }

 

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  /// ConsumeBrace - This consume method keeps the brace count up-to-date.

  ///

  SourceLocation ConsumeBrace() {

    assert(isTokenBrace() && "wrong consume method");

    if (Tok.getKind() == tok::l_brace)

      ++BraceCount;

    else if (BraceCount) {

      AngleBrackets.clear(*this);

      --BraceCount;     // Don't let unbalanced }'s drive the count negative.

    }

 

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  /// ConsumeStringToken - Consume the current 'peek token', lexing a new one

  /// and returning the token kind.  This method is specific to strings, as it

  /// handles string literal concatenation, as per C99 5.1.1.2, translation

  /// phase #6.

  SourceLocation ConsumeStringToken() {

    assert(isTokenStringLiteral() &&

           "Should only consume string literals with this method");

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  /// Consume the current code-completion token.

  ///

  /// This routine can be called to consume the code-completion token and

  /// continue processing in special cases where \c cutOffParsing() isn't

  /// desired, such as token caching or completion with lookahead.

  SourceLocation ConsumeCodeCompletionToken() {

    assert(Tok.is(tok::code_completion));

    PrevTokLocation = Tok.getLocation();

    PP.Lex(Tok);

    return PrevTokLocation;

  }

 

  ///\ brief When we are consuming a code-completion token without having

  /// matched specific position in the grammar, provide code-completion results

  /// based on context.

  ///

  /// \returns the source location of the code-completion token.

  SourceLocation handleUnexpectedCodeCompletionToken();

 

  /// Abruptly cut off parsing; mainly used when we have reached the

  /// code-completion point.

  void cutOffParsing() {

    if (PP.isCodeCompletionEnabled())

      PP.setCodeCompletionReached();

    // Cut off parsing by acting as if we reached the end-of-file.

    Tok.setKind(tok::eof);

  }

 

  /// Determine if we're at the end of the file or at a transition

  /// between modules.

  bool isEofOrEom() {

    tok::TokenKind Kind = Tok.getKind();

    return Kind == tok::eof || Kind == tok::annot_module_begin ||

           Kind == tok::annot_module_end || Kind == tok::annot_module_include;

  }

 

  /// Checks if the \p Level is valid for use in a fold expression.

  bool isFoldOperator(prec::Level Level) const;

 

  /// Checks if the \p Kind is a valid operator for fold expressions.

  bool isFoldOperator(tok::TokenKind Kind) const;

 

  /// Initialize all pragma handlers.

  void initializePragmaHandlers();

 

  /// Destroy and reset all pragma handlers.

  void resetPragmaHandlers();

 

  /// Handle the annotation token produced for #pragma unused(...)

  void HandlePragmaUnused();

 

  /// Handle the annotation token produced for

  /// #pragma GCC visibility...

  void HandlePragmaVisibility();

 

  /// Handle the annotation token produced for

  /// #pragma pack...

  void HandlePragmaPack();

 

  /// Handle the annotation token produced for

  /// #pragma ms_struct...

  void HandlePragmaMSStruct();

 

  void HandlePragmaMSPointersToMembers();

 

  void HandlePragmaMSVtorDisp();

 

  void HandlePragmaMSPragma();

  bool HandlePragmaMSSection(StringRef PragmaName,

                             SourceLocation PragmaLocation);

  bool HandlePragmaMSSegment(StringRef PragmaName,

                             SourceLocation PragmaLocation);

  bool HandlePragmaMSInitSeg(StringRef PragmaName,

                             SourceLocation PragmaLocation);

  bool HandlePragmaMSStrictGuardStackCheck(StringRef PragmaName,

                                           SourceLocation PragmaLocation);

  bool HandlePragmaMSFunction(StringRef PragmaName,

                              SourceLocation PragmaLocation);

  bool HandlePragmaMSAllocText(StringRef PragmaName,

                               SourceLocation PragmaLocation);

  bool HandlePragmaMSOptimize(StringRef PragmaName,

                              SourceLocation PragmaLocation);

 

  /// Handle the annotation token produced for

  /// #pragma align...

  void HandlePragmaAlign();

 

  /// Handle the annotation token produced for

  /// #pragma clang __debug dump...

  void HandlePragmaDump();

 

  /// Handle the annotation token produced for

  /// #pragma weak id...

  void HandlePragmaWeak();

 

  /// Handle the annotation token produced for

  /// #pragma weak id = id...

  void HandlePragmaWeakAlias();

 

  /// Handle the annotation token produced for

  /// #pragma redefine_extname...

  void HandlePragmaRedefineExtname();

 

  /// Handle the annotation token produced for

  /// #pragma STDC FP_CONTRACT...

  void HandlePragmaFPContract();

 

  /// Handle the annotation token produced for

  /// #pragma STDC FENV_ACCESS...

  void HandlePragmaFEnvAccess();

 

  /// Handle the annotation token produced for

  /// #pragma STDC FENV_ROUND...

  void HandlePragmaFEnvRound();

 

  /// Handle the annotation token produced for

  /// #pragma float_control

  void HandlePragmaFloatControl();

 

  /// \brief Handle the annotation token produced for

  /// #pragma clang fp ...

  void HandlePragmaFP();

 

  /// Handle the annotation token produced for

  /// #pragma OPENCL EXTENSION...

  void HandlePragmaOpenCLExtension();

 

  /// Handle the annotation token produced for

  /// #pragma clang __debug captured

  StmtResult HandlePragmaCaptured();

 

  /// Handle the annotation token produced for

  /// #pragma clang loop and #pragma unroll.

  bool HandlePragmaLoopHint(LoopHint &Hint);

 

  bool ParsePragmaAttributeSubjectMatchRuleSet(

      attr::ParsedSubjectMatchRuleSet &SubjectMatchRules,

      SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc);

 

  void HandlePragmaAttribute();

 

  /// GetLookAheadToken - This peeks ahead N tokens and returns that token

  /// without consuming any tokens.  LookAhead(0) returns 'Tok', LookAhead(1)

  /// returns the token after Tok, etc.

  ///

  /// Note that this differs from the Preprocessor's LookAhead method, because

  /// the Parser always has one token lexed that the preprocessor doesn't.

  ///

  const Token &GetLookAheadToken(unsigned N) {

    if (N == 0 || Tok.is(tok::eof)) return Tok;

    return PP.LookAhead(N-1);

  }

 

  /// NextToken - This peeks ahead one token and returns it without

  /// consuming it.

  const Token &NextToken() {

    return PP.LookAhead(0);

  }

 

  /// getTypeAnnotation - Read a parsed type out of an annotation token.

  static TypeResult getTypeAnnotation(const Token &Tok) {

    if (!Tok.getAnnotationValue())

      return TypeError();

    return ParsedType::getFromOpaquePtr(Tok.getAnnotationValue());

  }

 

  static void setTypeAnnotation(Token &Tok, TypeResult T) {

    assert((T.isInvalid() || T.get()) &&

           "produced a valid-but-null type annotation?");

    Tok.setAnnotationValue(T.isInvalid() ? nullptr : T.get().getAsOpaquePtr());

  }

 

  static NamedDecl *getNonTypeAnnotation(const Token &Tok) {

    return static_cast<NamedDecl*>(Tok.getAnnotationValue());

  }

 

  static void setNonTypeAnnotation(Token &Tok, NamedDecl *ND) {

    Tok.setAnnotationValue(ND);

  }

 

  static IdentifierInfo *getIdentifierAnnotation(const Token &Tok) {

    return static_cast<IdentifierInfo*>(Tok.getAnnotationValue());

  }

 

  static void setIdentifierAnnotation(Token &Tok, IdentifierInfo *ND) {

    Tok.setAnnotationValue(ND);

  }

 

  /// Read an already-translated primary expression out of an annotation

  /// token.

  static ExprResult getExprAnnotation(const Token &Tok) {

    return ExprResult::getFromOpaquePointer(Tok.getAnnotationValue());

  }

 

  /// Set the primary expression corresponding to the given annotation

  /// token.

  static void setExprAnnotation(Token &Tok, ExprResult ER) {

    Tok.setAnnotationValue(ER.getAsOpaquePointer());

  }

 

  // If NeedType is true, then TryAnnotateTypeOrScopeToken will try harder to

  // find a type name by attempting typo correction.

  bool

  TryAnnotateTypeOrScopeToken(ImplicitTypenameContext AllowImplicitTypename =

                                  ImplicitTypenameContext::No);

  bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(

      CXXScopeSpec &SS, bool IsNewScope,

      ImplicitTypenameContext AllowImplicitTypename);

  bool TryAnnotateCXXScopeToken(bool EnteringContext = false);

 

  bool MightBeCXXScopeToken() {

    return getLangOpts().CPlusPlus &&

           (Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||

            (Tok.is(tok::annot_template_id) &&

             NextToken().is(tok::coloncolon)) ||

            Tok.is(tok::kw_decltype) || Tok.is(tok::kw___super));

  }

  bool TryAnnotateOptionalCXXScopeToken(bool EnteringContext = false) {

    return MightBeCXXScopeToken() && TryAnnotateCXXScopeToken(EnteringContext);

  }

 

  enum AnnotatedNameKind {

    /// Annotation has failed and emitted an error.

    ANK_Error,

    /// The identifier is a tentatively-declared name.

    ANK_TentativeDecl,

    /// The identifier is a template name. FIXME: Add an annotation for that.

    ANK_TemplateName,

    /// The identifier can't be resolved.

    ANK_Unresolved,

    /// Annotation was successful.

    ANK_Success

  };

 

  AnnotatedNameKind

  TryAnnotateName(CorrectionCandidateCallback *CCC = nullptr,

                  ImplicitTypenameContext AllowImplicitTypename =

                      ImplicitTypenameContext::No);

 

  /// Push a tok::annot_cxxscope token onto the token stream.

  void AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation);

 

  /// TryAltiVecToken - Check for context-sensitive AltiVec identifier tokens,

  /// replacing them with the non-context-sensitive keywords.  This returns

  /// true if the token was replaced.

  bool TryAltiVecToken(DeclSpec &DS, SourceLocation Loc,

                       const char *&PrevSpec, unsigned &DiagID,

                       bool &isInvalid) {

    if (!getLangOpts().AltiVec && !getLangOpts().ZVector)

      return false;

 

    if (Tok.getIdentifierInfo() != Ident_vector &&

        Tok.getIdentifierInfo() != Ident_bool &&

        Tok.getIdentifierInfo() != Ident_Bool &&

        (!getLangOpts().AltiVec || Tok.getIdentifierInfo() != Ident_pixel))

      return false;

 

    return TryAltiVecTokenOutOfLine(DS, Loc, PrevSpec, DiagID, isInvalid);

  }

 

  /// TryAltiVecVectorToken - Check for context-sensitive AltiVec vector

  /// identifier token, replacing it with the non-context-sensitive __vector.

  /// This returns true if the token was replaced.

  bool TryAltiVecVectorToken() {

    if ((!getLangOpts().AltiVec && !getLangOpts().ZVector) ||

        Tok.getIdentifierInfo() != Ident_vector) return false;

    return TryAltiVecVectorTokenOutOfLine();

  }

 

  bool TryAltiVecVectorTokenOutOfLine();

  bool TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,

                                const char *&PrevSpec, unsigned &DiagID,

                                bool &isInvalid);

 

  /// Returns true if the current token is the identifier 'instancetype'.

  ///

  /// Should only be used in Objective-C language modes.

  bool isObjCInstancetype() {

    assert(getLangOpts().ObjC);

    if (Tok.isAnnotation())

      return false;

    if (!Ident_instancetype)

      Ident_instancetype = PP.getIdentifierInfo("instancetype");

    return Tok.getIdentifierInfo() == Ident_instancetype;

  }

 

  /// TryKeywordIdentFallback - For compatibility with system headers using

  /// keywords as identifiers, attempt to convert the current token to an

  /// identifier and optionally disable the keyword for the remainder of the

  /// translation unit. This returns false if the token was not replaced,

  /// otherwise emits a diagnostic and returns true.

  bool TryKeywordIdentFallback(bool DisableKeyword);

 

  /// Get the TemplateIdAnnotation from the token.

  TemplateIdAnnotation *takeTemplateIdAnnotation(const Token &tok);

 

  /// TentativeParsingAction - An object that is used as a kind of "tentative

  /// parsing transaction". It gets instantiated to mark the token position and

  /// after the token consumption is done, Commit() or Revert() is called to

  /// either "commit the consumed tokens" or revert to the previously marked

  /// token position. Example:

  ///

  ///   TentativeParsingAction TPA(*this);

  ///   ConsumeToken();

  ///   ....

  ///   TPA.Revert();

  ///

  class TentativeParsingAction {

    Parser &P;

    PreferredTypeBuilder PrevPreferredType;

    Token PrevTok;

    size_t PrevTentativelyDeclaredIdentifierCount;

    unsigned short PrevParenCount, PrevBracketCount, PrevBraceCount;

    bool isActive;

 

  public:

    explicit TentativeParsingAction(Parser &p)

        : P(p), PrevPreferredType(P.PreferredType) {

      PrevTok = P.Tok;

      PrevTentativelyDeclaredIdentifierCount =

          P.TentativelyDeclaredIdentifiers.size();

      PrevParenCount = P.ParenCount;

      PrevBracketCount = P.BracketCount;

      PrevBraceCount = P.BraceCount;

      P.PP.EnableBacktrackAtThisPos();

      isActive = true;

    }

    void Commit() {

      assert(isActive && "Parsing action was finished!");

      P.TentativelyDeclaredIdentifiers.resize(

          PrevTentativelyDeclaredIdentifierCount);

      P.PP.CommitBacktrackedTokens();

      isActive = false;

    }

    void Revert() {

      assert(isActive && "Parsing action was finished!");

      P.PP.Backtrack();

      P.PreferredType = PrevPreferredType;

      P.Tok = PrevTok;

      P.TentativelyDeclaredIdentifiers.resize(

          PrevTentativelyDeclaredIdentifierCount);

      P.ParenCount = PrevParenCount;

      P.BracketCount = PrevBracketCount;

      P.BraceCount = PrevBraceCount;

      isActive = false;

    }

    ~TentativeParsingAction() {

      assert(!isActive && "Forgot to call Commit or Revert!");

    }

  };

  /// A TentativeParsingAction that automatically reverts in its destructor.

  /// Useful for disambiguation parses that will always be reverted.

  class RevertingTentativeParsingAction

      : private Parser::TentativeParsingAction {

  public:

    RevertingTentativeParsingAction(Parser &P)

        : Parser::TentativeParsingAction(P) {}

    ~RevertingTentativeParsingAction() { Revert(); }

  };

 

  class UnannotatedTentativeParsingAction;

 

  /// ObjCDeclContextSwitch - An object used to switch context from

  /// an objective-c decl context to its enclosing decl context and

  /// back.

  class ObjCDeclContextSwitch {

    Parser &P;

    ObjCContainerDecl *DC;

    SaveAndRestore<bool> WithinObjCContainer;

  public:

    explicit ObjCDeclContextSwitch(Parser &p)

      : P(p), DC(p.getObjCDeclContext()),

        WithinObjCContainer(P.ParsingInObjCContainer, DC != nullptr) {

      if (DC)

        P.Actions.ActOnObjCTemporaryExitContainerContext(DC);

    }

    ~ObjCDeclContextSwitch() {

      if (DC)

        P.Actions.ActOnObjCReenterContainerContext(DC);

    }

  };

 

  /// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the

  /// input.  If so, it is consumed and false is returned.

  ///

  /// If a trivial punctuator misspelling is encountered, a FixIt error

  /// diagnostic is issued and false is returned after recovery.

  ///

  /// If the input is malformed, this emits the specified diagnostic and true is

  /// returned.

  bool ExpectAndConsume(tok::TokenKind ExpectedTok,

                        unsigned Diag = diag::err_expected,

                        StringRef DiagMsg = "");

 

  /// The parser expects a semicolon and, if present, will consume it.

  ///

  /// If the next token is not a semicolon, this emits the specified diagnostic,

  /// or, if there's just some closing-delimiter noise (e.g., ')' or ']') prior

  /// to the semicolon, consumes that extra token.

  bool ExpectAndConsumeSemi(unsigned DiagID , StringRef TokenUsed = "");

 

  /// The kind of extra semi diagnostic to emit.

  enum ExtraSemiKind {

    OutsideFunction = 0,

    InsideStruct = 1,

    InstanceVariableList = 2,

    AfterMemberFunctionDefinition = 3

  };

 

  /// Consume any extra semi-colons until the end of the line.

  void ConsumeExtraSemi(ExtraSemiKind Kind, DeclSpec::TST T = TST_unspecified);

 

  /// Return false if the next token is an identifier. An 'expected identifier'

  /// error is emitted otherwise.

  ///

  /// The parser tries to recover from the error by checking if the next token

  /// is a C++ keyword when parsing Objective-C++. Return false if the recovery

  /// was successful.

  bool expectIdentifier();

 

  /// Kinds of compound pseudo-tokens formed by a sequence of two real tokens.

  enum class CompoundToken {

    /// A '(' '{' beginning a statement-expression.

    StmtExprBegin,

    /// A '}' ')' ending a statement-expression.

    StmtExprEnd,

    /// A '[' '[' beginning a C++11 or C2x attribute.

    AttrBegin,

    /// A ']' ']' ending a C++11 or C2x attribute.

    AttrEnd,

    /// A '::' '*' forming a C++ pointer-to-member declaration.

    MemberPtr,

  };

 

  /// Check that a compound operator was written in a "sensible" way, and warn

  /// if not.

  void checkCompoundToken(SourceLocation FirstTokLoc,

                          tok::TokenKind FirstTokKind, CompoundToken Op);

 

  //===--------------------------------------------------------------------===//

  // Scope manipulation

 

  /// ParseScope - Introduces a new scope for parsing. The kind of

  /// scope is determined by ScopeFlags. Objects of this type should

  /// be created on the stack to coincide with the position where the

  /// parser enters the new scope, and this object's constructor will

  /// create that new scope. Similarly, once the object is destroyed

  /// the parser will exit the scope.

  class ParseScope {

    Parser *Self;

    ParseScope(const ParseScope &) = delete;

    void operator=(const ParseScope &) = delete;

 

  public:

    // ParseScope - Construct a new object to manage a scope in the

    // parser Self where the new Scope is created with the flags

    // ScopeFlags, but only when we aren't about to enter a compound statement.

    ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope = true,

               bool BeforeCompoundStmt = false)

      : Self(Self) {

      if (EnteredScope && !BeforeCompoundStmt)

        Self->EnterScope(ScopeFlags);

      else {

        if (BeforeCompoundStmt)

          Self->incrementMSManglingNumber();

 

        this->Self = nullptr;

      }

    }

 

    // Exit - Exit the scope associated with this object now, rather

    // than waiting until the object is destroyed.

    void Exit() {

      if (Self) {

        Self->ExitScope();

        Self = nullptr;

      }

    }

 

    ~ParseScope() {

      Exit();

    }

  };

 

  /// Introduces zero or more scopes for parsing. The scopes will all be exited

  /// when the object is destroyed.

  class MultiParseScope {

    Parser &Self;

    unsigned NumScopes = 0;

 

    MultiParseScope(const MultiParseScope&) = delete;

 

  public:

    MultiParseScope(Parser &Self) : Self(Self) {}

    void Enter(unsigned ScopeFlags) {

      Self.EnterScope(ScopeFlags);

      ++NumScopes;

    }

    void Exit() {

      while (NumScopes) {

        Self.ExitScope();

        --NumScopes;

      }

    }

    ~MultiParseScope() {

      Exit();

    }

  };

 

  /// EnterScope - Start a new scope.

  void EnterScope(unsigned ScopeFlags);

 

  /// ExitScope - Pop a scope off the scope stack.

  void ExitScope();

 

  /// Re-enter the template scopes for a declaration that might be a template.

  unsigned ReenterTemplateScopes(MultiParseScope &S, Decl *D);

 

  /// RAII object used to modify the scope flags for the current scope.

  class ParseScopeFlags {

    Scope *CurScope;

    unsigned OldFlags;

    ParseScopeFlags(const ParseScopeFlags &) = delete;

    void operator=(const ParseScopeFlags &) = delete;

 

  public:

    ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags = true);

    ~ParseScopeFlags();

  };

 

  //===--------------------------------------------------------------------===//

  // Diagnostic Emission and Error recovery.

 

  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);

  DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID);

  DiagnosticBuilder Diag(unsigned DiagID) {

    return Diag(Tok, DiagID);

  }

 

  void SuggestParentheses(SourceLocation Loc, unsigned DK,

                          SourceRange ParenRange);

  void CheckNestedObjCContexts(SourceLocation AtLoc);

 

 

  /// Control flags for SkipUntil functions.

  enum SkipUntilFlags {

    StopAtSemi = 1 << 0,  ///< Stop skipping at semicolon

    /// Stop skipping at specified token, but don't skip the token itself

    StopBeforeMatch = 1 << 1,

    StopAtCodeCompletion = 1 << 2 ///< Stop at code completion

  };

 

  friend constexpr SkipUntilFlags operator|(SkipUntilFlags L,

                                            SkipUntilFlags R) {

    return static_cast<SkipUntilFlags>(static_cast<unsigned>(L) |

                                       static_cast<unsigned>(R));

  }

 

  /// SkipUntil - Read tokens until we get to the specified token, then consume

  /// it (unless StopBeforeMatch is specified).  Because we cannot guarantee

  /// that the token will ever occur, this skips to the next token, or to some

  /// likely good stopping point.  If Flags has StopAtSemi flag, skipping will

  /// stop at a ';' character. Balances (), [], and {} delimiter tokens while

  /// skipping.

  ///

  /// If SkipUntil finds the specified token, it returns true, otherwise it

  /// returns false.

  bool SkipUntil(tok::TokenKind T,

                 SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {

    return SkipUntil(llvm::ArrayRef(T), Flags);

  }

  bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2,

                 SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {

    tok::TokenKind TokArray[] = {T1, T2};

    return SkipUntil(TokArray, Flags);

  }

  bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3,

                 SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {

    tok::TokenKind TokArray[] = {T1, T2, T3};

    return SkipUntil(TokArray, Flags);

  }

  bool SkipUntil(ArrayRef<tok::TokenKind> Toks,

                 SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0));

 

  /// SkipMalformedDecl - Read tokens until we get to some likely good stopping

  /// point for skipping past a simple-declaration.

  void SkipMalformedDecl();

 

  /// The location of the first statement inside an else that might

  /// have a missleading indentation. If there is no

  /// MisleadingIndentationChecker on an else active, this location is invalid.

  SourceLocation MisleadingIndentationElseLoc;

 

  //===--------------------------------------------------------------------===//

  // Lexing and parsing of C++ inline methods.

 

  struct ParsingClass;

 

  /// [class.mem]p1: "... the class is regarded as complete within

  /// - function bodies

  /// - default arguments

  /// - exception-specifications (TODO: C++0x)

  /// - and brace-or-equal-initializers for non-static data members

  /// (including such things in nested classes)."

  /// LateParsedDeclarations build the tree of those elements so they can

  /// be parsed after parsing the top-level class.

  class LateParsedDeclaration {

  public:

    virtual ~LateParsedDeclaration();

 

    virtual void ParseLexedMethodDeclarations();

    virtual void ParseLexedMemberInitializers();

    virtual void ParseLexedMethodDefs();

    virtual void ParseLexedAttributes();

    virtual void ParseLexedPragmas();

  };

 

  /// Inner node of the LateParsedDeclaration tree that parses

  /// all its members recursively.

  class LateParsedClass : public LateParsedDeclaration {

  public:

    LateParsedClass(Parser *P, ParsingClass *C);

    ~LateParsedClass() override;

 

    void ParseLexedMethodDeclarations() override;

    void ParseLexedMemberInitializers() override;

    void ParseLexedMethodDefs() override;

    void ParseLexedAttributes() override;

    void ParseLexedPragmas() override;

 

  private:

    Parser *Self;

    ParsingClass *Class;

  };

 

  /// Contains the lexed tokens of an attribute with arguments that

  /// may reference member variables and so need to be parsed at the

  /// end of the class declaration after parsing all other member

  /// member declarations.

  /// FIXME: Perhaps we should change the name of LateParsedDeclaration to

  /// LateParsedTokens.

  struct LateParsedAttribute : public LateParsedDeclaration {

    Parser *Self;

    CachedTokens Toks;

    IdentifierInfo &AttrName;

    IdentifierInfo *MacroII = nullptr;

    SourceLocation AttrNameLoc;

    SmallVector<Decl*, 2> Decls;

 

    explicit LateParsedAttribute(Parser *P, IdentifierInfo &Name,

                                 SourceLocation Loc)

      : Self(P), AttrName(Name), AttrNameLoc(Loc) {}

 

    void ParseLexedAttributes() override;

 

    void addDecl(Decl *D) { Decls.push_back(D); }

  };

 

  /// Contains the lexed tokens of a pragma with arguments that

  /// may reference member variables and so need to be parsed at the

  /// end of the class declaration after parsing all other member

  /// member declarations.

  class LateParsedPragma : public LateParsedDeclaration {

    Parser *Self = nullptr;

    AccessSpecifier AS = AS_none;

    CachedTokens Toks;

 

  public:

    explicit LateParsedPragma(Parser *P, AccessSpecifier AS)

        : Self(P), AS(AS) {}

 

    void takeToks(CachedTokens &Cached) { Toks.swap(Cached); }

    const CachedTokens &toks() const { return Toks; }

    AccessSpecifier getAccessSpecifier() const { return AS; }

 

    void ParseLexedPragmas() override;

  };

 

  // A list of late-parsed attributes.  Used by ParseGNUAttributes.

  class LateParsedAttrList: public SmallVector<LateParsedAttribute *, 2> {

  public:

    LateParsedAttrList(bool PSoon = false) : ParseSoon(PSoon) { }

 

    bool parseSoon() { return ParseSoon; }

 

  private:

    bool ParseSoon;  // Are we planning to parse these shortly after creation?

  };

 

  /// Contains the lexed tokens of a member function definition

  /// which needs to be parsed at the end of the class declaration

  /// after parsing all other member declarations.

  struct LexedMethod : public LateParsedDeclaration {

    Parser *Self;

    Decl *D;

    CachedTokens Toks;

 

    explicit LexedMethod(Parser *P, Decl *MD) : Self(P), D(MD) {}

 

    void ParseLexedMethodDefs() override;

  };

 

  /// LateParsedDefaultArgument - Keeps track of a parameter that may

  /// have a default argument that cannot be parsed yet because it

  /// occurs within a member function declaration inside the class

  /// (C++ [class.mem]p2).

  struct LateParsedDefaultArgument {

    explicit LateParsedDefaultArgument(Decl *P,

                                       std::unique_ptr<CachedTokens> Toks = nullptr)

      : Param(P), Toks(std::move(Toks)) { }

 

    /// Param - The parameter declaration for this parameter.

    Decl *Param;

 

    /// Toks - The sequence of tokens that comprises the default

    /// argument expression, not including the '=' or the terminating

    /// ')' or ','. This will be NULL for parameters that have no

    /// default argument.

    std::unique_ptr<CachedTokens> Toks;

  };

 

  /// LateParsedMethodDeclaration - A method declaration inside a class that

  /// contains at least one entity whose parsing needs to be delayed

  /// until the class itself is completely-defined, such as a default

  /// argument (C++ [class.mem]p2).

  struct LateParsedMethodDeclaration : public LateParsedDeclaration {

    explicit LateParsedMethodDeclaration(Parser *P, Decl *M)

        : Self(P), Method(M), ExceptionSpecTokens(nullptr) {}

 

    void ParseLexedMethodDeclarations() override;

 

    Parser *Self;

 

    /// Method - The method declaration.

    Decl *Method;

 

    /// DefaultArgs - Contains the parameters of the function and

    /// their default arguments. At least one of the parameters will

    /// have a default argument, but all of the parameters of the

    /// method will be stored so that they can be reintroduced into

    /// scope at the appropriate times.

    SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;

 

    /// The set of tokens that make up an exception-specification that

    /// has not yet been parsed.

    CachedTokens *ExceptionSpecTokens;

  };

 

  /// LateParsedMemberInitializer - An initializer for a non-static class data

  /// member whose parsing must to be delayed until the class is completely

  /// defined (C++11 [class.mem]p2).

  struct LateParsedMemberInitializer : public LateParsedDeclaration {

    LateParsedMemberInitializer(Parser *P, Decl *FD)

      : Self(P), Field(FD) { }

 

    void ParseLexedMemberInitializers() override;

 

    Parser *Self;

 

    /// Field - The field declaration.

    Decl *Field;

 

    /// CachedTokens - The sequence of tokens that comprises the initializer,

    /// including any leading '='.

    CachedTokens Toks;

  };

 

  /// LateParsedDeclarationsContainer - During parsing of a top (non-nested)

  /// C++ class, its method declarations that contain parts that won't be

  /// parsed until after the definition is completed (C++ [class.mem]p2),

  /// the method declarations and possibly attached inline definitions

  /// will be stored here with the tokens that will be parsed to create those

  /// entities.

  typedef SmallVector<LateParsedDeclaration*,2> LateParsedDeclarationsContainer;

 

  /// Representation of a class that has been parsed, including

  /// any member function declarations or definitions that need to be

  /// parsed after the corresponding top-level class is complete.

  struct ParsingClass {

    ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)

        : TopLevelClass(TopLevelClass), IsInterface(IsInterface),

          TagOrTemplate(TagOrTemplate) {}

 

    /// Whether this is a "top-level" class, meaning that it is

    /// not nested within another class.

    bool TopLevelClass : 1;

 

    /// Whether this class is an __interface.

    bool IsInterface : 1;

 

    /// The class or class template whose definition we are parsing.

    Decl *TagOrTemplate;

 

    /// LateParsedDeclarations - Method declarations, inline definitions and

    /// nested classes that contain pieces whose parsing will be delayed until

    /// the top-level class is fully defined.

    LateParsedDeclarationsContainer LateParsedDeclarations;

  };

 

  /// The stack of classes that is currently being

  /// parsed. Nested and local classes will be pushed onto this stack

  /// when they are parsed, and removed afterward.

  std::stack<ParsingClass *> ClassStack;

 

  ParsingClass &getCurrentClass() {

    assert(!ClassStack.empty() && "No lexed method stacks!");

    return *ClassStack.top();

  }

 

  /// RAII object used to manage the parsing of a class definition.

  class ParsingClassDefinition {

    Parser &P;

    bool Popped;

    Sema::ParsingClassState State;

 

  public:

    ParsingClassDefinition(Parser &P, Decl *TagOrTemplate, bool TopLevelClass,

                           bool IsInterface)

      : P(P), Popped(false),

        State(P.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {

    }

 

    /// Pop this class of the stack.

    void Pop() {

      assert(!Popped && "Nested class has already been popped");

      Popped = true;

      P.PopParsingClass(State);

    }

 

    ~ParsingClassDefinition() {

      if (!Popped)

        P.PopParsingClass(State);

    }

  };

 

  /// Contains information about any template-specific

  /// information that has been parsed prior to parsing declaration

  /// specifiers.

  struct ParsedTemplateInfo {

    ParsedTemplateInfo() : Kind(NonTemplate), TemplateParams(nullptr) {}

 

    ParsedTemplateInfo(TemplateParameterLists *TemplateParams,

                       bool isSpecialization,

                       bool lastParameterListWasEmpty = false)

      : Kind(isSpecialization? ExplicitSpecialization : Template),

        TemplateParams(TemplateParams),

        LastParameterListWasEmpty(lastParameterListWasEmpty) { }

 

    explicit ParsedTemplateInfo(SourceLocation ExternLoc,

                                SourceLocation TemplateLoc)

      : Kind(ExplicitInstantiation), TemplateParams(nullptr),

        ExternLoc(ExternLoc), TemplateLoc(TemplateLoc),

        LastParameterListWasEmpty(false){ }

 

    /// The kind of template we are parsing.

    enum {

      /// We are not parsing a template at all.

      NonTemplate = 0,

      /// We are parsing a template declaration.

      Template,

      /// We are parsing an explicit specialization.

      ExplicitSpecialization,

      /// We are parsing an explicit instantiation.

      ExplicitInstantiation

    } Kind;

 

    /// The template parameter lists, for template declarations

    /// and explicit specializations.

    TemplateParameterLists *TemplateParams;

 

    /// The location of the 'extern' keyword, if any, for an explicit

    /// instantiation

    SourceLocation ExternLoc;

 

    /// The location of the 'template' keyword, for an explicit

    /// instantiation.

    SourceLocation TemplateLoc;

 

    /// Whether the last template parameter list was empty.

    bool LastParameterListWasEmpty;

 

    SourceRange getSourceRange() const LLVM_READONLY;

  };

 

  // In ParseCXXInlineMethods.cpp.

  struct ReenterTemplateScopeRAII;

  struct ReenterClassScopeRAII;

 

  void LexTemplateFunctionForLateParsing(CachedTokens &Toks);

  void ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);

 

  static void LateTemplateParserCallback(void *P, LateParsedTemplate &LPT);

 

  Sema::ParsingClassState

  PushParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface);

  void DeallocateParsedClasses(ParsingClass *Class);

  void PopParsingClass(Sema::ParsingClassState);

 

  enum CachedInitKind {

    CIK_DefaultArgument,

    CIK_DefaultInitializer

  };

 

  NamedDecl *ParseCXXInlineMethodDef(AccessSpecifier AS,

                                     const ParsedAttributesView &AccessAttrs,

                                     ParsingDeclarator &D,

                                     const ParsedTemplateInfo &TemplateInfo,

                                     const VirtSpecifiers &VS,

                                     SourceLocation PureSpecLoc);

  void ParseCXXNonStaticMemberInitializer(Decl *VarD);

  void ParseLexedAttributes(ParsingClass &Class);

  void ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,

                               bool EnterScope, bool OnDefinition);

  void ParseLexedAttribute(LateParsedAttribute &LA,

                           bool EnterScope, bool OnDefinition);

  void ParseLexedMethodDeclarations(ParsingClass &Class);

  void ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);

  void ParseLexedMethodDefs(ParsingClass &Class);

  void ParseLexedMethodDef(LexedMethod &LM);

  void ParseLexedMemberInitializers(ParsingClass &Class);

  void ParseLexedMemberInitializer(LateParsedMemberInitializer &MI);

  void ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod);

  void ParseLexedPragmas(ParsingClass &Class);

  void ParseLexedPragma(LateParsedPragma &LP);

  bool ConsumeAndStoreFunctionPrologue(CachedTokens &Toks);

  bool ConsumeAndStoreInitializer(CachedTokens &Toks, CachedInitKind CIK);

  bool ConsumeAndStoreConditional(CachedTokens &Toks);

  bool ConsumeAndStoreUntil(tok::TokenKind T1,

                            CachedTokens &Toks,

                            bool StopAtSemi = true,

                            bool ConsumeFinalToken = true) {

    return ConsumeAndStoreUntil(T1, T1, Toks, StopAtSemi, ConsumeFinalToken);

  }

  bool ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,

                            CachedTokens &Toks,

                            bool StopAtSemi = true,

                            bool ConsumeFinalToken = true);

 

  //===--------------------------------------------------------------------===//

  // C99 6.9: External Definitions.

  DeclGroupPtrTy ParseExternalDeclaration(ParsedAttributes &DeclAttrs,

                                          ParsedAttributes &DeclSpecAttrs,

                                          ParsingDeclSpec *DS = nullptr);

  bool isDeclarationAfterDeclarator();

  bool isStartOfFunctionDefinition(const ParsingDeclarator &Declarator);

  DeclGroupPtrTy ParseDeclarationOrFunctionDefinition(

      ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs,

      ParsingDeclSpec *DS = nullptr, AccessSpecifier AS = AS_none);

  DeclGroupPtrTy ParseDeclOrFunctionDefInternal(ParsedAttributes &Attrs,

                                                ParsedAttributes &DeclSpecAttrs,

                                                ParsingDeclSpec &DS,

                                                AccessSpecifier AS);

 

  void SkipFunctionBody();

  Decl *ParseFunctionDefinition(ParsingDeclarator &D,

                 const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),

                 LateParsedAttrList *LateParsedAttrs = nullptr);

  void ParseKNRParamDeclarations(Declarator &D);

  // EndLoc is filled with the location of the last token of the simple-asm.

  ExprResult ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc);

  ExprResult ParseAsmStringLiteral(bool ForAsmLabel);

 

  // Objective-C External Declarations

  void MaybeSkipAttributes(tok::ObjCKeywordKind Kind);

  DeclGroupPtrTy ParseObjCAtDirectives(ParsedAttributes &DeclAttrs,

                                       ParsedAttributes &DeclSpecAttrs);

  DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc);

  Decl *ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,

                                        ParsedAttributes &prefixAttrs);

  class ObjCTypeParamListScope;

  ObjCTypeParamList *parseObjCTypeParamList();

  ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(

      ObjCTypeParamListScope &Scope, SourceLocation &lAngleLoc,

      SmallVectorImpl<IdentifierLocPair> &protocolIdents,

      SourceLocation &rAngleLoc, bool mayBeProtocolList = true);

 

  void HelperActionsForIvarDeclarations(ObjCContainerDecl *interfaceDecl,

                                        SourceLocation atLoc,

                                        BalancedDelimiterTracker &T,

                                        SmallVectorImpl<Decl *> &AllIvarDecls,

                                        bool RBraceMissing);

  void ParseObjCClassInstanceVariables(ObjCContainerDecl *interfaceDecl,

                                       tok::ObjCKeywordKind visibility,

                                       SourceLocation atLoc);

  bool ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &P,

                                   SmallVectorImpl<SourceLocation> &PLocs,

                                   bool WarnOnDeclarations,

                                   bool ForObjCContainer,

                                   SourceLocation &LAngleLoc,

                                   SourceLocation &EndProtoLoc,

                                   bool consumeLastToken);

 

  /// Parse the first angle-bracket-delimited clause for an

  /// Objective-C object or object pointer type, which may be either

  /// type arguments or protocol qualifiers.

  void parseObjCTypeArgsOrProtocolQualifiers(

         ParsedType baseType,

         SourceLocation &typeArgsLAngleLoc,

         SmallVectorImpl<ParsedType> &typeArgs,

         SourceLocation &typeArgsRAngleLoc,

         SourceLocation &protocolLAngleLoc,

         SmallVectorImpl<Decl *> &protocols,

         SmallVectorImpl<SourceLocation> &protocolLocs,

         SourceLocation &protocolRAngleLoc,

         bool consumeLastToken,

         bool warnOnIncompleteProtocols);

 

  /// Parse either Objective-C type arguments or protocol qualifiers; if the

  /// former, also parse protocol qualifiers afterward.

  void parseObjCTypeArgsAndProtocolQualifiers(

         ParsedType baseType,

         SourceLocation &typeArgsLAngleLoc,

         SmallVectorImpl<ParsedType> &typeArgs,

         SourceLocation &typeArgsRAngleLoc,

         SourceLocation &protocolLAngleLoc,

         SmallVectorImpl<Decl *> &protocols,

         SmallVectorImpl<SourceLocation> &protocolLocs,

         SourceLocation &protocolRAngleLoc,

         bool consumeLastToken);

 

  /// Parse a protocol qualifier type such as '<NSCopying>', which is

  /// an anachronistic way of writing 'id<NSCopying>'.

  TypeResult parseObjCProtocolQualifierType(SourceLocation &rAngleLoc);

 

  /// Parse Objective-C type arguments and protocol qualifiers, extending the

  /// current type with the parsed result.

  TypeResult parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,

                                                    ParsedType type,

                                                    bool consumeLastToken,

                                                    SourceLocation &endLoc);

 

  void ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,

                                  Decl *CDecl);

  DeclGroupPtrTy ParseObjCAtProtocolDeclaration(SourceLocation atLoc,

                                                ParsedAttributes &prefixAttrs);

 

  struct ObjCImplParsingDataRAII {

    Parser &P;

    Decl *Dcl;

    bool HasCFunction;

    typedef SmallVector<LexedMethod*, 8> LateParsedObjCMethodContainer;

    LateParsedObjCMethodContainer LateParsedObjCMethods;

 

    ObjCImplParsingDataRAII(Parser &parser, Decl *D)

      : P(parser), Dcl(D), HasCFunction(false) {

      P.CurParsedObjCImpl = this;

      Finished = false;

    }

    ~ObjCImplParsingDataRAII();

 

    void finish(SourceRange AtEnd);

    bool isFinished() const { return Finished; }

 

  private:

    bool Finished;

  };

  ObjCImplParsingDataRAII *CurParsedObjCImpl;

  void StashAwayMethodOrFunctionBodyTokens(Decl *MDecl);

 

  DeclGroupPtrTy ParseObjCAtImplementationDeclaration(SourceLocation AtLoc,

                                                      ParsedAttributes &Attrs);

  DeclGroupPtrTy ParseObjCAtEndDeclaration(SourceRange atEnd);

  Decl *ParseObjCAtAliasDeclaration(SourceLocation atLoc);

  Decl *ParseObjCPropertySynthesize(SourceLocation atLoc);

  Decl *ParseObjCPropertyDynamic(SourceLocation atLoc);

 

  IdentifierInfo *ParseObjCSelectorPiece(SourceLocation &MethodLocation);

  // Definitions for Objective-c context sensitive keywords recognition.

  enum ObjCTypeQual {

    objc_in=0, objc_out, objc_inout, objc_oneway, objc_bycopy, objc_byref,

    objc_nonnull, objc_nullable, objc_null_unspecified,

    objc_NumQuals

  };

  IdentifierInfo *ObjCTypeQuals[objc_NumQuals];

 

  bool isTokIdentifier_in() const;

 

  ParsedType ParseObjCTypeName(ObjCDeclSpec &DS, DeclaratorContext Ctx,

                               ParsedAttributes *ParamAttrs);

  Decl *ParseObjCMethodPrototype(

            tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,

            bool MethodDefinition = true);

  Decl *ParseObjCMethodDecl(SourceLocation mLoc, tok::TokenKind mType,

            tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,

            bool MethodDefinition=true);

  void ParseObjCPropertyAttribute(ObjCDeclSpec &DS);

 

  Decl *ParseObjCMethodDefinition();

 

  //===--------------------------------------------------------------------===//

  // C99 6.5: Expressions.

 

  /// TypeCastState - State whether an expression is or may be a type cast.

  enum TypeCastState {

    NotTypeCast = 0,

    MaybeTypeCast,

    IsTypeCast

  };

 

  ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast);

  ExprResult ParseConstantExpressionInExprEvalContext(

      TypeCastState isTypeCast = NotTypeCast);

  ExprResult ParseConstantExpression();

  ExprResult ParseCaseExpression(SourceLocation CaseLoc);

  ExprResult ParseConstraintExpression();