Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DeclBase.h - Base 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 and DeclContext interfaces.

//

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

#ifndef LLVM_CLANG_AST_DECLBASE_H

#define LLVM_CLANG_AST_DECLBASE_H

#include "clang/AST/ASTDumperUtils.h"

#include "clang/AST/AttrIterator.h"

#include "clang/AST/DeclarationName.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/PrettyStackTrace.h"

#include "llvm/Support/VersionTuple.h"

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <iterator>

#include <string>

#include <type_traits>

#include <utility>

namespace clang {

class ASTContext;

class ASTMutationListener;

class Attr;

class BlockDecl;

class DeclContext;

class ExternalSourceSymbolAttr;

class FunctionDecl;

class FunctionType;

class IdentifierInfo;

enum Linkage : unsigned char;

class LinkageSpecDecl;

class Module;

class NamedDecl;

class ObjCContainerDecl;

class ObjCMethodDecl;

struct PrintingPolicy;

class RecordDecl;

class SourceManager;

class Stmt;

class StoredDeclsMap;

class TemplateDecl;

class TemplateParameterList;

class TranslationUnitDecl;

class UsingDirectiveDecl;

/// Captures the result of checking the availability of a

/// declaration.

enum AvailabilityResult {

  AR_Available = 0,

  AR_NotYetIntroduced,

  AR_Deprecated,

  AR_Unavailable

};

/// Decl - This represents one declaration (or definition), e.g. a variable,

/// typedef, function, struct, etc.

///

/// Note: There are objects tacked on before the *beginning* of Decl

/// (and its subclasses) in its Decl::operator new(). Proper alignment

/// of all subclasses (not requiring more than the alignment of Decl) is

/// asserted in DeclBase.cpp.

class alignas(8) Decl {

public:

  /// Lists the kind of concrete classes of Decl.

  enum Kind {

#define DECL(DERIVED, BASE) DERIVED,

#define ABSTRACT_DECL(DECL)

#define DECL_RANGE(BASE, START, END) \

        first##BASE = START, last##BASE = END,

#define LAST_DECL_RANGE(BASE, START, END) \

        first##BASE = START, last##BASE = END

#include "clang/AST/DeclNodes.inc"

  };

  /// A placeholder type used to construct an empty shell of a

  /// decl-derived type that will be filled in later (e.g., by some

  /// deserialization method).

  struct EmptyShell {};

  /// IdentifierNamespace - The different namespaces in which

  /// declarations may appear.  According to C99 6.2.3, there are

  /// four namespaces, labels, tags, members and ordinary

  /// identifiers.  C++ describes lookup completely differently:

  /// certain lookups merely "ignore" certain kinds of declarations,

  /// usually based on whether the declaration is of a type, etc.

  ///

  /// These are meant as bitmasks, so that searches in

  /// C++ can look into the "tag" namespace during ordinary lookup.

  ///

  /// Decl currently provides 15 bits of IDNS bits.

  enum IdentifierNamespace {

    /// Labels, declared with 'x:' and referenced with 'goto x'.

    IDNS_Label               = 0x0001,

    /// Tags, declared with 'struct foo;' and referenced with

    /// 'struct foo'.  All tags are also types.  This is what

    /// elaborated-type-specifiers look for in C.

    /// This also contains names that conflict with tags in the

    /// same scope but that are otherwise ordinary names (non-type

    /// template parameters and indirect field declarations).

    IDNS_Tag                 = 0x0002,

    /// Types, declared with 'struct foo', typedefs, etc.

    /// This is what elaborated-type-specifiers look for in C++,

    /// but note that it's ill-formed to find a non-tag.

    IDNS_Type                = 0x0004,

    /// Members, declared with object declarations within tag

    /// definitions.  In C, these can only be found by "qualified"

    /// lookup in member expressions.  In C++, they're found by

    /// normal lookup.

    IDNS_Member              = 0x0008,

    /// Namespaces, declared with 'namespace foo {}'.

