Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

namespace clang {

 

class ASTContext;

struct ASTTemplateArgumentListInfo;

class CompoundStmt;

class DependentFunctionTemplateSpecializationInfo;

class EnumDecl;

class Expr;

class FunctionTemplateDecl;

class FunctionTemplateSpecializationInfo;

class FunctionTypeLoc;

class LabelStmt;

class MemberSpecializationInfo;

class Module;

class NamespaceDecl;

class ParmVarDecl;

class RecordDecl;

class Stmt;

class StringLiteral;

class TagDecl;

class TemplateArgumentList;

class TemplateArgumentListInfo;

class TemplateParameterList;

class TypeAliasTemplateDecl;

class UnresolvedSetImpl;

class VarTemplateDecl;

 

class TranslationUnitDecl : public Decl,

                            public DeclContext,

                            public Redeclarable<TranslationUnitDecl> {

  using redeclarable_base = Redeclarable<TranslationUnitDecl>;

 

  TranslationUnitDecl *getNextRedeclarationImpl() override {

    return getNextRedeclaration();

  }

 

  TranslationUnitDecl *getPreviousDeclImpl() override {

    return getPreviousDecl();

  }

 

  TranslationUnitDecl *getMostRecentDeclImpl() override {

    return getMostRecentDecl();

  }

 

  ASTContext &Ctx;

 

  /// The (most recently entered) anonymous namespace for this

  /// translation unit, if one has been created.

  NamespaceDecl *AnonymousNamespace = nullptr;

 

  explicit TranslationUnitDecl(ASTContext &ctx);

 

  virtual void anchor();

 

  using redecl_range = redeclarable_base::redecl_range;

  using redecl_iterator = redeclarable_base::redecl_iterator;

 

  using redeclarable_base::getMostRecentDecl;

  using redeclarable_base::getPreviousDecl;

  using redeclarable_base::isFirstDecl;

  using redeclarable_base::redecls;

  using redeclarable_base::redecls_begin;

  using redeclarable_base::redecls_end;

 

  ASTContext &getASTContext() const { return Ctx; }

 

  NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }

  void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }

 

  static TranslationUnitDecl *Create(ASTContext &C);

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == TranslationUnit; }

  static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {

    return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));

  }

  static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {

    return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));

  }

 

class PragmaCommentDecl final

    : public Decl,

      private llvm::TrailingObjects<PragmaCommentDecl, char> {

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  friend TrailingObjects;

 

  PragmaMSCommentKind CommentKind;

 

  PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,

                    PragmaMSCommentKind CommentKind)

      : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}

 

  virtual void anchor();

 

  static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,

                                   SourceLocation CommentLoc,

                                   PragmaMSCommentKind CommentKind,

                                   StringRef Arg);

  static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,

                                               unsigned ArgSize);

 

  PragmaMSCommentKind getCommentKind() const { return CommentKind; }

 

  StringRef getArg() const { return getTrailingObjects<char>(); }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == PragmaComment; }

 

class PragmaDetectMismatchDecl final

    : public Decl,

      private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  friend TrailingObjects;

 

  size_t ValueStart;

 

  PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,

                           size_t ValueStart)

      : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}

 

  virtual void anchor();

 

  static PragmaDetectMismatchDecl *Create(const ASTContext &C,

                                          TranslationUnitDecl *DC,

                                          SourceLocation Loc, StringRef Name,

                                          StringRef Value);

  static PragmaDetectMismatchDecl *

  CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);

 

  StringRef getName() const { return getTrailingObjects<char>(); }

  StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }

 

class ExternCContextDecl : public Decl, public DeclContext {

  explicit ExternCContextDecl(TranslationUnitDecl *TU)

    : Decl(ExternCContext, TU, SourceLocation()),

      DeclContext(ExternCContext) {}

 

  virtual void anchor();

 

  static ExternCContextDecl *Create(const ASTContext &C,

                                    TranslationUnitDecl *TU);

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == ExternCContext; }

  static DeclContext *castToDeclContext(const ExternCContextDecl *D) {

    return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));

  }

  static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {

    return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));

  }

 

class NamedDecl : public Decl {

  /// The name of this declaration, which is typically a normal

  /// identifier but may also be a special kind of name (C++

  /// constructor, Objective-C selector, etc.)

  DeclarationName Name;

 

  virtual void anchor();

 

  NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;

 

  NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)

      : Decl(DK, DC, L), Name(N) {}

 

  /// Get the identifier that names this declaration, if there is one.

  ///

  /// This will return NULL if this declaration has no name (e.g., for

  /// an unnamed class) or if the name is a special name (C++ constructor,

  /// Objective-C selector, etc.).

  IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }

 

  /// Get the name of identifier for this declaration as a StringRef.

  ///

  /// This requires that the declaration have a name and that it be a simple

  /// identifier.

  StringRef getName() const {

    assert(Name.isIdentifier() && "Name is not a simple identifier");

    return getIdentifier() ? getIdentifier()->getName() : "";

  }

 

  /// Get a human-readable name for the declaration, even if it is one of the

  /// special kinds of names (C++ constructor, Objective-C selector, etc).

  ///

  /// Creating this name requires expensive string manipulation, so it should

  /// be called only when performance doesn't matter. For simple declarations,

  /// getNameAsCString() should suffice.

  //

  // FIXME: This function should be renamed to indicate that it is not just an

  // alternate form of getName(), and clients should move as appropriate.

  //

  // FIXME: Deprecated, move clients to getName().

  std::string getNameAsString() const { return Name.getAsString(); }

 

  /// Pretty-print the unqualified name of this declaration. Can be overloaded

  /// by derived classes to provide a more user-friendly name when appropriate.

  virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const;

  /// Calls printName() with the ASTContext printing policy from the decl.

  void printName(raw_ostream &OS) const;

 

  /// Get the actual, stored name of the declaration, which may be a special

  /// name.

  ///

  /// Note that generally in diagnostics, the non-null \p NamedDecl* itself

  /// should be sent into the diagnostic instead of using the result of

  /// \p getDeclName().

  ///

  /// A \p DeclarationName in a diagnostic will just be streamed to the output,

  /// which will directly result in a call to \p DeclarationName::print.

  ///

  /// A \p NamedDecl* in a diagnostic will also ultimately result in a call to

  /// \p DeclarationName::print, but with two customisation points along the

  /// way (\p getNameForDiagnostic and \p printName). These are used to print

  /// the template arguments if any, and to provide a user-friendly name for

  /// some entities (such as unnamed variables and anonymous records).

  DeclarationName getDeclName() const { return Name; }

 

  /// Set the name of this declaration.

  void setDeclName(DeclarationName N) { Name = N; }

 

  /// Returns a human-readable qualified name for this declaration, like

  /// A::B::i, for i being member of namespace A::B.

  ///

  /// If the declaration is not a member of context which can be named (record,

  /// namespace), it will return the same result as printName().

  ///

  /// Creating this name is expensive, so it should be called only when

  /// performance doesn't matter.

  void printQualifiedName(raw_ostream &OS) const;

  void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;

 

  /// Print only the nested name specifier part of a fully-qualified name,

  /// including the '::' at the end. E.g.

  ///    when `printQualifiedName(D)` prints "A::B::i",

  ///    this function prints "A::B::".

  void printNestedNameSpecifier(raw_ostream &OS) const;

  void printNestedNameSpecifier(raw_ostream &OS,

                                const PrintingPolicy &Policy) const;

 

  // FIXME: Remove string version.

  std::string getQualifiedNameAsString() const;

 

  /// Appends a human-readable name for this declaration into the given stream.

  ///

  /// This is the method invoked by Sema when displaying a NamedDecl

  /// in a diagnostic.  It does not necessarily produce the same

  /// result as printName(); for example, class template

  /// specializations are printed with their template arguments.

  virtual void getNameForDiagnostic(raw_ostream &OS,

                                    const PrintingPolicy &Policy,

                                    bool Qualified) const;

 

  /// Determine whether this declaration, if known to be well-formed within

  /// its context, will replace the declaration OldD if introduced into scope.

  ///

  /// A declaration will replace another declaration if, for example, it is

  /// a redeclaration of the same variable or function, but not if it is a

  /// declaration of a different kind (function vs. class) or an overloaded

  /// function.

  ///

  /// \param IsKnownNewer \c true if this declaration is known to be newer

  /// than \p OldD (for instance, if this declaration is newly-created).

  bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;

 

  /// Determine whether this declaration has linkage.

  bool hasLinkage() const;

 

  using Decl::isModulePrivate;

  using Decl::setModulePrivate;

 

  /// Determine whether this declaration is a C++ class member.

  bool isCXXClassMember() const {

    const DeclContext *DC = getDeclContext();

 

    // C++0x [class.mem]p1:

    //   The enumerators of an unscoped enumeration defined in

    //   the class are members of the class.

    if (isa<EnumDecl>(DC))

      DC = DC->getRedeclContext();

 

    return DC->isRecord();

  }

 

  /// Determine whether the given declaration is an instance member of

  /// a C++ class.

  bool isCXXInstanceMember() const;

 

  /// Determine if the declaration obeys the reserved identifier rules of the

  /// given language.

  ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;

 

  /// Determine what kind of linkage this entity has.

  ///

  /// This is not the linkage as defined by the standard or the codegen notion

  /// of linkage. It is just an implementation detail that is used to compute

  /// those.

  Linkage getLinkageInternal() const;

 

  /// Get the linkage from a semantic point of view. Entities in

  /// anonymous namespaces are external (in c++98).

  Linkage getFormalLinkage() const {

    return clang::getFormalLinkage(getLinkageInternal());

  }

 

  /// True if this decl has external linkage.

  bool hasExternalFormalLinkage() const {

    return isExternalFormalLinkage(getLinkageInternal());

  }

 

  bool isExternallyVisible() const {

    return clang::isExternallyVisible(getLinkageInternal());

  }

 

  /// Determine whether this declaration can be redeclared in a

  /// different translation unit.

  bool isExternallyDeclarable() const {

    return isExternallyVisible() && !getOwningModuleForLinkage();

  }

 

  /// Determines the visibility of this entity.

  Visibility getVisibility() const {

    return getLinkageAndVisibility().getVisibility();

  }

 

  /// Determines the linkage and visibility of this entity.

  LinkageInfo getLinkageAndVisibility() const;

 

  /// Kinds of explicit visibility.

  enum ExplicitVisibilityKind {

    /// Do an LV computation for, ultimately, a type.

    /// Visibility may be restricted by type visibility settings and

    /// the visibility of template arguments.

    VisibilityForType,

 

    /// Do an LV computation for, ultimately, a non-type declaration.

    /// Visibility may be restricted by value visibility settings and

    /// the visibility of template arguments.

    VisibilityForValue

  };

 

  /// If visibility was explicitly specified for this

  /// declaration, return that visibility.

  std::optional<Visibility>

  getExplicitVisibility(ExplicitVisibilityKind kind) const;

 

  /// True if the computed linkage is valid. Used for consistency

  /// checking. Should always return true.

  bool isLinkageValid() const;

 

  /// True if something has required us to compute the linkage

  /// of this declaration.

  ///

  /// Language features which can retroactively change linkage (like a

  /// typedef name for linkage purposes) may need to consider this,

  /// but hopefully only in transitory ways during parsing.

  bool hasLinkageBeenComputed() const {

    return hasCachedLinkage();

  }

 

  /// Looks through UsingDecls and ObjCCompatibleAliasDecls for

  /// the underlying named decl.

  NamedDecl *getUnderlyingDecl() {

    // Fast-path the common case.

    if (this->getKind() != UsingShadow &&

        this->getKind() != ConstructorUsingShadow &&

        this->getKind() != ObjCCompatibleAlias &&

        this->getKind() != NamespaceAlias)

      return this;

 

    return getUnderlyingDeclImpl();

  }

  const NamedDecl *getUnderlyingDecl() const {

    return const_cast<NamedDecl*>(this)->getUnderlyingDecl();

  }

 

  NamedDecl *getMostRecentDecl() {

    return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());

  }

  const NamedDecl *getMostRecentDecl() const {

    return const_cast<NamedDecl*>(this)->getMostRecentDecl();

  }

 

  ObjCStringFormatFamily getObjCFStringFormattingFamily() const;

 

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }

 

inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {

  ND.printName(OS);

  return OS;

 

class LabelDecl : public NamedDecl {

  LabelStmt *TheStmt;

  StringRef MSAsmName;

  bool MSAsmNameResolved = false;

 

  /// For normal labels, this is the same as the main declaration

  /// label, i.e., the location of the identifier; for GNU local labels,

  /// this is the location of the __label__ keyword.

  SourceLocation LocStart;

 

  LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,

            LabelStmt *S, SourceLocation StartL)

      : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}

 

  void anchor() override;

 

  static LabelDecl *Create(ASTContext &C, DeclContext *DC,

                           SourceLocation IdentL, IdentifierInfo *II);

  static LabelDecl *Create(ASTContext &C, DeclContext *DC,

                           SourceLocation IdentL, IdentifierInfo *II,

                           SourceLocation GnuLabelL);

  static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);

 

  LabelStmt *getStmt() const { return TheStmt; }

  void setStmt(LabelStmt *T) { TheStmt = T; }

 

  bool isGnuLocal() const { return LocStart != getLocation(); }

  void setLocStart(SourceLocation L) { LocStart = L; }

 

  SourceRange getSourceRange() const override LLVM_READONLY {

    return SourceRange(LocStart, getLocation());

  }

 

  bool isMSAsmLabel() const { return !MSAsmName.empty(); }

  bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }

  void setMSAsmLabel(StringRef Name);

  StringRef getMSAsmLabel() const { return MSAsmName; }

  void setMSAsmLabelResolved() { MSAsmNameResolved = true; }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == Label; }

 

class NamespaceDecl : public NamedDecl, public DeclContext,

                      public Redeclarable<NamespaceDecl>

 

  enum Flags : unsigned { F_Inline = 1 << 0, F_Nested = 1 << 1 };

 

  /// The starting location of the source range, pointing

  /// to either the namespace or the inline keyword.

  SourceLocation LocStart;

 

  /// The ending location of the source range.

  SourceLocation RBraceLoc;

 

  /// A pointer to either the anonymous namespace that lives just inside

  /// this namespace or to the first namespace in the chain (the latter case

  /// only when this is not the first in the chain), along with a

  /// boolean value indicating whether this is an inline namespace.

  llvm::PointerIntPair<NamespaceDecl *, 2, unsigned>

      AnonOrFirstNamespaceAndFlags;

 

  NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,

                SourceLocation StartLoc, SourceLocation IdLoc,

                IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested);

 

  using redeclarable_base = Redeclarable<NamespaceDecl>;

 

  NamespaceDecl *getNextRedeclarationImpl() override;

  NamespaceDecl *getPreviousDeclImpl() override;

  NamespaceDecl *getMostRecentDeclImpl() override;

 

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

 

  static NamespaceDecl *Create(ASTContext &C, DeclContext *DC, bool Inline,

                               SourceLocation StartLoc, SourceLocation IdLoc,

                               IdentifierInfo *Id, NamespaceDecl *PrevDecl,

                               bool Nested);

 

  static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);

 

  using redecl_range = redeclarable_base::redecl_range;

  using redecl_iterator = redeclarable_base::redecl_iterator;

 

  using redeclarable_base::redecls_begin;

  using redeclarable_base::redecls_end;

  using redeclarable_base::redecls;

  using redeclarable_base::getPreviousDecl;

  using redeclarable_base::getMostRecentDecl;

  using redeclarable_base::isFirstDecl;

 

  /// Returns true if this is an anonymous namespace declaration.

  ///

  /// For example:

  /// \code

  ///   namespace {

  ///     ...

  ///   };

  /// \endcode

  /// q.v. C++ [namespace.unnamed]

  bool isAnonymousNamespace() const {

    return !getIdentifier();

  }

 

  /// Returns true if this is an inline namespace declaration.

  bool isInline() const {

    return AnonOrFirstNamespaceAndFlags.getInt() & F_Inline;

  }

 

  /// Set whether this is an inline namespace declaration.

  void setInline(bool Inline) {

    unsigned F = AnonOrFirstNamespaceAndFlags.getInt();

    if (Inline)

      AnonOrFirstNamespaceAndFlags.setInt(F | F_Inline);

    else

      AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Inline);

  }

 

  /// Returns true if this is a nested namespace declaration.

  /// \code

  /// namespace outer::nested { }

  /// \endcode

  bool isNested() const {

    return AnonOrFirstNamespaceAndFlags.getInt() & F_Nested;

  }

 

  /// Set whether this is a nested namespace declaration.

  void setNested(bool Nested) {

    unsigned F = AnonOrFirstNamespaceAndFlags.getInt();

    if (Nested)

      AnonOrFirstNamespaceAndFlags.setInt(F | F_Nested);

    else

      AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Nested);

  }

 

  /// Returns true if the inline qualifier for \c Name is redundant.

  bool isRedundantInlineQualifierFor(DeclarationName Name) const {

    if (!isInline())

      return false;

    auto X = lookup(Name);

    // We should not perform a lookup within a transparent context, so find a

    // non-transparent parent context.

    auto Y = getParent()->getNonTransparentContext()->lookup(Name);

    return std::distance(X.begin(), X.end()) ==

      std::distance(Y.begin(), Y.end());

  }

 

  /// Get the original (first) namespace declaration.

  NamespaceDecl *getOriginalNamespace();

 

  /// Get the original (first) namespace declaration.

  const NamespaceDecl *getOriginalNamespace() const;

 

  /// Return true if this declaration is an original (first) declaration

  /// of the namespace. This is false for non-original (subsequent) namespace

  /// declarations and anonymous namespaces.

  bool isOriginalNamespace() const;

 

  /// Retrieve the anonymous namespace nested inside this namespace,

  /// if any.

  NamespaceDecl *getAnonymousNamespace() const {

    return getOriginalNamespace()->AnonOrFirstNamespaceAndFlags.getPointer();

  }

 

  void setAnonymousNamespace(NamespaceDecl *D) {

    getOriginalNamespace()->AnonOrFirstNamespaceAndFlags.setPointer(D);

  }

 

  /// Retrieves the canonical declaration of this namespace.

  NamespaceDecl *getCanonicalDecl() override {

    return getOriginalNamespace();

  }

  const NamespaceDecl *getCanonicalDecl() const {

    return getOriginalNamespace();

  }

 

  SourceRange getSourceRange() const override LLVM_READONLY {

    return SourceRange(LocStart, RBraceLoc);

  }

 

  SourceLocation getBeginLoc() const LLVM_READONLY { return LocStart; }

  SourceLocation getRBraceLoc() const { return RBraceLoc; }

  void setLocStart(SourceLocation L) { LocStart = L; }

  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == Namespace; }

  static DeclContext *castToDeclContext(const NamespaceDecl *D) {

    return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));

  }

  static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {

    return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));

  }

 

class VarDecl;

 

class ValueDecl : public NamedDecl {

  QualType DeclType;

 

  void anchor() override;

 

  ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,

