//===- ASTContext.h - Context to hold long-lived AST nodes ------*- 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

//

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

//

/// \file

/// Defines the clang::ASTContext interface.

//

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

#ifndef LLVM_CLANG_AST_ASTCONTEXT_H

#define LLVM_CLANG_AST_ASTCONTEXT_H

#include "clang/AST/ASTContextAllocate.h"

#include "clang/AST/ASTFwd.h"

#include "clang/AST/CanonicalType.h"

#include "clang/AST/CommentCommandTraits.h"

#include "clang/AST/ComparisonCategories.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/PrettyPrinter.h"

#include "clang/AST/RawCommentList.h"

#include "clang/AST/TemplateName.h"

#include "clang/AST/Type.h"

#include "clang/Basic/AddressSpaces.h"

#include "clang/Basic/AttrKinds.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/Linkage.h"

#include "clang/Basic/NoSanitizeList.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/ProfileList.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetCXXABI.h"

#include "clang/Basic/XRayLists.h"

#include "llvm/ADT/APSInt.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/None.h"

#include "llvm/ADT/Optional.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringMap.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/TinyPtrVector.h"

#include "llvm/ADT/Triple.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/AlignOf.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/TypeSize.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <iterator>

#include <memory>

#include <string>

#include <type_traits>

#include <utility>

#include <vector>

namespace llvm {

class APFixedPoint;

class FixedPointSemantics;

struct fltSemantics;

template <typename T, unsigned N> class SmallPtrSet;

} // namespace llvm

namespace clang {

class APValue;

class ASTMutationListener;

class ASTRecordLayout;

class AtomicExpr;

class BlockExpr;

class BuiltinTemplateDecl;

class CharUnits;

class ConceptDecl;

class CXXABI;

class CXXConstructorDecl;

class CXXMethodDecl;

class CXXRecordDecl;

class DiagnosticsEngine;

class ParentMapContext;

class DynTypedNodeList;

class Expr;

enum class FloatModeKind;

class GlobalDecl;

class MangleContext;

class MangleNumberingContext;

class MemberSpecializationInfo;

class Module;

struct MSGuidDeclParts;

class ObjCCategoryDecl;

class ObjCCategoryImplDecl;

class ObjCContainerDecl;

class ObjCImplDecl;

class ObjCImplementationDecl;

class ObjCInterfaceDecl;

class ObjCIvarDecl;

class ObjCMethodDecl;

class ObjCPropertyDecl;

class ObjCPropertyImplDecl;

class ObjCProtocolDecl;

class ObjCTypeParamDecl;

class OMPTraitInfo;

struct ParsedTargetAttr;

class Preprocessor;

class StoredDeclsMap;

class TargetAttr;

class TargetInfo;

class TemplateDecl;

class TemplateParameterList;

class TemplateTemplateParmDecl;

class TemplateTypeParmDecl;

class TypeConstraint;

class UnresolvedSetIterator;

class UsingShadowDecl;

class VarTemplateDecl;

class VTableContextBase;

struct BlockVarCopyInit;

namespace Builtin {

class Context;

} // namespace Builtin

enum BuiltinTemplateKind : int;

enum OpenCLTypeKind : uint8_t;

namespace comments {

class FullComment;

} // namespace comments

namespace interp {

class Context;

} // namespace interp

namespace serialization {

template <class> class AbstractTypeReader;

} // namespace serialization

enum class AlignRequirementKind {

  /// The alignment was not explicit in code.

  None,

  /// The alignment comes from an alignment attribute on a typedef.

  RequiredByTypedef,

  /// The alignment comes from an alignment attribute on a record type.

  RequiredByRecord,

  /// The alignment comes from an alignment attribute on a enum type.

  RequiredByEnum,

};

struct TypeInfo {

  uint64_t Width = 0;

  unsigned Align = 0;

  AlignRequirementKind AlignRequirement;

  TypeInfo() : AlignRequirement(AlignRequirementKind::None) {}

  TypeInfo(uint64_t Width, unsigned Align,

           AlignRequirementKind AlignRequirement)

      : Width(Width), Align(Align), AlignRequirement(AlignRequirement) {}

  bool isAlignRequired() {

    return AlignRequirement != AlignRequirementKind::None;

  }

};

struct TypeInfoChars {

  CharUnits Width;

  CharUnits Align;

  AlignRequirementKind AlignRequirement;

  TypeInfoChars() : AlignRequirement(AlignRequirementKind::None) {}

  TypeInfoChars(CharUnits Width, CharUnits Align,

                AlignRequirementKind AlignRequirement)

      : Width(Width), Align(Align), AlignRequirement(AlignRequirement) {}

  bool isAlignRequired() {

    return AlignRequirement != AlignRequirementKind::None;

  }

};

/// Holds long-lived AST nodes (such as types and decls) that can be

/// referred to throughout the semantic analysis of a file.

class ASTContext : public RefCountedBase<ASTContext> {