    /// Lookup for nested-name-specifiers find these.

    IDNS_Namespace           = 0x0010,

    /// Ordinary names.  In C, everything that's not a label, tag,

    /// member, or function-local extern ends up here.

    IDNS_Ordinary            = 0x0020,

    /// Objective C \@protocol.

    IDNS_ObjCProtocol        = 0x0040,

    /// This declaration is a friend function.  A friend function

    /// declaration is always in this namespace but may also be in

    /// IDNS_Ordinary if it was previously declared.

    IDNS_OrdinaryFriend      = 0x0080,

    /// This declaration is a friend class.  A friend class

    /// declaration is always in this namespace but may also be in

    /// IDNS_Tag|IDNS_Type if it was previously declared.

    IDNS_TagFriend           = 0x0100,

    /// This declaration is a using declaration.  A using declaration

    /// *introduces* a number of other declarations into the current

    /// scope, and those declarations use the IDNS of their targets,

    /// but the actual using declarations go in this namespace.

    IDNS_Using               = 0x0200,

    /// This declaration is a C++ operator declared in a non-class

    /// context.  All such operators are also in IDNS_Ordinary.

    /// C++ lexical operator lookup looks for these.

    IDNS_NonMemberOperator   = 0x0400,

    /// This declaration is a function-local extern declaration of a

    /// variable or function. This may also be IDNS_Ordinary if it

    /// has been declared outside any function. These act mostly like

    /// invisible friend declarations, but are also visible to unqualified

    /// lookup within the scope of the declaring function.

    IDNS_LocalExtern         = 0x0800,

    /// This declaration is an OpenMP user defined reduction construction.

    IDNS_OMPReduction        = 0x1000,

    /// This declaration is an OpenMP user defined mapper.

    IDNS_OMPMapper           = 0x2000,

  };

  /// ObjCDeclQualifier - 'Qualifiers' written next to the return and

  /// parameter types in method declarations.  Other than remembering

  /// them and mangling them into the method's signature string, these

  /// are ignored by the compiler; they are consumed by certain

  /// remote-messaging frameworks.

  ///

  /// in, inout, and out are mutually exclusive and apply only to

  /// method parameters.  bycopy and byref are mutually exclusive and

  /// apply only to method parameters (?).  oneway applies only to

  /// results.  All of these expect their corresponding parameter to

  /// have a particular type.  None of this is currently enforced by

  /// clang.

  ///

  /// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.

  enum ObjCDeclQualifier {

    OBJC_TQ_None = 0x0,

    OBJC_TQ_In = 0x1,

    OBJC_TQ_Inout = 0x2,

    OBJC_TQ_Out = 0x4,

    OBJC_TQ_Bycopy = 0x8,

    OBJC_TQ_Byref = 0x10,

    OBJC_TQ_Oneway = 0x20,

    /// The nullability qualifier is set when the nullability of the

    /// result or parameter was expressed via a context-sensitive

    /// keyword.

    OBJC_TQ_CSNullability = 0x40

  };

  /// The kind of ownership a declaration has, for visibility purposes.

  /// This enumeration is designed such that higher values represent higher

  /// levels of name hiding.

  enum class ModuleOwnershipKind : unsigned {

    /// This declaration is not owned by a module.

    Unowned,

    /// This declaration has an owning module, but is globally visible

    /// (typically because its owning module is visible and we know that

    /// modules cannot later become hidden in this compilation).

    /// After serialization and deserialization, this will be converted

    /// to VisibleWhenImported.

    Visible,

    /// This declaration has an owning module, and is visible when that

    /// module is imported.

    VisibleWhenImported,

    /// This declaration has an owning module, and is visible to lookups

    /// that occurs within that module. And it is reachable in other module

    /// when the owning module is transitively imported.

    ReachableWhenImported,

    /// This declaration has an owning module, but is only visible to

    /// lookups that occur within that module.

    /// The discarded declarations in global module fragment belongs