            DeclarationName N, QualType T)

    : NamedDecl(DK, DC, L, N), DeclType(T) {}

 

  QualType getType() const { return DeclType; }

  void setType(QualType newType) { DeclType = newType; }

 

  /// Determine whether this symbol is weakly-imported,

  ///        or declared with the weak or weak-ref attr.

  bool isWeak() const;

 

  /// Whether this variable is the implicit variable for a lambda init-capture.

  /// Only VarDecl can be init captures, but both VarDecl and BindingDecl

  /// can be captured.

  bool isInitCapture() const;

 

  // If this is a VarDecl, or a BindindDecl with an

  // associated decomposed VarDecl, return that VarDecl.

  VarDecl *getPotentiallyDecomposedVarDecl();

  const VarDecl *getPotentiallyDecomposedVarDecl() const {

    return const_cast<ValueDecl *>(this)->getPotentiallyDecomposedVarDecl();

  }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }

 

struct QualifierInfo {

  NestedNameSpecifierLoc QualifierLoc;

 

  /// The number of "outer" template parameter lists.

  /// The count includes all of the template parameter lists that were matched

  /// against the template-ids occurring into the NNS and possibly (in the

  /// case of an explicit specialization) a final "template <>".

  unsigned NumTemplParamLists = 0;

 

  /// A new-allocated array of size NumTemplParamLists,

  /// containing pointers to the "outer" template parameter lists.

  /// It includes all of the template parameter lists that were matched

  /// against the template-ids occurring into the NNS and possibly (in the

  /// case of an explicit specialization) a final "template <>".

  TemplateParameterList** TemplParamLists = nullptr;

 

  QualifierInfo() = default;

  QualifierInfo(const QualifierInfo &) = delete;

  QualifierInfo& operator=(const QualifierInfo &) = delete;

 

  /// Sets info about "outer" template parameter lists.

  void setTemplateParameterListsInfo(ASTContext &Context,

                                     ArrayRef<TemplateParameterList *> TPLists);

 

class DeclaratorDecl : public ValueDecl {

  // A struct representing a TInfo, a trailing requires-clause and a syntactic

  // qualifier, to be used for the (uncommon) case of out-of-line declarations

  // and constrained function decls.

  struct ExtInfo : public QualifierInfo {

    TypeSourceInfo *TInfo;

    Expr *TrailingRequiresClause = nullptr;

  };

 

  llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;

 

  /// The start of the source range for this declaration,

  /// ignoring outer template declarations.

  SourceLocation InnerLocStart;

 

  bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }

  ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }

  const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }

 

  DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,

                 DeclarationName N, QualType T, TypeSourceInfo *TInfo,

                 SourceLocation StartL)

      : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}

 

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

 

  TypeSourceInfo *getTypeSourceInfo() const {

    return hasExtInfo()

      ? getExtInfo()->TInfo

      : DeclInfo.get<TypeSourceInfo*>();

  }

 

  void setTypeSourceInfo(TypeSourceInfo *TI) {

    if (hasExtInfo())

      getExtInfo()->TInfo = TI;

    else

      DeclInfo = TI;

  }

 

  /// Return start of source range ignoring outer template declarations.

  SourceLocation getInnerLocStart() const { return InnerLocStart; }

  void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }

 

  /// Return start of source range taking into account any outer template

  /// declarations.

  SourceLocation getOuterLocStart() const;

 

  SourceRange getSourceRange() const override LLVM_READONLY;

 

  SourceLocation getBeginLoc() const LLVM_READONLY {

    return getOuterLocStart();

  }

 

  /// Retrieve the nested-name-specifier that qualifies the name of this

  /// declaration, if it was present in the source.

  NestedNameSpecifier *getQualifier() const {

    return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()

                        : nullptr;

  }

 

  /// Retrieve the nested-name-specifier (with source-location

  /// information) that qualifies the name of this declaration, if it was

  /// present in the source.

  NestedNameSpecifierLoc getQualifierLoc() const {

    return hasExtInfo() ? getExtInfo()->QualifierLoc

                        : NestedNameSpecifierLoc();

  }

 

  void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);

 

  /// \brief Get the constraint-expression introduced by the trailing

  /// requires-clause in the function/member declaration, or null if no

  /// requires-clause was provided.

  Expr *getTrailingRequiresClause() {

    return hasExtInfo() ? getExtInfo()->TrailingRequiresClause

                        : nullptr;

  }

 

  const Expr *getTrailingRequiresClause() const {

    return hasExtInfo() ? getExtInfo()->TrailingRequiresClause

                        : nullptr;

  }

 

  void setTrailingRequiresClause(Expr *TrailingRequiresClause);

 

  unsigned getNumTemplateParameterLists() const {

    return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;

  }

 

  TemplateParameterList *getTemplateParameterList(unsigned index) const {

    assert(index < getNumTemplateParameterLists());

    return getExtInfo()->TemplParamLists[index];

  }

 

  void setTemplateParameterListsInfo(ASTContext &Context,

                                     ArrayRef<TemplateParameterList *> TPLists);

 

  SourceLocation getTypeSpecStartLoc() const;

  SourceLocation getTypeSpecEndLoc() const;

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) {

    return K >= firstDeclarator && K <= lastDeclarator;

  }

 

struct EvaluatedStmt {

  /// Whether this statement was already evaluated.

  bool WasEvaluated : 1;

 

  /// Whether this statement is being evaluated.

  bool IsEvaluating : 1;

 

  /// Whether this variable is known to have constant initialization. This is

  /// currently only computed in C++, for static / thread storage duration

  /// variables that might have constant initialization and for variables that

  /// are usable in constant expressions.

  bool HasConstantInitialization : 1;

 

  /// Whether this variable is known to have constant destruction. That is,

  /// whether running the destructor on the initial value is a side-effect

  /// (and doesn't inspect any state that might have changed during program

  /// execution). This is currently only computed if the destructor is

  /// non-trivial.

  bool HasConstantDestruction : 1;

 

  /// In C++98, whether the initializer is an ICE. This affects whether the

  /// variable is usable in constant expressions.

  bool HasICEInit : 1;

  bool CheckedForICEInit : 1;

 

  Stmt *Value;

  APValue Evaluated;

 

  EvaluatedStmt()

      : WasEvaluated(false), IsEvaluating(false),

        HasConstantInitialization(false), HasConstantDestruction(false),

        HasICEInit(false), CheckedForICEInit(false) {}

 

class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {

  /// Initialization styles.

  enum InitializationStyle {

    /// C-style initialization with assignment

    CInit,

 

    /// Call-style initialization (C++98)

    CallInit,

 

    /// Direct list-initialization (C++11)

    ListInit,

 

    /// Parenthesized list-initialization (C++20)

    ParenListInit

  };

 

  /// Kinds of thread-local storage.

  enum TLSKind {

    /// Not a TLS variable.

    TLS_None,

 

    /// TLS with a known-constant initializer.

    TLS_Static,

 

    /// TLS with a dynamic initializer.