  friend class NestedNameSpecifier;

  mutable SmallVector<Type *, 0> Types;

  mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;

  mutable llvm::FoldingSet<ComplexType> ComplexTypes;

  mutable llvm::FoldingSet<PointerType> PointerTypes{GeneralTypesLog2InitSize};

  mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;

  mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;

  mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;

  mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;

  mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;

  mutable llvm::ContextualFoldingSet<ConstantArrayType, ASTContext &>

      ConstantArrayTypes;

  mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;

  mutable std::vector<VariableArrayType*> VariableArrayTypes;

  mutable llvm::FoldingSet<DependentSizedArrayType> DependentSizedArrayTypes;

  mutable llvm::FoldingSet<DependentSizedExtVectorType>

    DependentSizedExtVectorTypes;

  mutable llvm::FoldingSet<DependentAddressSpaceType>

      DependentAddressSpaceTypes;

  mutable llvm::FoldingSet<VectorType> VectorTypes;

  mutable llvm::FoldingSet<DependentVectorType> DependentVectorTypes;

  mutable llvm::FoldingSet<ConstantMatrixType> MatrixTypes;

  mutable llvm::FoldingSet<DependentSizedMatrixType> DependentSizedMatrixTypes;

  mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;

  mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>

    FunctionProtoTypes;

  mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;

  mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;

  mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;

  mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;

  mutable llvm::FoldingSet<SubstTemplateTypeParmType>

    SubstTemplateTypeParmTypes;

  mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>

    SubstTemplateTypeParmPackTypes;

  mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>

    TemplateSpecializationTypes;

  mutable llvm::FoldingSet<ParenType> ParenTypes{GeneralTypesLog2InitSize};

  mutable llvm::FoldingSet<UsingType> UsingTypes;

  mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes{

      GeneralTypesLog2InitSize};

  mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;

  mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,

                                     ASTContext&>

    DependentTemplateSpecializationTypes;

  llvm::FoldingSet<PackExpansionType> PackExpansionTypes;

  mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;

  mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;

  mutable llvm::FoldingSet<DependentUnaryTransformType>

    DependentUnaryTransformTypes;

  mutable llvm::ContextualFoldingSet<AutoType, ASTContext&> AutoTypes;

  mutable llvm::FoldingSet<DeducedTemplateSpecializationType>

    DeducedTemplateSpecializationTypes;

  mutable llvm::FoldingSet<AtomicType> AtomicTypes;

  mutable llvm::FoldingSet<AttributedType> AttributedTypes;

  mutable llvm::FoldingSet<PipeType> PipeTypes;

  mutable llvm::FoldingSet<BitIntType> BitIntTypes;

  mutable llvm::FoldingSet<DependentBitIntType> DependentBitIntTypes;

  llvm::FoldingSet<BTFTagAttributedType> BTFTagAttributedTypes;

  mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;

  mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;

  mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>

    SubstTemplateTemplateParms;

  mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,

                                     ASTContext&>

    SubstTemplateTemplateParmPacks;

  /// The set of nested name specifiers.

  ///

  /// This set is managed by the NestedNameSpecifier class.

  mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;

  mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;

  /// A cache mapping from RecordDecls to ASTRecordLayouts.

  ///

  /// This is lazily created.  This is intentionally not serialized.

  mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>

    ASTRecordLayouts;

  mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>

    ObjCLayouts;

  /// A cache from types to size and alignment information.

  using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;

  mutable TypeInfoMap MemoizedTypeInfo;

  /// A cache from types to unadjusted alignment information. Only ARM and

  /// AArch64 targets need this information, keeping it separate prevents

  /// imposing overhead on TypeInfo size.

  using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;

  mutable UnadjustedAlignMap MemoizedUnadjustedAlign;

  /// A cache mapping from CXXRecordDecls to key functions.

  llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;

  /// Mapping from ObjCContainers to their ObjCImplementations.

  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;

  /// Mapping from ObjCMethod to its duplicate declaration in the same

  /// interface.

  llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;

  /// Mapping from __block VarDecls to BlockVarCopyInit.

  llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;

  /// Mapping from GUIDs to the corresponding MSGuidDecl.

  mutable llvm::FoldingSet<MSGuidDecl> MSGuidDecls;

  /// Mapping from APValues to the corresponding UnnamedGlobalConstantDecl.

  mutable llvm::FoldingSet<UnnamedGlobalConstantDecl>

      UnnamedGlobalConstantDecls;

  /// Mapping from APValues to the corresponding TemplateParamObjects.

  mutable llvm::FoldingSet<TemplateParamObjectDecl> TemplateParamObjectDecls;

  /// A cache mapping a string value to a StringLiteral object with the same

  /// value.