    /// to this group too.

    ModulePrivate

  };

protected:

  /// The next declaration within the same lexical

  /// DeclContext. These pointers form the linked list that is

  /// traversed via DeclContext's decls_begin()/decls_end().

  ///

  /// The extra three bits are used for the ModuleOwnershipKind.

  llvm::PointerIntPair<Decl *, 3, ModuleOwnershipKind> NextInContextAndBits;

private:

  friend class DeclContext;

  struct MultipleDC {

    DeclContext *SemanticDC;

    DeclContext *LexicalDC;

  };

  /// DeclCtx - Holds either a DeclContext* or a MultipleDC*.

  /// For declarations that don't contain C++ scope specifiers, it contains

  /// the DeclContext where the Decl was declared.

  /// For declarations with C++ scope specifiers, it contains a MultipleDC*

  /// with the context where it semantically belongs (SemanticDC) and the

  /// context where it was lexically declared (LexicalDC).

  /// e.g.:

  ///

  ///   namespace A {

  ///      void f(); // SemanticDC == LexicalDC == 'namespace A'

  ///   }

  ///   void A::f(); // SemanticDC == namespace 'A'

  ///                // LexicalDC == global namespace

  llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;

  bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }

  bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }

  MultipleDC *getMultipleDC() const {

    return DeclCtx.get<MultipleDC*>();

  }

  DeclContext *getSemanticDC() const {

    return DeclCtx.get<DeclContext*>();

  }

  /// Loc - The location of this decl.

  SourceLocation Loc;

  /// DeclKind - This indicates which class this is.

  unsigned DeclKind : 7;

  /// InvalidDecl - This indicates a semantic error occurred.

  unsigned InvalidDecl :  1;

  /// HasAttrs - This indicates whether the decl has attributes or not.

  unsigned HasAttrs : 1;

  /// Implicit - Whether this declaration was implicitly generated by

  /// the implementation rather than explicitly written by the user.

  unsigned Implicit : 1;

  /// Whether this declaration was "used", meaning that a definition is

  /// required.

  unsigned Used : 1;

  /// Whether this declaration was "referenced".

  /// The difference with 'Used' is whether the reference appears in a

  /// evaluated context or not, e.g. functions used in uninstantiated templates

  /// are regarded as "referenced" but not "used".

  unsigned Referenced : 1;

  /// Whether this declaration is a top-level declaration (function,

  /// global variable, etc.) that is lexically inside an objc container

  /// definition.

  unsigned TopLevelDeclInObjCContainer : 1;

  /// Whether statistic collection is enabled.

  static bool StatisticsEnabled;

protected:

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  friend class ASTNodeImporter;

  friend class ASTReader;

  friend class CXXClassMemberWrapper;

  friend class LinkageComputer;

  friend class RecordDecl;

  template<typename decl_type> friend class Redeclarable;

  /// Access - Used by C++ decls for the access specifier.

  // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum

  unsigned Access : 2;

  /// Whether this declaration was loaded from an AST file.

  unsigned FromASTFile : 1;

  /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.

  unsigned IdentifierNamespace : 14;

  /// If 0, we have not computed the linkage of this declaration.

  /// Otherwise, it is the linkage + 1.

  mutable unsigned CacheValidAndLinkage : 3;

  /// Allocate memory for a deserialized declaration.

  ///

  /// This routine must be used to allocate memory for any declaration that is

  /// deserialized from a module file.

  ///

  /// \param Size The size of the allocated object.

  /// \param Ctx The context in which we will allocate memory.

  /// \param ID The global ID of the deserialized declaration.

  /// \param Extra The amount of extra space to allocate after the object.

  void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,

                     std::size_t Extra = 0);

  /// Allocate memory for a non-deserialized declaration.

  void *operator new(std::size_t Size, const ASTContext &Ctx,

                     DeclContext *Parent, std::size_t Extra = 0);