    TLS_Dynamic

  };

 

  /// Return the string used to specify the storage class \p SC.

  ///

  /// It is illegal to call this function with SC == None.

  static const char *getStorageClassSpecifierString(StorageClass SC);

 

  // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we

  // have allocated the auxiliary struct of information there.

  //

  // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for

  // this as *many* VarDecls are ParmVarDecls that don't have default

  // arguments. We could save some space by moving this pointer union to be

  // allocated in trailing space when necessary.

  using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;

 

  /// The initializer for this variable or, for a ParmVarDecl, the

  /// C++ default argument.

  mutable InitType Init;

 

  friend class ASTDeclReader;

  friend class ASTNodeImporter;

  friend class StmtIteratorBase;

 

  class VarDeclBitfields {

    friend class ASTDeclReader;

    friend class VarDecl;

 

    unsigned SClass : 3;

    unsigned TSCSpec : 2;

    unsigned InitStyle : 2;

 

    /// Whether this variable is an ARC pseudo-__strong variable; see

    /// isARCPseudoStrong() for details.

    unsigned ARCPseudoStrong : 1;

  };

  enum { NumVarDeclBits = 8 };

 

  enum { NumParameterIndexBits = 8 };

 

  enum DefaultArgKind {

    DAK_None,

    DAK_Unparsed,

    DAK_Uninstantiated,

    DAK_Normal

  };

 

  enum { NumScopeDepthOrObjCQualsBits = 7 };

 

  class ParmVarDeclBitfields {

    friend class ASTDeclReader;

    friend class ParmVarDecl;

 

    unsigned : NumVarDeclBits;

 

    /// Whether this parameter inherits a default argument from a

    /// prior declaration.

    unsigned HasInheritedDefaultArg : 1;

 

    /// Describes the kind of default argument for this parameter. By default

    /// this is none. If this is normal, then the default argument is stored in

    /// the \c VarDecl initializer expression unless we were unable to parse

    /// (even an invalid) expression for the default argument.

    unsigned DefaultArgKind : 2;

 

    /// Whether this parameter undergoes K&R argument promotion.

    unsigned IsKNRPromoted : 1;

 

    /// Whether this parameter is an ObjC method parameter or not.

    unsigned IsObjCMethodParam : 1;

 

    /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.

    /// Otherwise, the number of function parameter scopes enclosing

    /// the function parameter scope in which this parameter was

    /// declared.

    unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;

 

    /// The number of parameters preceding this parameter in the

    /// function parameter scope in which it was declared.

    unsigned ParameterIndex : NumParameterIndexBits;

  };

 

  class NonParmVarDeclBitfields {

    friend class ASTDeclReader;

    friend class ImplicitParamDecl;

    friend class VarDecl;

 

    unsigned : NumVarDeclBits;

 

    // FIXME: We need something similar to CXXRecordDecl::DefinitionData.

    /// Whether this variable is a definition which was demoted due to

    /// module merge.

    unsigned IsThisDeclarationADemotedDefinition : 1;

 

    /// Whether this variable is the exception variable in a C++ catch

    /// or an Objective-C @catch statement.

    unsigned ExceptionVar : 1;

 

    /// Whether this local variable could be allocated in the return

    /// slot of its function, enabling the named return value optimization

    /// (NRVO).

    unsigned NRVOVariable : 1;

 

    /// Whether this variable is the for-range-declaration in a C++0x

    /// for-range statement.

    unsigned CXXForRangeDecl : 1;

 

    /// Whether this variable is the for-in loop declaration in Objective-C.

    unsigned ObjCForDecl : 1;

 

    /// Whether this variable is (C++1z) inline.

    unsigned IsInline : 1;

 

    /// Whether this variable has (C++1z) inline explicitly specified.

    unsigned IsInlineSpecified : 1;

 

    /// Whether this variable is (C++0x) constexpr.

    unsigned IsConstexpr : 1;

 

    /// Whether this variable is the implicit variable for a lambda

    /// init-capture.

    unsigned IsInitCapture : 1;

 

    /// Whether this local extern variable's previous declaration was

    /// declared in the same block scope. This controls whether we should merge

    /// the type of this declaration with its previous declaration.

    unsigned PreviousDeclInSameBlockScope : 1;

 

    /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or

    /// something else.

    unsigned ImplicitParamKind : 3;

 

    unsigned EscapingByref : 1;

  };

 

  union {

    unsigned AllBits;

    VarDeclBitfields VarDeclBits;

    ParmVarDeclBitfields ParmVarDeclBits;

    NonParmVarDeclBitfields NonParmVarDeclBits;

  };

 

  VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,

          SourceLocation IdLoc, const IdentifierInfo *Id, QualType T,

          TypeSourceInfo *TInfo, StorageClass SC);

 

  using redeclarable_base = Redeclarable<VarDecl>;

 

  VarDecl *getNextRedeclarationImpl() override {

    return getNextRedeclaration();

  }

 

  VarDecl *getPreviousDeclImpl() override {

    return getPreviousDecl();

  }

 

  VarDecl *getMostRecentDeclImpl() override {

    return getMostRecentDecl();

  }

 

  using redecl_range = redeclarable_base::redecl_range;

  using redecl_iterator = redeclarable_base::redecl_iterator;

 

  using redeclarable_base::redecls_begin;

  using redeclarable_base::redecls_end;

  using redeclarable_base::redecls;

  using redeclarable_base::getPreviousDecl;

  using redeclarable_base::getMostRecentDecl;

  using redeclarable_base::isFirstDecl;

 

  static VarDecl *Create(ASTContext &C, DeclContext *DC,

                         SourceLocation StartLoc, SourceLocation IdLoc,

                         const IdentifierInfo *Id, QualType T,

                         TypeSourceInfo *TInfo, StorageClass S);

 