  ///

  /// This is lazily created.  This is intentionally not serialized.

  mutable llvm::StringMap<StringLiteral *> StringLiteralCache;

  /// MD5 hash of CUID. It is calculated when first used and cached by this

  /// data member.

  mutable std::string CUIDHash;

  /// Representation of a "canonical" template template parameter that

  /// is used in canonical template names.

  class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {

    TemplateTemplateParmDecl *Parm;

  public:

    CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)

        : Parm(Parm) {}

    TemplateTemplateParmDecl *getParam() const { return Parm; }

    void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {

      Profile(ID, C, Parm);

    }

    static void Profile(llvm::FoldingSetNodeID &ID,

                        const ASTContext &C,

                        TemplateTemplateParmDecl *Parm);

  };

  mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,

                                     const ASTContext&>

    CanonTemplateTemplateParms;

  TemplateTemplateParmDecl *

    getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;

  /// The typedef for the __int128_t type.

  mutable TypedefDecl *Int128Decl = nullptr;

  /// The typedef for the __uint128_t type.

  mutable TypedefDecl *UInt128Decl = nullptr;

  /// The typedef for the target specific predefined

  /// __builtin_va_list type.

  mutable TypedefDecl *BuiltinVaListDecl = nullptr;

  /// The typedef for the predefined \c __builtin_ms_va_list type.

  mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;

  /// The typedef for the predefined \c id type.

  mutable TypedefDecl *ObjCIdDecl = nullptr;

  /// The typedef for the predefined \c SEL type.

  mutable TypedefDecl *ObjCSelDecl = nullptr;

  /// The typedef for the predefined \c Class type.

  mutable TypedefDecl *ObjCClassDecl = nullptr;

  /// The typedef for the predefined \c Protocol class in Objective-C.

  mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;

  /// The typedef for the predefined 'BOOL' type.

  mutable TypedefDecl *BOOLDecl = nullptr;

  // Typedefs which may be provided defining the structure of Objective-C

  // pseudo-builtins

  QualType ObjCIdRedefinitionType;

  QualType ObjCClassRedefinitionType;

  QualType ObjCSelRedefinitionType;

  /// The identifier 'bool'.

  mutable IdentifierInfo *BoolName = nullptr;

  /// The identifier 'NSObject'.

  mutable IdentifierInfo *NSObjectName = nullptr;

  /// The identifier 'NSCopying'.

  IdentifierInfo *NSCopyingName = nullptr;

  /// The identifier '__make_integer_seq'.

  mutable IdentifierInfo *MakeIntegerSeqName = nullptr;

  /// The identifier '__type_pack_element'.

  mutable IdentifierInfo *TypePackElementName = nullptr;

  QualType ObjCConstantStringType;

  mutable RecordDecl *CFConstantStringTagDecl = nullptr;

  mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;

  mutable QualType ObjCSuperType;

  QualType ObjCNSStringType;

  /// The typedef declaration for the Objective-C "instancetype" type.

  TypedefDecl *ObjCInstanceTypeDecl = nullptr;

  /// The type for the C FILE type.

  TypeDecl *FILEDecl = nullptr;

  /// The type for the C jmp_buf type.

  TypeDecl *jmp_bufDecl = nullptr;

  /// The type for the C sigjmp_buf type.

  TypeDecl *sigjmp_bufDecl = nullptr;

  /// The type for the C ucontext_t type.

  TypeDecl *ucontext_tDecl = nullptr;

  /// Type for the Block descriptor for Blocks CodeGen.

  ///

  /// Since this is only used for generation of debug info, it is not

  /// serialized.

  mutable RecordDecl *BlockDescriptorType = nullptr;

  /// Type for the Block descriptor for Blocks CodeGen.

  ///

  /// Since this is only used for generation of debug info, it is not

  /// serialized.

  mutable RecordDecl *BlockDescriptorExtendedType = nullptr;

  /// Declaration for the CUDA cudaConfigureCall function.

  FunctionDecl *cudaConfigureCallDecl = nullptr;

  /// Keeps track of all declaration attributes.

  ///

  /// Since so few decls have attrs, we keep them in a hash map instead of

  /// wasting space in the Decl class.

  llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;

  /// A mapping from non-redeclarable declarations in modules that were

  /// merged with other declarations to the canonical declaration that they were

  /// merged into.

  llvm::DenseMap<Decl*, Decl*> MergedDecls;

  /// A mapping from a defining declaration to a list of modules (other

  /// than the owning module of the declaration) that contain merged

  /// definitions of that entity.

  llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;

  /// Initializers for a module, in order. Each Decl will be either

  /// something that has a semantic effect on startup (such as a variable with

  /// a non-constant initializer), or an ImportDecl (which recursively triggers

  /// initialization of another module).

  struct PerModuleInitializers {