private:

  bool AccessDeclContextCheck() const;

  /// Get the module ownership kind to use for a local lexical child of \p DC,

  /// which may be either a local or (rarely) an imported declaration.

  static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {

    if (DC) {

      auto *D = cast<Decl>(DC);

      auto MOK = D->getModuleOwnershipKind();

      if (MOK != ModuleOwnershipKind::Unowned &&

          (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))

        return MOK;

      // If D is not local and we have no local module storage, then we don't

      // need to track module ownership at all.

    }

    return ModuleOwnershipKind::Unowned;

  }

public:

  Decl() = delete;

  Decl(const Decl&) = delete;

  Decl(Decl &&) = delete;

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

  Decl &operator=(Decl&&) = delete;

protected:

  Decl(Kind DK, DeclContext *DC, SourceLocation L)

      : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),

        DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),

        Implicit(false), Used(false), Referenced(false),

        TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),

        IdentifierNamespace(getIdentifierNamespaceForKind(DK)),

        CacheValidAndLinkage(0) {

    if (StatisticsEnabled) add(DK);

  }

  Decl(Kind DK, EmptyShell Empty)

      : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),

        Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),

        Access(AS_none), FromASTFile(0),

        IdentifierNamespace(getIdentifierNamespaceForKind(DK)),

        CacheValidAndLinkage(0) {

    if (StatisticsEnabled) add(DK);

  }

  virtual ~Decl();

  /// Update a potentially out-of-date declaration.

  void updateOutOfDate(IdentifierInfo &II) const;

  Linkage getCachedLinkage() const {

    return Linkage(CacheValidAndLinkage - 1);

  }

  void setCachedLinkage(Linkage L) const {

    CacheValidAndLinkage = L + 1;

  }

  bool hasCachedLinkage() const {

    return CacheValidAndLinkage;

  }