  static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);

 

  SourceRange getSourceRange() const override LLVM_READONLY;

 

  /// Returns the storage class as written in the source. For the

  /// computed linkage of symbol, see getLinkage.

  StorageClass getStorageClass() const {

    return (StorageClass) VarDeclBits.SClass;

  }

  void setStorageClass(StorageClass SC);

 

  void setTSCSpec(ThreadStorageClassSpecifier TSC) {

    VarDeclBits.TSCSpec = TSC;

    assert(VarDeclBits.TSCSpec == TSC && "truncation");

  }

  ThreadStorageClassSpecifier getTSCSpec() const {

    return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);

  }

  TLSKind getTLSKind() const;

 

  /// Returns true if a variable with function scope is a non-static local

  /// variable.

  bool hasLocalStorage() const {

    if (getStorageClass() == SC_None) {

      // OpenCL v1.2 s6.5.3: The __constant or constant address space name is

      // used to describe variables allocated in global memory and which are

      // accessed inside a kernel(s) as read-only variables. As such, variables

      // in constant address space cannot have local storage.

      if (getType().getAddressSpace() == LangAS::opencl_constant)

        return false;

      // Second check is for C++11 [dcl.stc]p4.

      return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;

    }

 

    // Global Named Register (GNU extension)

    if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())

      return false;

 

    // Return true for:  Auto, Register.

    // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.

 

    return getStorageClass() >= SC_Auto;

  }

 

  /// Returns true if a variable with function scope is a static local

  /// variable.

  bool isStaticLocal() const {

    return (getStorageClass() == SC_Static ||

            // C++11 [dcl.stc]p4

            (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))

      && !isFileVarDecl();

  }

 

  /// Returns true if a variable has extern or __private_extern__

  /// storage.

  bool hasExternalStorage() const {

    return getStorageClass() == SC_Extern ||

           getStorageClass() == SC_PrivateExtern;

  }

 

  /// Returns true for all variables that do not have local storage.

  ///

  /// This includes all global variables as well as static variables declared

  /// within a function.

  bool hasGlobalStorage() const { return !hasLocalStorage(); }

 

  /// Get the storage duration of this variable, per C++ [basic.stc].

  StorageDuration getStorageDuration() const {

    return hasLocalStorage() ? SD_Automatic :

           getTSCSpec() ? SD_Thread : SD_Static;

  }

 

  /// Compute the language linkage.

  LanguageLinkage getLanguageLinkage() const;

 

  /// Determines whether this variable is a variable with external, C linkage.

  bool isExternC() const;

 

  /// Determines whether this variable's context is, or is nested within,

  /// a C++ extern "C" linkage spec.

  bool isInExternCContext() const;

 

  /// Determines whether this variable's context is, or is nested within,

  /// a C++ extern "C++" linkage spec.

  bool isInExternCXXContext() const;

 

  /// Returns true for local variable declarations other than parameters.

  /// Note that this includes static variables inside of functions. It also

  /// includes variables inside blocks.

  ///

  ///   void foo() { int x; static int y; extern int z; }

  bool isLocalVarDecl() const {

    if (getKind() != Decl::Var && getKind() != Decl::Decomposition)

      return false;

    if (const DeclContext *DC = getLexicalDeclContext())

      return DC->getRedeclContext()->isFunctionOrMethod();

    return false;

  }

 

  /// Similar to isLocalVarDecl but also includes parameters.

  bool isLocalVarDeclOrParm() const {

    return isLocalVarDecl() || getKind() == Decl::ParmVar;

  }

 

  /// Similar to isLocalVarDecl, but excludes variables declared in blocks.

  bool isFunctionOrMethodVarDecl() const {

    if (getKind() != Decl::Var && getKind() != Decl::Decomposition)

      return false;

    const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();

    return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;

  }

 

  /// Determines whether this is a static data member.

  ///

  /// This will only be true in C++, and applies to, e.g., the

  /// variable 'x' in:

  /// \code

  /// struct S {

  ///   static int x;

  /// };

  /// \endcode

  bool isStaticDataMember() const {

    // If it wasn't static, it would be a FieldDecl.

    return getKind() != Decl::ParmVar && getDeclContext()->isRecord();

  }

 

  VarDecl *getCanonicalDecl() override;

  const VarDecl *getCanonicalDecl() const {

    return const_cast<VarDecl*>(this)->getCanonicalDecl();

  }

 

  enum DefinitionKind {

    /// This declaration is only a declaration.

    DeclarationOnly,

 

    /// This declaration is a tentative definition.

    TentativeDefinition,

 

    /// This declaration is definitely a definition.

    Definition

  };

 

  /// Check whether this declaration is a definition. If this could be

  /// a tentative definition (in C), don't check whether there's an overriding

  /// definition.

  DefinitionKind isThisDeclarationADefinition(ASTContext &) const;

  DefinitionKind isThisDeclarationADefinition() const {

    return isThisDeclarationADefinition(getASTContext());

  }

 

  /// Check whether this variable is defined in this translation unit.

  DefinitionKind hasDefinition(ASTContext &) const;

  DefinitionKind hasDefinition() const {

    return hasDefinition(getASTContext());

  }

 

  /// Get the tentative definition that acts as the real definition in a TU.

  /// Returns null if there is a proper definition available.

  VarDecl *getActingDefinition();

  const VarDecl *getActingDefinition() const {

    return const_cast<VarDecl*>(this)->getActingDefinition();

  }

 

  /// Get the real (not just tentative) definition for this declaration.

  VarDecl *getDefinition(ASTContext &);

  const VarDecl *getDefinition(ASTContext &C) const {

    return const_cast<VarDecl*>(this)->getDefinition(C);

  }

  VarDecl *getDefinition() {

    return getDefinition(getASTContext());

  }

  const VarDecl *getDefinition() const {

    return const_cast<VarDecl*>(this)->getDefinition();

  }

 

  /// Determine whether this is or was instantiated from an out-of-line

  /// definition of a static data member.

  bool isOutOfLine() const override;

 

  /// Returns true for file scoped variable declaration.

  bool isFileVarDecl() const {

    Kind K = getKind();

    if (K == ParmVar || K == ImplicitParam)

      return false;

 

    if (getLexicalDeclContext()->getRedeclContext()->isFileContext())

      return true;

 

    if (isStaticDataMember())

      return true;

 

    return false;

  }

 

  /// Get the initializer for this variable, no matter which

  /// declaration it is attached to.

  const Expr *getAnyInitializer() const {

    const VarDecl *D;

    return getAnyInitializer(D);

  }

 

  /// Get the initializer for this variable, no matter which

  /// declaration it is attached to. Also get that declaration.

  const Expr *getAnyInitializer(const VarDecl *&D) const;

 

  bool hasInit() const;

  const Expr *getInit() const {

    return const_cast<VarDecl *>(this)->getInit();

  }

  Expr *getInit();

 

  /// Retrieve the address of the initializer expression.

  Stmt **getInitAddress();

 

  void setInit(Expr *I);

 

  /// Get the initializing declaration of this variable, if any. This is

  /// usually the definition, except that for a static data member it can be

  /// the in-class declaration.

  VarDecl *getInitializingDeclaration();

  const VarDecl *getInitializingDeclaration() const {

    return const_cast<VarDecl *>(this)->getInitializingDeclaration();

  }

 

  /// Determine whether this variable's value might be usable in a

  /// constant expression, according to the relevant language standard.

  /// This only checks properties of the declaration, and does not check

  /// whether the initializer is in fact a constant expression.

  ///

  /// This corresponds to C++20 [expr.const]p3's notion of a

  /// "potentially-constant" variable.

  bool mightBeUsableInConstantExpressions(const ASTContext &C) const;

 

  /// Determine whether this variable's value can be used in a

  /// constant expression, according to the relevant language standard,

  /// including checking whether it was initialized by a constant expression.

  bool isUsableInConstantExpressions(const ASTContext &C) const;

 

  EvaluatedStmt *ensureEvaluatedStmt() const;

  EvaluatedStmt *getEvaluatedStmt() const;

 

  /// Attempt to evaluate the value of the initializer attached to this

  /// declaration, and produce notes explaining why it cannot be evaluated.

  /// Returns a pointer to the value if evaluation succeeded, 0 otherwise.

  APValue *evaluateValue() const;

 

  APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,

                             bool IsConstantInitialization) const;

 

  /// Return the already-evaluated value of this variable's

  /// initializer, or NULL if the value is not yet known. Returns pointer

  /// to untyped APValue if the value could not be evaluated.

  APValue *getEvaluatedValue() const;

 

  /// Evaluate the destruction of this variable to determine if it constitutes

  /// constant destruction.

  ///

  /// \pre hasConstantInitialization()

  /// \return \c true if this variable has constant destruction, \c false if

  ///         not.

  bool evaluateDestruction(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

 

  /// Determine whether this variable has constant initialization.

  ///

  /// This is only set in two cases: when the language semantics require

  /// constant initialization (globals in C and some globals in C++), and when

  /// the variable is usable in constant expressions (constexpr, const int, and

  /// reference variables in C++).

  bool hasConstantInitialization() const;

 

  /// Determine whether the initializer of this variable is an integer constant

  /// expression. For use in C++98, where this affects whether the variable is

  /// usable in constant expressions.

  bool hasICEInitializer(const ASTContext &Context) const;

 

  /// Evaluate the initializer of this variable to determine whether it's a

  /// constant initializer. Should only be called once, after completing the

  /// definition of the variable.

  bool checkForConstantInitialization(

      SmallVectorImpl<PartialDiagnosticAt> &Notes) const;

 

  void setInitStyle(InitializationStyle Style) {

    VarDeclBits.InitStyle = Style;

  }

 

  /// The style of initialization for this declaration.

  ///

  /// C-style initialization is "int x = 1;". Call-style initialization is

  /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be

  /// the expression inside the parens or a "ClassType(a,b,c)" class constructor

  /// expression for class types. List-style initialization is C++11 syntax,

  /// e.g. "int x{1};". Clients can distinguish between different forms of

  /// initialization by checking this value. In particular, "int x = {1};" is

  /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the

  /// Init expression in all three cases is an InitListExpr.

  InitializationStyle getInitStyle() const {

    return static_cast<InitializationStyle>(VarDeclBits.InitStyle);

  }

 

  /// Whether the initializer is a direct-initializer (list or call).

  bool isDirectInit() const {

    return getInitStyle() != CInit;

  }

 

  /// If this definition should pretend to be a declaration.

  bool isThisDeclarationADemotedDefinition() const {

    return isa<ParmVarDecl>(this) ? false :

      NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;

  }

 

  /// This is a definition which should be demoted to a declaration.

  ///

  /// In some cases (mostly module merging) we can end up with two visible

  /// definitions one of which needs to be demoted to a declaration to keep

  /// the AST invariants.

  void demoteThisDefinitionToDeclaration() {

    assert(isThisDeclarationADefinition() && "Not a definition!");

    assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");

    NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;

  }

 

  /// Determine whether this variable is the exception variable in a

  /// C++ catch statememt or an Objective-C \@catch statement.

  bool isExceptionVariable() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;

  }

  void setExceptionVariable(bool EV) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.ExceptionVar = EV;

  }

 

  /// Determine whether this local variable can be used with the named

  /// return value optimization (NRVO).

  ///

  /// The named return value optimization (NRVO) works by marking certain

  /// non-volatile local variables of class type as NRVO objects. These

  /// locals can be allocated within the return slot of their containing

  /// function, in which case there is no need to copy the object to the

  /// return slot when returning from the function. Within the function body,

  /// each return that returns the NRVO object will have this variable as its

  /// NRVO candidate.

  bool isNRVOVariable() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;

  }

  void setNRVOVariable(bool NRVO) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.NRVOVariable = NRVO;

  }

 

  /// Determine whether this variable is the for-range-declaration in

  /// a C++0x for-range statement.

  bool isCXXForRangeDecl() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;

  }

  void setCXXForRangeDecl(bool FRD) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.CXXForRangeDecl = FRD;

  }

 

  /// Determine whether this variable is a for-loop declaration for a

  /// for-in statement in Objective-C.

  bool isObjCForDecl() const {

    return NonParmVarDeclBits.ObjCForDecl;

  }

 

  void setObjCForDecl(bool FRD) {

    NonParmVarDeclBits.ObjCForDecl = FRD;

  }

 

  /// Determine whether this variable is an ARC pseudo-__strong variable. A

  /// pseudo-__strong variable has a __strong-qualified type but does not

  /// actually retain the object written into it. Generally such variables are

  /// also 'const' for safety. There are 3 cases where this will be set, 1) if

  /// the variable is annotated with the objc_externally_retained attribute, 2)

  /// if its 'self' in a non-init method, or 3) if its the variable in an for-in

  /// loop.

  bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }

  void setARCPseudoStrong(bool PS) { VarDeclBits.ARCPseudoStrong = PS; }

 

  /// Whether this variable is (C++1z) inline.

  bool isInline() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;

  }

  bool isInlineSpecified() const {

    return isa<ParmVarDecl>(this) ? false

                                  : NonParmVarDeclBits.IsInlineSpecified;

  }

  void setInlineSpecified() {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.IsInline = true;

    NonParmVarDeclBits.IsInlineSpecified = true;

  }

  void setImplicitlyInline() {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.IsInline = true;

  }

 

  /// Whether this variable is (C++11) constexpr.

  bool isConstexpr() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;

  }

  void setConstexpr(bool IC) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.IsConstexpr = IC;

  }

 

  /// Whether this variable is the implicit variable for a lambda init-capture.

  bool isInitCapture() const {

    return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;

  }

  void setInitCapture(bool IC) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.IsInitCapture = IC;

  }

 

  /// Determine whether this variable is actually a function parameter pack or

  /// init-capture pack.

  bool isParameterPack() const;

 

  /// Whether this local extern variable declaration's previous declaration

  /// was declared in the same block scope. Only correct in C++.

  bool isPreviousDeclInSameBlockScope() const {

    return isa<ParmVarDecl>(this)

               ? false

               : NonParmVarDeclBits.PreviousDeclInSameBlockScope;

  }

  void setPreviousDeclInSameBlockScope(bool Same) {

    assert(!isa<ParmVarDecl>(this));

    NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;

  }

 

  /// Indicates the capture is a __block variable that is captured by a block

  /// that can potentially escape (a block for which BlockDecl::doesNotEscape

  /// returns false).

  bool isEscapingByref() const;

 

  /// Indicates the capture is a __block variable that is never captured by an

  /// escaping block.

  bool isNonEscapingByref() const;

 

  void setEscapingByref() {

    NonParmVarDeclBits.EscapingByref = true;

  }

 

  /// Determines if this variable's alignment is dependent.

  bool hasDependentAlignment() const;

 

  /// Retrieve the variable declaration from which this variable could

  /// be instantiated, if it is an instantiation (rather than a non-template).

  VarDecl *getTemplateInstantiationPattern() const;

 

  /// If this variable is an instantiated static data member of a

  /// class template specialization, returns the templated static data member

  /// from which it was instantiated.

  VarDecl *getInstantiatedFromStaticDataMember() const;

 

  /// If this variable is an instantiation of a variable template or a

  /// static data member of a class template, determine what kind of

  /// template specialization or instantiation this is.

  TemplateSpecializationKind getTemplateSpecializationKind() const;

 

  /// Get the template specialization kind of this variable for the purposes of

  /// template instantiation. This differs from getTemplateSpecializationKind()

  /// for an instantiation of a class-scope explicit specialization.

  TemplateSpecializationKind

  getTemplateSpecializationKindForInstantiation() const;

 

  /// If this variable is an instantiation of a variable template or a

  /// static data member of a class template, determine its point of

  /// instantiation.

  SourceLocation getPointOfInstantiation() const;

 

  /// If this variable is an instantiation of a static data member of a

  /// class template specialization, retrieves the member specialization

  /// information.

  MemberSpecializationInfo *getMemberSpecializationInfo() const;

 

  /// For a static data member that was instantiated from a static

  /// data member of a class template, set the template specialiation kind.

  void setTemplateSpecializationKind(TemplateSpecializationKind TSK,

                        SourceLocation PointOfInstantiation = SourceLocation());

 

  /// Specify that this variable is an instantiation of the

  /// static data member VD.

  void setInstantiationOfStaticDataMember(VarDecl *VD,

                                          TemplateSpecializationKind TSK);

 

  /// Retrieves the variable template that is described by this

  /// variable declaration.

  ///

  /// Every variable template is represented as a VarTemplateDecl and a

  /// VarDecl. The former contains template properties (such as

  /// the template parameter lists) while the latter contains the

  /// actual description of the template's

  /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the

  /// VarDecl that from a VarTemplateDecl, while

  /// getDescribedVarTemplate() retrieves the VarTemplateDecl from

  /// a VarDecl.

  VarTemplateDecl *getDescribedVarTemplate() const;

 

  void setDescribedVarTemplate(VarTemplateDecl *Template);

 

  // Is this variable known to have a definition somewhere in the complete

  // program? This may be true even if the declaration has internal linkage and

  // has no definition within this source file.

  bool isKnownToBeDefined() const;

 

  /// Is destruction of this variable entirely suppressed? If so, the variable

  /// need not have a usable destructor at all.

  bool isNoDestroy(const ASTContext &) const;

 

  /// Would the destruction of this variable have any effect, and if so, what

  /// kind?

  QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const;

 

  /// Whether this variable has a flexible array member initialized with one

  /// or more elements. This can only be called for declarations where

  /// hasInit() is true.

  ///

  /// (The standard doesn't allow initializing flexible array members; this is

  /// a gcc/msvc extension.)

  bool hasFlexibleArrayInit(const ASTContext &Ctx) const;

 

  /// If hasFlexibleArrayInit is true, compute the number of additional bytes

  /// necessary to store those elements. Otherwise, returns zero.

  ///

  /// This can only be called for declarations where hasInit() is true.

  CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const;

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }

 