    llvm::SmallVector<Decl*, 4> Initializers;

    llvm::SmallVector<uint32_t, 4> LazyInitializers;

    void resolve(ASTContext &Ctx);

  };

  llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;

  static constexpr unsigned ConstantArrayTypesLog2InitSize = 8;

  static constexpr unsigned GeneralTypesLog2InitSize = 9;

  static constexpr unsigned FunctionProtoTypesLog2InitSize = 12;

  ASTContext &this_() { return *this; }

public:

  /// A type synonym for the TemplateOrInstantiation mapping.

  using TemplateOrSpecializationInfo =

      llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>;

private:

  friend class ASTDeclReader;

  friend class ASTReader;

  friend class ASTWriter;

  template <class> friend class serialization::AbstractTypeReader;

  friend class CXXRecordDecl;

  friend class IncrementalParser;

  /// A mapping to contain the template or declaration that

  /// a variable declaration describes or was instantiated from,

  /// respectively.

  ///

  /// For non-templates, this value will be NULL. For variable

  /// declarations that describe a variable template, this will be a

  /// pointer to a VarTemplateDecl. For static data members

  /// of class template specializations, this will be the

  /// MemberSpecializationInfo referring to the member variable that was

  /// instantiated or specialized. Thus, the mapping will keep track of

  /// the static data member templates from which static data members of

  /// class template specializations were instantiated.

  ///

  /// Given the following example:

  ///

  /// \code

  /// template<typename T>

  /// struct X {

  ///   static T value;

  /// };

  ///

  /// template<typename T>

  ///   T X<T>::value = T(17);

  ///

  /// int *x = &X<int>::value;

  /// \endcode

  ///

  /// This mapping will contain an entry that maps from the VarDecl for

  /// X<int>::value to the corresponding VarDecl for X<T>::value (within the

  /// class template X) and will be marked TSK_ImplicitInstantiation.

  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>

  TemplateOrInstantiation;

  /// Keeps track of the declaration from which a using declaration was

  /// created during instantiation.

  ///

  /// The source and target declarations are always a UsingDecl, an

  /// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.

  ///

  /// For example:

  /// \code

  /// template<typename T>

  /// struct A {

  ///   void f();

  /// };

  ///

  /// template<typename T>

  /// struct B : A<T> {

  ///   using A<T>::f;

  /// };

  ///

  /// template struct B<int>;

  /// \endcode

  ///

  /// This mapping will contain an entry that maps from the UsingDecl in

  /// B<int> to the UnresolvedUsingDecl in B<T>.

  llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;

  /// Like InstantiatedFromUsingDecl, but for using-enum-declarations. Maps

  /// from the instantiated using-enum to the templated decl from whence it

  /// came.

  /// Note that using-enum-declarations cannot be dependent and

  /// thus will never be instantiated from an "unresolved"

  /// version thereof (as with using-declarations), so each mapping is from

  /// a (resolved) UsingEnumDecl to a (resolved) UsingEnumDecl.

  llvm::DenseMap<UsingEnumDecl *, UsingEnumDecl *>

      InstantiatedFromUsingEnumDecl;

  /// Simlarly maps instantiated UsingShadowDecls to their origin.

  llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>

    InstantiatedFromUsingShadowDecl;

  llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;

  /// Mapping that stores the methods overridden by a given C++

  /// member function.

  ///

  /// Since most C++ member functions aren't virtual and therefore

  /// don't override anything, we store the overridden functions in

  /// this map on the side rather than within the CXXMethodDecl structure.

  using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;

  llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;

  /// Mapping from each declaration context to its corresponding

  /// mangling numbering context (used for constructs like lambdas which

  /// need to be consistently numbered for the mangler).

  llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>

      MangleNumberingContexts;

  llvm::DenseMap<const Decl *, std::unique_ptr<MangleNumberingContext>>

      ExtraMangleNumberingContexts;

  /// Side-table of mangling numbers for declarations which rarely

  /// need them (like static local vars).

  llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;

  llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;

  /// Mapping the associated device lambda mangling number if present.

  mutable llvm::DenseMap<const CXXRecordDecl *, unsigned>

      DeviceLambdaManglingNumbers;

  /// Mapping that stores parameterIndex values for ParmVarDecls when

  /// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.

  using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;

  ParameterIndexTable ParamIndices;

  ImportDecl *FirstLocalImport = nullptr;

  ImportDecl *LastLocalImport = nullptr;

  TranslationUnitDecl *TUDecl = nullptr;

  mutable ExternCContextDecl *ExternCContext = nullptr;

  mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;

  mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;

  /// The associated SourceManager object.

  SourceManager &SourceMgr;

  /// The language options used to create the AST associated with

  ///  this ASTContext object.

  LangOptions &LangOpts;

  /// NoSanitizeList object that is used by sanitizers to decide which