public:

  /// Source range that this declaration covers.

  virtual SourceRange getSourceRange() const LLVM_READONLY {

    return SourceRange(getLocation(), getLocation());

  }

  SourceLocation getBeginLoc() const LLVM_READONLY {

    return getSourceRange().getBegin();

  }

  SourceLocation getEndLoc() const LLVM_READONLY {

    return getSourceRange().getEnd();

  }

  SourceLocation getLocation() const { return Loc; }

  void setLocation(SourceLocation L) { Loc = L; }

  Kind getKind() const { return static_cast<Kind>(DeclKind); }

  const char *getDeclKindName() const;

  Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }

  const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}

  DeclContext *getDeclContext() {

    if (isInSemaDC())

      return getSemanticDC();

    return getMultipleDC()->SemanticDC;

  }

  const DeclContext *getDeclContext() const {

    return const_cast<Decl*>(this)->getDeclContext();

  }

  /// Return the non transparent context.

  /// See the comment of `DeclContext::isTransparentContext()` for the

  /// definition of transparent context.

  DeclContext *getNonTransparentDeclContext();

  const DeclContext *getNonTransparentDeclContext() const {

    return const_cast<Decl *>(this)->getNonTransparentDeclContext();

  }

  /// Find the innermost non-closure ancestor of this declaration,

  /// walking up through blocks, lambdas, etc.  If that ancestor is

  /// not a code context (!isFunctionOrMethod()), returns null.

  ///

  /// A declaration may be its own non-closure context.

  Decl *getNonClosureContext();

  const Decl *getNonClosureContext() const {

    return const_cast<Decl*>(this)->getNonClosureContext();

  }

  TranslationUnitDecl *getTranslationUnitDecl();

  const TranslationUnitDecl *getTranslationUnitDecl() const {

    return const_cast<Decl*>(this)->getTranslationUnitDecl();

  }

  bool isInAnonymousNamespace() const;

  bool isInStdNamespace() const;

  // Return true if this is a FileContext Decl.

  bool isFileContextDecl() const;

  ASTContext &getASTContext() const LLVM_READONLY;

  /// Helper to get the language options from the ASTContext.

  /// Defined out of line to avoid depending on ASTContext.h.

  const LangOptions &getLangOpts() const LLVM_READONLY;

  void setAccess(AccessSpecifier AS) {

    Access = AS;

    assert(AccessDeclContextCheck());

  }

  AccessSpecifier getAccess() const {

    assert(AccessDeclContextCheck());

    return AccessSpecifier(Access);

  }

  /// Retrieve the access specifier for this declaration, even though

  /// it may not yet have been properly set.

  AccessSpecifier getAccessUnsafe() const {

    return AccessSpecifier(Access);

  }

  bool hasAttrs() const { return HasAttrs; }

  void setAttrs(const AttrVec& Attrs) {

    return setAttrsImpl(Attrs, getASTContext());

  }

  AttrVec &getAttrs() {

    return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());

  }

  const AttrVec &getAttrs() const;

  void dropAttrs();

  void addAttr(Attr *A);

  using attr_iterator = AttrVec::const_iterator;

  using attr_range = llvm::iterator_range<attr_iterator>;

  attr_range attrs() const {

    return attr_range(attr_begin(), attr_end());

  }

  attr_iterator attr_begin() const {

    return hasAttrs() ? getAttrs().begin() : nullptr;

  }

  attr_iterator attr_end() const {

    return hasAttrs() ? getAttrs().end() : nullptr;

  }

  template <typename T>

  void dropAttr() {

    if (!HasAttrs) return;

    AttrVec &Vec = getAttrs();

    llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });

    if (Vec.empty())

      HasAttrs = false;

  }

  template <typename T>

  llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {

    return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());

  }

  template <typename T>

  specific_attr_iterator<T> specific_attr_begin() const {

    return specific_attr_iterator<T>(attr_begin());

  }

  template <typename T>

  specific_attr_iterator<T> specific_attr_end() const {

    return specific_attr_iterator<T>(attr_end());

  }

  template<typename T> T *getAttr() const {

    return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;

  }

  template<typename T> bool hasAttr() const {

    return hasAttrs() && hasSpecificAttr<T>(getAttrs());

  }

  /// getMaxAlignment - return the maximum alignment specified by attributes

  /// on this decl, 0 if there are none.

  unsigned getMaxAlignment() const;

  /// setInvalidDecl - Indicates the Decl had a semantic error. This

  /// allows for graceful error recovery.

  void setInvalidDecl(bool Invalid = true);

  bool isInvalidDecl() const { return (bool) InvalidDecl; }

  /// isImplicit - Indicates whether the declaration was implicitly

  /// generated by the implementation. If false, this declaration

  /// was written explicitly in the source code.

  bool isImplicit() const { return Implicit; }

  void setImplicit(bool I = true) { Implicit = I; }

  /// Whether *any* (re-)declaration of the entity was used, meaning that

  /// a definition is required.

  ///

  /// \param CheckUsedAttr When true, also consider the "used" attribute

  /// (in addition to the "used" bit set by \c setUsed()) when determining

  /// whether the function is used.

  bool isUsed(bool CheckUsedAttr = true) const;

  /// Set whether the declaration is used, in the sense of odr-use.

  ///

  /// This should only be used immediately after creating a declaration.

  /// It intentionally doesn't notify any listeners.

  void setIsUsed() { getCanonicalDecl()->Used = true; }

  /// Mark the declaration used, in the sense of odr-use.

  ///

  /// This notifies any mutation listeners in addition to setting a bit

  /// indicating the declaration is used.

  void markUsed(ASTContext &C);

  /// Whether any declaration of this entity was referenced.

  bool isReferenced() const;

  /// Whether this declaration was referenced. This should not be relied

  /// upon for anything other than debugging.

  bool isThisDeclarationReferenced() const { return Referenced; }

  void setReferenced(bool R = true) { Referenced = R; }

  /// Whether this declaration is a top-level declaration (function,

  /// global variable, etc.) that is lexically inside an objc container

  /// definition.

  bool isTopLevelDeclInObjCContainer() const {

    return TopLevelDeclInObjCContainer;

  }

  void setTopLevelDeclInObjCContainer(bool V = true) {

    TopLevelDeclInObjCContainer = V;

  }

  /// Looks on this and related declarations for an applicable

  /// external source symbol attribute.

  ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;

  /// Whether this declaration was marked as being private to the

  /// module in which it was defined.

  bool isModulePrivate() const {

    return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;

  }

  /// Whether this declaration was exported in a lexical context.

  /// e.g.:

  ///

  ///   export namespace A {

  ///      void f1();        // isInExportDeclContext() == true

  ///   }

  ///   void A::f1();        // isInExportDeclContext() == false

  ///

  ///   namespace B {

  ///      void f2();        // isInExportDeclContext() == false

  ///   }

  ///   export void B::f2(); // isInExportDeclContext() == true

  bool isInExportDeclContext() const;

  bool isInvisibleOutsideTheOwningModule() const {

    return getModuleOwnershipKind() > ModuleOwnershipKind::VisibleWhenImported;

  }

  /// FIXME: Implement discarding declarations actually in global module

  /// fragment. See [module.global.frag]p3,4 for details.

  bool isDiscardedInGlobalModuleFragment() const { return false; }

  /// Return true if this declaration has an attribute which acts as

  /// definition of the entity, such as 'alias' or 'ifunc'.

  bool hasDefiningAttr() const;

  /// Return this declaration's defining attribute if it has one.

  const Attr *getDefiningAttr() const;

