Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

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

//

//  This file defines the Decl subclasses.

//

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

#ifndef LLVM_CLANG_AST_DECL_H

#define LLVM_CLANG_AST_DECL_H

#include "clang/AST/APValue.h"

#include "clang/AST/ASTContextAllocate.h"

#include "clang/AST/DeclAccessPair.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/Redeclarable.h"

#include "clang/AST/Type.h"

#include "clang/Basic/AddressSpaces.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/Linkage.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/PragmaKinds.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/Visibility.h"

#include "llvm/ADT/APSInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/TrailingObjects.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <optional>

#include <string>

#include <utility>

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;

/// The top declaration context.

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();

public:

  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));

  }

};

/// Represents a `#pragma comment` line. Always a child of

/// TranslationUnitDecl.

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();

public:

  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; }

};

/// Represents a `#pragma detect_mismatch` line. Always a child of

/// TranslationUnitDecl.

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();

public:

  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; }

};

/// Declaration context for names declared as extern "C" in C++. This

/// is neither the semantic nor lexical context for such declarations, but is

/// used to check for conflicts with other extern "C" declarations. Example:

///

/// \code

///   namespace N { extern "C" void f(); } // #1

///   void N::f() {}                       // #2

///   namespace M { extern "C" void f(); } // #3

/// \endcode

///

/// The semantic context of #1 is namespace N and its lexical context is the

/// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical

/// context is the TU. However, both declarations are also visible in the

/// extern "C" context.

///

/// The declaration at #3 finds it is a redeclaration of \c N::f through

/// lookup in the extern "C" context.

class ExternCContextDecl : public Decl, public DeclContext {

  explicit ExternCContextDecl(TranslationUnitDecl *TU)

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

      DeclContext(ExternCContext) {}

  virtual void anchor();

public:

  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));

  }

};

/// This represents a decl that may have a name.  Many decls have names such

/// as ObjCMethodDecl, but not \@class, etc.

///

/// Note that not every NamedDecl is actually named (e.g., a struct might

/// be anonymous), and not every name is an identifier.

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();

private:

  NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;

protected:

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

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

public:

  /// 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;

}

/// Represents the declaration of a label.  Labels also have a

/// corresponding LabelStmt, which indicates the position that the label was

/// defined at.  For normal labels, the location of the decl is the same as the

/// location of the statement.  For GNU local labels (__label__), the decl

/// location is where the __label__ is.

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;

public:

  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; }

};

/// Represent a C++ namespace.

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;

public:

  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;

/// Represent the declaration of a variable (in which case it is

/// an lvalue) a function (in which case it is a function designator) or

/// an enum constant.

class ValueDecl : public NamedDecl {

  QualType DeclType;

  void anchor() override;

protected:

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

            DeclarationName N, QualType T)

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

public:

  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; }

};

/// A struct with extended info about a syntactic

/// name qualifier, to be used for the case of out-of-line declarations.

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);

};

/// Represents a ValueDecl that came out of a declarator.

/// Contains type source information through TypeSourceInfo.

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*>(); }

protected:

  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) {}

public:

  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;