  /// entities should not be instrumented.

  std::unique_ptr<NoSanitizeList> NoSanitizeL;

  /// Function filtering mechanism to determine whether a given function

  /// should be imbued with the XRay "always" or "never" attributes.

  std::unique_ptr<XRayFunctionFilter> XRayFilter;

  /// ProfileList object that is used by the profile instrumentation

  /// to decide which entities should be instrumented.

  std::unique_ptr<ProfileList> ProfList;

  /// The allocator used to create AST objects.

  ///

  /// AST objects are never destructed; rather, all memory associated with the

  /// AST objects will be released when the ASTContext itself is destroyed.

  mutable llvm::BumpPtrAllocator BumpAlloc;

  /// Allocator for partial diagnostics.

  PartialDiagnostic::DiagStorageAllocator DiagAllocator;

  /// The current C++ ABI.

  std::unique_ptr<CXXABI> ABI;

  CXXABI *createCXXABI(const TargetInfo &T);

  /// The logical -> physical address space map.

  const LangASMap *AddrSpaceMap = nullptr;

  /// Address space map mangling must be used with language specific

  /// address spaces (e.g. OpenCL/CUDA)

  bool AddrSpaceMapMangling;

  const TargetInfo *Target = nullptr;

  const TargetInfo *AuxTarget = nullptr;

  clang::PrintingPolicy PrintingPolicy;

  std::unique_ptr<interp::Context> InterpContext;

  std::unique_ptr<ParentMapContext> ParentMapCtx;

  /// Keeps track of the deallocated DeclListNodes for future reuse.

  DeclListNode *ListNodeFreeList = nullptr;

public:

  IdentifierTable &Idents;

  SelectorTable &Selectors;

  Builtin::Context &BuiltinInfo;

  const TranslationUnitKind TUKind;

  mutable DeclarationNameTable DeclarationNames;

  IntrusiveRefCntPtr<ExternalASTSource> ExternalSource;

  ASTMutationListener *Listener = nullptr;

  /// Returns the clang bytecode interpreter context.

  interp::Context &getInterpContext();

  struct CUDAConstantEvalContext {

    /// Do not allow wrong-sided variables in constant expressions.

    bool NoWrongSidedVars = false;

  } CUDAConstantEvalCtx;

  struct CUDAConstantEvalContextRAII {

    ASTContext &Ctx;

    CUDAConstantEvalContext SavedCtx;

    CUDAConstantEvalContextRAII(ASTContext &Ctx_, bool NoWrongSidedVars)

        : Ctx(Ctx_), SavedCtx(Ctx_.CUDAConstantEvalCtx) {

      Ctx_.CUDAConstantEvalCtx.NoWrongSidedVars = NoWrongSidedVars;

    }

    ~CUDAConstantEvalContextRAII() { Ctx.CUDAConstantEvalCtx = SavedCtx; }

  };

  /// Returns the dynamic AST node parent map context.

  ParentMapContext &getParentMapContext();

  // A traversal scope limits the parts of the AST visible to certain analyses.

  // RecursiveASTVisitor only visits specified children of TranslationUnitDecl.

  // getParents() will only observe reachable parent edges.

  //

  // The scope is defined by a set of "top-level" declarations which will be

  // visible under the TranslationUnitDecl.

  // Initially, it is the entire TU, represented by {getTranslationUnitDecl()}.

  //

  // After setTraversalScope({foo, bar}), the exposed AST looks like:

  // TranslationUnitDecl

  //  - foo

  //    - ...

  //  - bar

  //    - ...

  // All other siblings of foo and bar are pruned from the tree.

  // (However they are still accessible via TranslationUnitDecl->decls())

  //

  // Changing the scope clears the parent cache, which is expensive to rebuild.

  std::vector<Decl *> getTraversalScope() const { return TraversalScope; }

  void setTraversalScope(const std::vector<Decl *> &);

  /// Forwards to get node parents from the ParentMapContext. New callers should

  /// use ParentMapContext::getParents() directly.

  template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);

  const clang::PrintingPolicy &getPrintingPolicy() const {

    return PrintingPolicy;

  }

  void setPrintingPolicy(const clang::PrintingPolicy &Policy) {

    PrintingPolicy = Policy;

  }

  SourceManager& getSourceManager() { return SourceMgr; }

  const SourceManager& getSourceManager() const { return SourceMgr; }

  // Cleans up some of the data structures. This allows us to do cleanup

  // normally done in the destructor earlier. Renders much of the ASTContext

  // unusable, mostly the actual AST nodes, so should be called when we no

  // longer need access to the AST.

  void cleanup();

  llvm::BumpPtrAllocator &getAllocator() const {

    return BumpAlloc;

  }

  void *Allocate(size_t Size, unsigned Align = 8) const {

    return BumpAlloc.Allocate(Size, Align);

  }

  template <typename T> T *Allocate(size_t Num = 1) const {

    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));

  }