protected:

  /// Specify that this declaration was marked as being private

  /// to the module in which it was defined.

  void setModulePrivate() {

    // The module-private specifier has no effect on unowned declarations.

    // FIXME: We should track this in some way for source fidelity.

    if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)

      return;

    setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);

  }

public:

  /// Set the FromASTFile flag. This indicates that this declaration

  /// was deserialized and not parsed from source code and enables

  /// features such as module ownership information.

  void setFromASTFile() {

    FromASTFile = true;

  }

  /// Set the owning module ID.  This may only be called for

  /// deserialized Decls.

  void setOwningModuleID(unsigned ID) {

    assert(isFromASTFile() && "Only works on a deserialized declaration");

    *((unsigned*)this - 2) = ID;

  }

public:

  /// Determine the availability of the given declaration.

  ///

  /// This routine will determine the most restrictive availability of

  /// the given declaration (e.g., preferring 'unavailable' to

  /// 'deprecated').

  ///

  /// \param Message If non-NULL and the result is not \c

  /// AR_Available, will be set to a (possibly empty) message

  /// describing why the declaration has not been introduced, is

  /// deprecated, or is unavailable.

  ///

  /// \param EnclosingVersion The version to compare with. If empty, assume the

  /// deployment target version.

  ///

  /// \param RealizedPlatform If non-NULL and the availability result is found

  /// in an available attribute it will set to the platform which is written in

  /// the available attribute.

  AvailabilityResult

  getAvailability(std::string *Message = nullptr,

                  VersionTuple EnclosingVersion = VersionTuple(),

                  StringRef *RealizedPlatform = nullptr) const;

  /// Retrieve the version of the target platform in which this

  /// declaration was introduced.

  ///

  /// \returns An empty version tuple if this declaration has no 'introduced'

  /// availability attributes, or the version tuple that's specified in the

  /// attribute otherwise.

  VersionTuple getVersionIntroduced() const;

  /// Determine whether this declaration is marked 'deprecated'.

  ///

  /// \param Message If non-NULL and the declaration is deprecated,

  /// this will be set to the message describing why the declaration

  /// was deprecated (which may be empty).

  bool isDeprecated(std::string *Message = nullptr) const {

    return getAvailability(Message) == AR_Deprecated;

  }

  /// Determine whether this declaration is marked 'unavailable'.

  ///

  /// \param Message If non-NULL and the declaration is unavailable,

  /// this will be set to the message describing why the declaration

  /// was made unavailable (which may be empty).

  bool isUnavailable(std::string *Message = nullptr) const {

    return getAvailability(Message) == AR_Unavailable;

  }

  /// Determine whether this is a weak-imported symbol.

  ///

  /// Weak-imported symbols are typically marked with the

  /// 'weak_import' attribute, but may also be marked with an

  /// 'availability' attribute where we're targing a platform prior to

  /// the introduction of this feature.

  bool isWeakImported() const;

  /// Determines whether this symbol can be weak-imported,

  /// e.g., whether it would be well-formed to add the weak_import

  /// attribute.

  ///

  /// \param IsDefinition Set to \c true to indicate that this

  /// declaration cannot be weak-imported because it has a definition.

  bool canBeWeakImported(bool &IsDefinition) const;

  /// Determine whether this declaration came from an AST file (such as

  /// a precompiled header or module) rather than having been parsed.

  bool isFromASTFile() const { return FromASTFile; }

  /// Retrieve the global declaration ID associated with this

  /// declaration, which specifies where this Decl was loaded from.

  unsigned getGlobalID() const {

    if (isFromASTFile())

      return *((const unsigned*)this - 1);

    return 0;

  }

  /// Retrieve the global ID of the module that owns this particular

  /// declaration.

  unsigned getOwningModuleID() const {

    if (isFromASTFile())

      return *((const unsigned*)this - 2);

    return 0;

  }