class ImplicitParamDecl : public VarDecl {

  void anchor() override;

 

  /// Defines the kind of the implicit parameter: is this an implicit parameter

  /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured

  /// context or something else.

  enum ImplicitParamKind : unsigned {

    /// Parameter for Objective-C 'self' argument

    ObjCSelf,

 

    /// Parameter for Objective-C '_cmd' argument

    ObjCCmd,

 

    /// Parameter for C++ 'this' argument

    CXXThis,

 

    /// Parameter for C++ virtual table pointers

    CXXVTT,

 

    /// Parameter for captured context

    CapturedContext,

 

    /// Parameter for Thread private variable

    ThreadPrivateVar,

 

    /// Other implicit parameter

    Other,

  };

 

  /// Create implicit parameter.

  static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,

                                   SourceLocation IdLoc, IdentifierInfo *Id,

                                   QualType T, ImplicitParamKind ParamKind);

  static ImplicitParamDecl *Create(ASTContext &C, QualType T,

                                   ImplicitParamKind ParamKind);

 

  static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);

 

  ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,

                    IdentifierInfo *Id, QualType Type,

                    ImplicitParamKind ParamKind)

      : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,

                /*TInfo=*/nullptr, SC_None) {

    NonParmVarDeclBits.ImplicitParamKind = ParamKind;

    setImplicit();

  }

 

  ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)

      : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),

                SourceLocation(), /*Id=*/nullptr, Type,

                /*TInfo=*/nullptr, SC_None) {

    NonParmVarDeclBits.ImplicitParamKind = ParamKind;

    setImplicit();

  }

 

  /// Returns the implicit parameter kind.

  ImplicitParamKind getParameterKind() const {

    return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);

  }

 

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) { return K == ImplicitParam; }

 

class ParmVarDecl : public VarDecl {

  enum { MaxFunctionScopeDepth = 255 };

  enum { MaxFunctionScopeIndex = 255 };

 

  ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,

              SourceLocation IdLoc, IdentifierInfo *Id, QualType T,

              TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)

      : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {

    assert(ParmVarDeclBits.HasInheritedDefaultArg == false);

    assert(ParmVarDeclBits.DefaultArgKind == DAK_None);

    assert(ParmVarDeclBits.IsKNRPromoted == false);

    assert(ParmVarDeclBits.IsObjCMethodParam == false);

    setDefaultArg(DefArg);