clang::BlockDecl::Capture* clang::ASTContext::Allocate<clang::BlockDecl::Capture>(unsigned long) const

Line

Count

Source

733

1.51k

  template <typename T> T *Allocate(size_t Num = 1) const {

734

1.51k

    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));

735

1.51k

  }

char* clang::ASTContext::Allocate<char>(unsigned long) const

Line

Count

Source

733

606

  template <typename T> T *Allocate(size_t Num = 1) const {

734

606

    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));

735

606

  }

clang::TemplateArgument* clang::ASTContext::Allocate<clang::TemplateArgument>(unsigned long) const

Line

Count

Source

733

698k

  template <typename T> T *Allocate(size_t Num = 1) const {

734

698k

    return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));

735

698k

  }

Unexecuted instantiation: clang::QualType* clang::ASTContext::Allocate<clang::QualType>(unsigned long) const

  void Deallocate(void *Ptr) const {}

  /// Allocates a \c DeclListNode or returns one from the \c ListNodeFreeList

  /// pool.

  DeclListNode *AllocateDeclListNode(clang::NamedDecl *ND) {

    if (DeclListNode *Alloc = ListNodeFreeList) {

      ListNodeFreeList = Alloc->Rest.dyn_cast<DeclListNode*>();

      Alloc->D = ND;

      Alloc->Rest = nullptr;

      return Alloc;

    }

    return new (*this) DeclListNode(ND);

  }

  /// Deallcates a \c DeclListNode by returning it to the \c ListNodeFreeList

  /// pool.

  void DeallocateDeclListNode(DeclListNode *N) {

    N->Rest = ListNodeFreeList;

    ListNodeFreeList = N;

  }

  /// Return the total amount of physical memory allocated for representing

  /// AST nodes and type information.

  size_t getASTAllocatedMemory() const {

    return BumpAlloc.getTotalMemory();

  }

  /// Return the total memory used for various side tables.

  size_t getSideTableAllocatedMemory() const;

  PartialDiagnostic::DiagStorageAllocator &getDiagAllocator() {

    return DiagAllocator;

  }

  const TargetInfo &getTargetInfo() const { return *Target; }

  const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }

  /// getIntTypeForBitwidth -

  /// sets integer QualTy according to specified details:

  /// bitwidth, signed/unsigned.

  /// Returns empty type if there is no appropriate target types.

  QualType getIntTypeForBitwidth(unsigned DestWidth,

                                 unsigned Signed) const;

  /// getRealTypeForBitwidth -

  /// sets floating point QualTy according to specified bitwidth.

  /// Returns empty type if there is no appropriate target types.

  QualType getRealTypeForBitwidth(unsigned DestWidth,

                                  FloatModeKind ExplicitType) const;

  bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;

  const LangOptions& getLangOpts() const { return LangOpts; }

  // If this condition is false, typo correction must be performed eagerly

  // rather than delayed in many places, as it makes use of dependent types.

  // the condition is false for clang's C-only codepath, as it doesn't support

  // dependent types yet.

  bool isDependenceAllowed() const {

    return LangOpts.CPlusPlus || 
LangOpts.RecoveryAST12.1M
;

  }

  const NoSanitizeList &getNoSanitizeList() const { return *NoSanitizeL; }

  const XRayFunctionFilter &getXRayFilter() const {

    return *XRayFilter;

  }

  const ProfileList &getProfileList() const { return *ProfList; }

  DiagnosticsEngine &getDiagnostics() const;

  FullSourceLoc getFullLoc(SourceLocation Loc) const {

    return FullSourceLoc(Loc,SourceMgr);

  }

  /// Return the C++ ABI kind that should be used. The C++ ABI can be overriden

  /// at compile time with `-fc++-abi=`. If this is not provided, we instead use

  /// the default ABI set by the target.

  TargetCXXABI::Kind getCXXABIKind() const;

  /// All comments in this translation unit.

  RawCommentList Comments;

  /// True if comments are already loaded from ExternalASTSource.

  mutable bool CommentsLoaded = false;

  /// Mapping from declaration to directly attached comment.

  ///

  /// Raw comments are owned by Comments list.  This mapping is populated

  /// lazily.

  mutable llvm::DenseMap<const Decl *, const RawComment *> DeclRawComments;

  /// Mapping from canonical declaration to the first redeclaration in chain

  /// that has a comment attached.

  ///

  /// Raw comments are owned by Comments list.  This mapping is populated

  /// lazily.

  mutable llvm::DenseMap<const Decl *, const Decl *> RedeclChainComments;

  /// Keeps track of redeclaration chains that don't have any comment attached.

  /// Mapping from canonical declaration to redeclaration chain that has no

  /// comments attached to any redeclaration. Specifically it's mapping to

  /// the last redeclaration we've checked.

  ///

  /// Shall not contain declarations that have comments attached to any

  /// redeclaration in their chain.

  mutable llvm::DenseMap<const Decl *, const Decl *> CommentlessRedeclChains;

  /// Mapping from declarations to parsed comments attached to any

  /// redeclaration.

  mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;

  /// Attaches \p Comment to \p OriginalD and to its redeclaration chain

  /// and removes the redeclaration chain from the set of commentless chains.

  ///

  /// Don't do anything if a comment has already been attached to \p OriginalD

  /// or its redeclaration chain.

  void cacheRawCommentForDecl(const Decl &OriginalD,

                              const RawComment &Comment) const;

  /// \returns searches \p CommentsInFile for doc comment for \p D.

  ///

  /// \p RepresentativeLocForDecl is used as a location for searching doc

  /// comments. \p CommentsInFile is a mapping offset -> comment of files in the

  /// same file where \p RepresentativeLocForDecl is.

  RawComment *getRawCommentForDeclNoCacheImpl(

      const Decl *D, const SourceLocation RepresentativeLocForDecl,

      const std::map<unsigned, RawComment *> &CommentsInFile) const;

  /// Return the documentation comment attached to a given declaration,

  /// without looking into cache.

  RawComment *getRawCommentForDeclNoCache(const Decl *D) const;