private:

  Module *getOwningModuleSlow() const;

protected:

  bool hasLocalOwningModuleStorage() const;

public:

  /// Get the imported owning module, if this decl is from an imported

  /// (non-local) module.

  Module *getImportedOwningModule() const {

    if (!isFromASTFile() || !hasOwningModule())

      return nullptr;

    return getOwningModuleSlow();

  }

  /// Get the local owning module, if known. Returns nullptr if owner is

  /// not yet known or declaration is not from a module.

  Module *getLocalOwningModule() const {

    if (isFromASTFile() || !hasOwningModule())

      return nullptr;

    assert(hasLocalOwningModuleStorage() &&

           "owned local decl but no local module storage");

    return reinterpret_cast<Module *const *>(this)[-1];

  }

  void setLocalOwningModule(Module *M) {

    assert(!isFromASTFile() && hasOwningModule() &&

           hasLocalOwningModuleStorage() &&

           "should not have a cached owning module");

    reinterpret_cast<Module **>(this)[-1] = M;

  }

  /// Is this declaration owned by some module?

  bool hasOwningModule() const {

    return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;

  }

  /// Get the module that owns this declaration (for visibility purposes).

  Module *getOwningModule() const {

    return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();

  }

  /// Get the module that owns this declaration for linkage purposes.

  /// There only ever is such a module under the C++ Modules TS.

  ///

  /// \param IgnoreLinkage Ignore the linkage of the entity; assume that

  /// all declarations in a global module fragment are unowned.

  Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;

  /// Determine whether this declaration is definitely visible to name lookup,

  /// independent of whether the owning module is visible.

  /// Note: The declaration may be visible even if this returns \c false if the

  /// owning module is visible within the query context. This is a low-level

  /// helper function; most code should be calling Sema::isVisible() instead.

  bool isUnconditionallyVisible() const {

    return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;

  }

  bool isReachable() const {

    return (int)getModuleOwnershipKind() <=

           (int)ModuleOwnershipKind::ReachableWhenImported;

  }

  /// Set that this declaration is globally visible, even if it came from a

  /// module that is not visible.

  void setVisibleDespiteOwningModule() {

    if (!isUnconditionallyVisible())

      setModuleOwnershipKind(ModuleOwnershipKind::Visible);

  }

  /// Get the kind of module ownership for this declaration.

  ModuleOwnershipKind getModuleOwnershipKind() const {

    return NextInContextAndBits.getInt();

  }