public:

  void addComment(const RawComment &RC);

  /// Return the documentation comment attached to a given declaration.

  /// Returns nullptr if no comment is attached.

  ///

  /// \param OriginalDecl if not nullptr, is set to declaration AST node that

  /// had the comment, if the comment we found comes from a redeclaration.

  const RawComment *

  getRawCommentForAnyRedecl(const Decl *D,

                            const Decl **OriginalDecl = nullptr) const;

  /// Searches existing comments for doc comments that should be attached to \p

  /// Decls. If any doc comment is found, it is parsed.

  ///

  /// Requirement: All \p Decls are in the same file.

  ///

  /// If the last comment in the file is already attached we assume

  /// there are not comments left to be attached to \p Decls.

  void attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,

                                       const Preprocessor *PP);

  /// Return parsed documentation comment attached to a given declaration.

  /// Returns nullptr if no comment is attached.

  ///

  /// \param PP the Preprocessor used with this TU.  Could be nullptr if

  /// preprocessor is not available.

  comments::FullComment *getCommentForDecl(const Decl *D,

                                           const Preprocessor *PP) const;

  /// Return parsed documentation comment attached to a given declaration.

  /// Returns nullptr if no comment is attached. Does not look at any

  /// redeclarations of the declaration.

  comments::FullComment *getLocalCommentForDeclUncached(const Decl *D) const;

  comments::FullComment *cloneFullComment(comments::FullComment *FC,

                                         const Decl *D) const;

private:

  mutable comments::CommandTraits CommentCommandTraits;

  /// Iterator that visits import declarations.

  class import_iterator {

    ImportDecl *Import = nullptr;

  public:

    using value_type = ImportDecl *;

    using reference = ImportDecl *;

    using pointer = ImportDecl *;

    using difference_type = int;

    using iterator_category = std::forward_iterator_tag;

    import_iterator() = default;

    explicit import_iterator(ImportDecl *Import) : Import(Import) {}

    reference operator*() const { return Import; }

    pointer operator->() const { return Import; }

    import_iterator &operator++() {

      Import = ASTContext::getNextLocalImport(Import);

      return *this;

    }

    import_iterator operator++(int) {

      import_iterator Other(*this);

      ++(*this);

      return Other;

    }

    friend bool operator==(import_iterator X, import_iterator Y) {

      return X.Import == Y.Import;

    }

    friend bool operator!=(import_iterator X, import_iterator Y) {

      return X.Import != Y.Import;

    }

  };

public:

  comments::CommandTraits &getCommentCommandTraits() const {

    return CommentCommandTraits;

  }

  /// Retrieve the attributes for the given declaration.

  AttrVec& getDeclAttrs(const Decl *D);

  /// Erase the attributes corresponding to the given declaration.

  void eraseDeclAttrs(const Decl *D);

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

  // FIXME: Remove ?

  MemberSpecializationInfo *getInstantiatedFromStaticDataMember(

                                                           const VarDecl *Var);

  /// Note that the static data member \p Inst is an instantiation of

  /// the static data member template \p Tmpl of a class template.

  void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,

                                           TemplateSpecializationKind TSK,

                        SourceLocation PointOfInstantiation = SourceLocation());

  TemplateOrSpecializationInfo

  getTemplateOrSpecializationInfo(const VarDecl *Var);

  void setTemplateOrSpecializationInfo(VarDecl *Inst,

                                       TemplateOrSpecializationInfo TSI);

  /// If the given using decl \p Inst is an instantiation of

  /// another (possibly unresolved) using decl, return it.

  NamedDecl *getInstantiatedFromUsingDecl(NamedDecl *Inst);

  /// Remember that the using decl \p Inst is an instantiation

  /// of the using decl \p Pattern of a class template.

  void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern);

  /// If the given using-enum decl \p Inst is an instantiation of

  /// another using-enum decl, return it.

  UsingEnumDecl *getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst);

  /// Remember that the using enum decl \p Inst is an instantiation

  /// of the using enum decl \p Pattern of a class template.

  void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst,

                                        UsingEnumDecl *Pattern);

  UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);

  void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,

                                          UsingShadowDecl *Pattern);

  FieldDecl *getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field);

  void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl);

  // Access to the set of methods overridden by the given C++ method.

  using overridden_cxx_method_iterator = CXXMethodVector::const_iterator;

  overridden_cxx_method_iterator

  overridden_methods_begin(const CXXMethodDecl *Method) const;

  overridden_cxx_method_iterator

  overridden_methods_end(const CXXMethodDecl *Method) const;

  unsigned overridden_methods_size(const CXXMethodDecl *Method) const;

  using overridden_method_range =

      llvm::iterator_range<overridden_cxx_method_iterator>;

  overridden_method_range overridden_methods(const CXXMethodDecl *Method) const;

  /// Note that the given C++ \p Method overrides the given \p

  /// Overridden method.

  void addOverriddenMethod(const CXXMethodDecl *Method,

                           const CXXMethodDecl *Overridden);

  /// Return C++ or ObjC overridden methods for the given \p Method.

  ///

  /// An ObjC method is considered to override any method in the class's

  /// base classes, its protocols, or its categories' protocols, that has

  /// the same selector and is of the same kind (class or instance).

  /// A method in an implementation is not considered as overriding the same

  /// method in the interface or its categories.

  void getOverriddenMethods(

                        const NamedDecl *Method,

                        SmallVectorImpl<const NamedDecl *> &Overridden) const;

  /// Notify the AST context that a new import declaration has been

  /// parsed or implicitly created within this translation unit.

  void addedLocalImportDecl(ImportDecl *Import);

  static ImportDecl *getNextLocalImport(ImportDecl *Import) {

    return Import->getNextLocalImport();

  }

  using import_range = llvm::iterator_range<import_iterator>;

  import_range local_imports() const {

    return import_range(import_iterator(FirstLocalImport), import_iterator());

  }

  Decl *getPrimaryMergedDecl(Decl *D) {

    Decl *Result = MergedDecls.lookup(D);

    return Result ? 
Result13.1k
 : 
D1.86M
;

  }

  void setPrimaryMergedDecl(Decl *D, Decl *Primary) {

    MergedDecls[D] = Primary;

  }

  /// Note that the definition \p ND has been merged into module \p M,

  /// and should be visible whenever \p M is visible.

  void mergeDefinitionIntoModule(NamedDecl *ND, Module *M,

                                 bool NotifyListeners = true);

  /// Clean up the merged definition list. Call this if you might have

  /// added duplicates into the list.

  void deduplicateMergedDefinitonsFor(NamedDecl *ND);

  /// Get the additional modules in which the definition \p Def has

  /// been merged.

  ArrayRef<Module*> getModulesWithMergedDefinition(const NamedDecl *Def);

  /// Add a declaration to the list of declarations that are initialized

  /// for a module. This will typically be a global variable (with internal

  /// linkage) that runs module initializers, such as the iostream initializer,

  /// or an ImportDecl nominating another module that has initializers.

  void addModuleInitializer(Module *M, Decl *Init);

  void addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs);

  /// Get the initializations to perform when importing a module, if any.

  ArrayRef<Decl*> getModuleInitializers(Module *M);

  TranslationUnitDecl *getTranslationUnitDecl() const {

    return TUDecl->getMostRecentDecl();

  }

  void addTranslationUnitDecl() {

    assert(!TUDecl || TUKind == TU_Incremental);

    TranslationUnitDecl *NewTUDecl = TranslationUnitDecl::Create(*this);

    if (TraversalScope.empty() || 
TraversalScope.back() == TUDecl112
)

      TraversalScope = {NewTUDecl};

    if (TUDecl)

      NewTUDecl->setPreviousDecl(TUDecl);

    TUDecl = NewTUDecl;

  }

  ExternCContextDecl *getExternCContextDecl() const;

  BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;

  BuiltinTemplateDecl *getTypePackElementDecl() const;

  // Builtin Types.

  CanQualType VoidTy;

  CanQualType BoolTy;

  CanQualType CharTy;

  CanQualType WCharTy;  // [C++ 3.9.1p5].

  CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.

  CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.

  CanQualType Char8Ty;  // [C++20 proposal]

  CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.