Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

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;

  }

 

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<TypedefType> TypedefTypes;

  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;

 

  /// For module code-gen cases, this is the top-level module we are building.

  Module *TopLevelModule = nullptr;

 

  static constexpr unsigned ConstantArrayTypesLog2InitSize = 8;

  static constexpr unsigned GeneralTypesLog2InitSize = 9;

  static constexpr unsigned FunctionProtoTypesLog2InitSize = 12;

 

  ASTContext &this_() { return *this; }

 

  /// A type synonym for the TemplateOrInstantiation mapping.

  using TemplateOrSpecializationInfo =

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

 

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

 

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

 

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

  }

  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.RecoveryAST;

  }

 

  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;

 

  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;

 

  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;

    }

  };

 

  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 ? Result : D;

  }

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

 

  /// Set the (C++20) module we are building.

  void setModuleForCodeGen(Module *M) { TopLevelModule = M; }

 

  /// Get module under construction, nullptr if this is not a C++20 module.

  Module *getModuleForCodeGen() const { return TopLevelModule; }

 

  TranslationUnitDecl *getTranslationUnitDecl() const {

    return TUDecl->getMostRecentDecl();

  }

  void addTranslationUnitDecl() {

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

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

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

      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.

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

  CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;

  CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;

  CanQualType UnsignedLongLongTy, UnsignedInt128Ty;

  CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty, Ibm128Ty;

  CanQualType ShortAccumTy, AccumTy,

      LongAccumTy;  // ISO/IEC JTC1 SC22 WG14 N1169 Extension

  CanQualType UnsignedShortAccumTy, UnsignedAccumTy, UnsignedLongAccumTy;

  CanQualType ShortFractTy, FractTy, LongFractTy;

  CanQualType UnsignedShortFractTy, UnsignedFractTy, UnsignedLongFractTy;

  CanQualType SatShortAccumTy, SatAccumTy, SatLongAccumTy;

  CanQualType SatUnsignedShortAccumTy, SatUnsignedAccumTy,

      SatUnsignedLongAccumTy;

  CanQualType SatShortFractTy, SatFractTy, SatLongFractTy;

  CanQualType SatUnsignedShortFractTy, SatUnsignedFractTy,

      SatUnsignedLongFractTy;

  CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON

  CanQualType BFloat16Ty;

  CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3

  CanQualType VoidPtrTy, NullPtrTy;

  CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;

  CanQualType BuiltinFnTy;

  CanQualType PseudoObjectTy, ARCUnbridgedCastTy;

  CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;

  CanQualType ObjCBuiltinBoolTy;

  CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;

  CanQualType OCLQueueTy, OCLReserveIDTy;

  CanQualType IncompleteMatrixIdxTy;

  CanQualType OMPArraySectionTy, OMPArrayShapingTy, OMPIteratorTy;

 

  // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.

  mutable QualType AutoDeductTy;     // Deduction against 'auto'.

  mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.

 

  // Decl used to help define __builtin_va_list for some targets.

  // The decl is built when constructing 'BuiltinVaListDecl'.

  mutable Decl *VaListTagDecl = nullptr;

 

  // Implicitly-declared type 'struct _GUID'.

  mutable TagDecl *MSGuidTagDecl = nullptr;

 

  /// Keep track of CUDA/HIP device-side variables ODR-used by host code.

  llvm::DenseSet<const VarDecl *> CUDADeviceVarODRUsedByHost;

 

  /// Keep track of CUDA/HIP external kernels or device variables ODR-used by

  /// host code.

  llvm::DenseSet<const ValueDecl *> CUDAExternalDeviceDeclODRUsedByHost;

 

  ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents,

             SelectorTable &sels, Builtin::Context &builtins,

             TranslationUnitKind TUKind);

  ASTContext(const ASTContext &) = delete;

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

  ~ASTContext();

 

  /// Attach an external AST source to the AST context.

  ///

  /// The external AST source provides the ability to load parts of

  /// the abstract syntax tree as needed from some external storage,

  /// e.g., a precompiled header.

  void setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source);

 

  /// Retrieve a pointer to the external AST source associated

  /// with this AST context, if any.

  ExternalASTSource *getExternalSource() const {

    return ExternalSource.get();

  }

 

  /// Attach an AST mutation listener to the AST context.

  ///

  /// The AST mutation listener provides the ability to track modifications to

  /// the abstract syntax tree entities committed after they were initially

  /// created.

  void setASTMutationListener(ASTMutationListener *Listener) {

    this->Listener = Listener;

  }

 

  /// Retrieve a pointer to the AST mutation listener associated

  /// with this AST context, if any.

  ASTMutationListener *getASTMutationListener() const { return Listener; }

 

  void PrintStats() const;

  const SmallVectorImpl<Type *>& getTypes() const { return Types; }

 

  BuiltinTemplateDecl *buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,

                                                const IdentifierInfo *II) const;

 

  /// Create a new implicit TU-level CXXRecordDecl or RecordDecl

  /// declaration.

  RecordDecl *buildImplicitRecord(StringRef Name,

                                  RecordDecl::TagKind TK = TTK_Struct) const;

 

  /// Create a new implicit TU-level typedef declaration.

  TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;

 

  /// Retrieve the declaration for the 128-bit signed integer type.

  TypedefDecl *getInt128Decl() const;

 

  /// Retrieve the declaration for the 128-bit unsigned integer type.

  TypedefDecl *getUInt128Decl() const;

 

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

  //                           Type Constructors

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

 

  /// Return a type with extended qualifiers.

  QualType getExtQualType(const Type *Base, Qualifiers Quals) const;

 

  QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;

 

  QualType getPipeType(QualType T, bool ReadOnly) const;

 

  /// Return the uniqued reference to the type for an address space

  /// qualified type with the specified type and address space.

  ///

  /// The resulting type has a union of the qualifiers from T and the address

  /// space. If T already has an address space specifier, it is silently

  /// replaced.

  QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;

 

  /// Remove any existing address space on the type and returns the type

  /// with qualifiers intact (or that's the idea anyway)

  ///

  /// The return type should be T with all prior qualifiers minus the address

  /// space.

  QualType removeAddrSpaceQualType(QualType T) const;

 

  /// Apply Objective-C protocol qualifiers to the given type.

  /// \param allowOnPointerType specifies if we can apply protocol

  /// qualifiers on ObjCObjectPointerType. It can be set to true when

  /// constructing the canonical type of a Objective-C type parameter.

  QualType applyObjCProtocolQualifiers(QualType type,

      ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,

      bool allowOnPointerType = false) const;

 

  /// Return the uniqued reference to the type for an Objective-C

  /// gc-qualified type.

  ///

  /// The resulting type has a union of the qualifiers from T and the gc

  /// attribute.

  QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const;

 

  /// Remove the existing address space on the type if it is a pointer size

  /// address space and return the type with qualifiers intact.

  QualType removePtrSizeAddrSpace(QualType T) const;

 

  /// Return the uniqued reference to the type for a \c restrict

  /// qualified type.

  ///

  /// The resulting type has a union of the qualifiers from \p T and

  /// \c restrict.

  QualType getRestrictType(QualType T) const {

    return T.withFastQualifiers(Qualifiers::Restrict);

  }

 

  /// Return the uniqued reference to the type for a \c volatile

  /// qualified type.

  ///

  /// The resulting type has a union of the qualifiers from \p T and

  /// \c volatile.

  QualType getVolatileType(QualType T) const {

    return T.withFastQualifiers(Qualifiers::Volatile);

  }

 

  /// Return the uniqued reference to the type for a \c const

  /// qualified type.

  ///

  /// The resulting type has a union of the qualifiers from \p T and \c const.

  ///

  /// It can be reasonably expected that this will always be equivalent to

  /// calling T.withConst().

  QualType getConstType(QualType T) const { return T.withConst(); }

 

  /// Change the ExtInfo on a function type.

  const FunctionType *adjustFunctionType(const FunctionType *Fn,

                                         FunctionType::ExtInfo EInfo);

 

  /// Adjust the given function result type.

  CanQualType getCanonicalFunctionResultType(QualType ResultType) const;

 

  /// Change the result type of a function type once it is deduced.

  void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType);

 

  /// Get a function type and produce the equivalent function type with the

  /// specified exception specification. Type sugar that can be present on a

  /// declaration of a function with an exception specification is permitted

  /// and preserved. Other type sugar (for instance, typedefs) is not.

  QualType getFunctionTypeWithExceptionSpec(

      QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const;

 

  /// Determine whether two function types are the same, ignoring

  /// exception specifications in cases where they're part of the type.

  bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const;

 

  /// Change the exception specification on a function once it is

  /// delay-parsed, instantiated, or computed.

  void adjustExceptionSpec(FunctionDecl *FD,

                           const FunctionProtoType::ExceptionSpecInfo &ESI,

                           bool AsWritten = false);

 

  /// Get a function type and produce the equivalent function type where

  /// pointer size address spaces in the return type and parameter tyeps are

  /// replaced with the default address space.

  QualType getFunctionTypeWithoutPtrSizes(QualType T);

 

  /// Determine whether two function types are the same, ignoring pointer sizes

  /// in the return type and parameter types.

  bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U);

 

  /// Return the uniqued reference to the type for a complex

  /// number with the specified element type.

  QualType getComplexType(QualType T) const;

  CanQualType getComplexType(CanQualType T) const {

    return CanQualType::CreateUnsafe(getComplexType((QualType) T));

  }

 

  /// Return the uniqued reference to the type for a pointer to

  /// the specified type.

  QualType getPointerType(QualType T) const;

  CanQualType getPointerType(CanQualType T) const {

    return CanQualType::CreateUnsafe(getPointerType((QualType) T));

  }

 

  /// Return the uniqued reference to a type adjusted from the original

  /// type to a new type.

  QualType getAdjustedType(QualType Orig, QualType New) const;

  CanQualType getAdjustedType(CanQualType Orig, CanQualType New) const {

    return CanQualType::CreateUnsafe(

        getAdjustedType((QualType)Orig, (QualType)New));

  }

 

  /// Return the uniqued reference to the decayed version of the given

  /// type.  Can only be called on array and function types which decay to

  /// pointer types.

  QualType getDecayedType(QualType T) const;

  CanQualType getDecayedType(CanQualType T) const {

    return CanQualType::CreateUnsafe(getDecayedType((QualType) T));

  }

  /// Return the uniqued reference to a specified decay from the original

  /// type to the decayed type.

  QualType getDecayedType(QualType Orig, QualType Decayed) const;

 

  /// Return the uniqued reference to the atomic type for the specified

  /// type.

  QualType getAtomicType(QualType T) const;

 

  /// Return the uniqued reference to the type for a block of the

  /// specified type.

  QualType getBlockPointerType(QualType T) const;

 

  /// Gets the struct used to keep track of the descriptor for pointer to

  /// blocks.

  QualType getBlockDescriptorType() const;

 

  /// Return a read_only pipe type for the specified type.

  QualType getReadPipeType(QualType T) const;

 

  /// Return a write_only pipe type for the specified type.

  QualType getWritePipeType(QualType T) const;

 

  /// Return a bit-precise integer type with the specified signedness and bit

  /// count.

  QualType getBitIntType(bool Unsigned, unsigned NumBits) const;

 

  /// Return a dependent bit-precise integer type with the specified signedness

  /// and bit count.

  QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const;

 

  /// Gets the struct used to keep track of the extended descriptor for

  /// pointer to blocks.

  QualType getBlockDescriptorExtendedType() const;

 

  /// Map an AST Type to an OpenCLTypeKind enum value.

  OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;

 

  /// Get address space for OpenCL type.

  LangAS getOpenCLTypeAddrSpace(const Type *T) const;

 

  /// Returns default address space based on OpenCL version and enabled features

  inline LangAS getDefaultOpenCLPointeeAddrSpace() {

    return LangOpts.OpenCLGenericAddressSpace ? LangAS::opencl_generic

                                              : LangAS::opencl_private;

  }

 

  void setcudaConfigureCallDecl(FunctionDecl *FD) {

    cudaConfigureCallDecl = FD;

  }

 

  FunctionDecl *getcudaConfigureCallDecl() {

    return cudaConfigureCallDecl;

  }

 

  /// Returns true iff we need copy/dispose helpers for the given type.

  bool BlockRequiresCopying(QualType Ty, const VarDecl *D);

 

  /// Returns true, if given type has a known lifetime. HasByrefExtendedLayout

  /// is set to false in this case. If HasByrefExtendedLayout returns true,

  /// byref variable has extended lifetime.

  bool getByrefLifetime(QualType Ty,

                        Qualifiers::ObjCLifetime &Lifetime,

                        bool &HasByrefExtendedLayout) const;

 

  /// Return the uniqued reference to the type for an lvalue reference

  /// to the specified type.

  QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true)

    const;

 

  /// Return the uniqued reference to the type for an rvalue reference

  /// to the specified type.

  QualType getRValueReferenceType(QualType T) const;

 

  /// Return the uniqued reference to the type for a member pointer to

  /// the specified type in the specified class.

  ///

  /// The class \p Cls is a \c Type because it could be a dependent name.

  QualType getMemberPointerType(QualType T, const Type *Cls) const;

 

  /// Return a non-unique reference to the type for a variable array of

  /// the specified element type.

  QualType getVariableArrayType(QualType EltTy, Expr *NumElts,

                                ArrayType::ArraySizeModifier ASM,

                                unsigned IndexTypeQuals,

                                SourceRange Brackets) const;

 

  /// Return a non-unique reference to the type for a dependently-sized

  /// array of the specified element type.

  ///

  /// FIXME: We will need these to be uniqued, or at least comparable, at some

  /// point.

  QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts,

                                      ArrayType::ArraySizeModifier ASM,

                                      unsigned IndexTypeQuals,

                                      SourceRange Brackets) const;

 

  /// Return a unique reference to the type for an incomplete array of

  /// the specified element type.

  QualType getIncompleteArrayType(QualType EltTy,

                                  ArrayType::ArraySizeModifier ASM,

                                  unsigned IndexTypeQuals) const;

 

  /// Return the unique reference to the type for a constant array of

  /// the specified element type.

  QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,

                                const Expr *SizeExpr,

                                ArrayType::ArraySizeModifier ASM,

                                unsigned IndexTypeQuals) const;

 

  /// Return a type for a constant array for a string literal of the

  /// specified element type and length.

  QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const;

 

  /// Returns a vla type where known sizes are replaced with [*].

  QualType getVariableArrayDecayedType(QualType Ty) const;

 

  // Convenience struct to return information about a builtin vector type.

  struct BuiltinVectorTypeInfo {

    QualType ElementType;

    llvm::ElementCount EC;

    unsigned NumVectors;

    BuiltinVectorTypeInfo(QualType ElementType, llvm::ElementCount EC,

                          unsigned NumVectors)

        : ElementType(ElementType), EC(EC), NumVectors(NumVectors) {}

  };

 

  /// Returns the element type, element count and number of vectors

  /// (in case of tuple) for a builtin vector type.

  BuiltinVectorTypeInfo

  getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const;

 

  /// Return the unique reference to a scalable vector type of the specified

  /// element type and scalable number of elements.

  ///

  /// \pre \p EltTy must be a built-in type.

  QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const;

 

  /// Return the unique reference to a vector type of the specified

  /// element type and size.

  ///

  /// \pre \p VectorType must be a built-in type.

  QualType getVectorType(QualType VectorType, unsigned NumElts,

                         VectorType::VectorKind VecKind) const;

  /// Return the unique reference to the type for a dependently sized vector of

  /// the specified element type.

  QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr,

                                  SourceLocation AttrLoc,

                                  VectorType::VectorKind VecKind) const;

 

  /// Return the unique reference to an extended vector type

  /// of the specified element type and size.

  ///

  /// \pre \p VectorType must be a built-in type.

  QualType getExtVectorType(QualType VectorType, unsigned NumElts) const;

 

  /// \pre Return a non-unique reference to the type for a dependently-sized

  /// vector of the specified element type.

  ///

  /// FIXME: We will need these to be uniqued, or at least comparable, at some

  /// point.

  QualType getDependentSizedExtVectorType(QualType VectorType,

                                          Expr *SizeExpr,

                                          SourceLocation AttrLoc) const;

 

  /// Return the unique reference to the matrix type of the specified element

  /// type and size

  ///

  /// \pre \p ElementType must be a valid matrix element type (see

  /// MatrixType::isValidElementType).

  QualType getConstantMatrixType(QualType ElementType, unsigned NumRows,

                                 unsigned NumColumns) const;

 

  /// Return the unique reference to the matrix type of the specified element

  /// type and size

  QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,

                                       Expr *ColumnExpr,

                                       SourceLocation AttrLoc) const;

 

  QualType getDependentAddressSpaceType(QualType PointeeType,

                                        Expr *AddrSpaceExpr,

                                        SourceLocation AttrLoc) const;

 

  /// Return a K&R style C function type like 'int()'.

  QualType getFunctionNoProtoType(QualType ResultTy,

                                  const FunctionType::ExtInfo &Info) const;

 

  QualType getFunctionNoProtoType(QualType ResultTy) const {

    return getFunctionNoProtoType(ResultTy, FunctionType::ExtInfo());

  }

 

  /// Return a normal function type with a typed argument list.

  QualType getFunctionType(QualType ResultTy, ArrayRef<QualType> Args,

                           const FunctionProtoType::ExtProtoInfo &EPI) const {

    return getFunctionTypeInternal(ResultTy, Args, EPI, false);

  }

 

  QualType adjustStringLiteralBaseType(QualType StrLTy) const;

 

  /// Return a normal function type with a typed argument list.

  QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,

                                   const FunctionProtoType::ExtProtoInfo &EPI,

                                   bool OnlyWantCanonical) const;

  QualType

  getAutoTypeInternal(QualType DeducedType, AutoTypeKeyword Keyword,

                      bool IsDependent, bool IsPack = false,

                      ConceptDecl *TypeConstraintConcept = nullptr,

                      ArrayRef<TemplateArgument> TypeConstraintArgs = {},

                      bool IsCanon = false) const;

 

  /// Return the unique reference to the type for the specified type

  /// declaration.

  QualType getTypeDeclType(const TypeDecl *Decl,

                           const TypeDecl *PrevDecl = nullptr) const {

    assert(Decl && "Passed null for Decl param");

    if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

 

    if (PrevDecl) {

      assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl");

      Decl->TypeForDecl = PrevDecl->TypeForDecl;

      return QualType(PrevDecl->TypeForDecl, 0);

    }

 

    return getTypeDeclTypeSlow(Decl);

  }

 

  QualType getUsingType(const UsingShadowDecl *Found,

                        QualType Underlying) const;

 

  /// Return the unique reference to the type for the specified

  /// typedef-name decl.

  QualType getTypedefType(const TypedefNameDecl *Decl,

                          QualType Underlying = QualType()) const;

 

  QualType getRecordType(const RecordDecl *Decl) const;

 

  QualType getEnumType(const EnumDecl *Decl) const;

 

  QualType

  getUnresolvedUsingType(const UnresolvedUsingTypenameDecl *Decl) const;

 

  QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const;

 

  QualType getAttributedType(attr::Kind attrKind, QualType modifiedType,

                             QualType equivalentType) const;

 

  QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr,

                                   QualType Wrapped);

 

  QualType

  getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,

                               unsigned Index,

                               std::optional<unsigned> PackIndex) const;

  QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,

                                            unsigned Index, bool Final,

                                            const TemplateArgument &ArgPack);

 

  QualType

  getTemplateTypeParmType(unsigned Depth, unsigned Index,

                          bool ParameterPack,

                          TemplateTypeParmDecl *ParmDecl = nullptr) const;

 

  QualType getTemplateSpecializationType(TemplateName T,

                                         ArrayRef<TemplateArgument> Args,

                                         QualType Canon = QualType()) const;

 

  QualType

  getCanonicalTemplateSpecializationType(TemplateName T,

                                         ArrayRef<TemplateArgument> Args) const;

 

  QualType getTemplateSpecializationType(TemplateName T,

                                         ArrayRef<TemplateArgumentLoc> Args,

                                         QualType Canon = QualType()) const;

 

  TypeSourceInfo *

  getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,

                                    const TemplateArgumentListInfo &Args,

                                    QualType Canon = QualType()) const;

 

  QualType getParenType(QualType NamedType) const;

 

  QualType getMacroQualifiedType(QualType UnderlyingTy,

                                 const IdentifierInfo *MacroII) const;

 

  QualType getElaboratedType(ElaboratedTypeKeyword Keyword,

                             NestedNameSpecifier *NNS, QualType NamedType,

                             TagDecl *OwnedTagDecl = nullptr) const;

  QualType getDependentNameType(ElaboratedTypeKeyword Keyword,

                                NestedNameSpecifier *NNS,

                                const IdentifierInfo *Name,

                                QualType Canon = QualType()) const;

 

  QualType getDependentTemplateSpecializationType(

      ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,

      const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const;

  QualType getDependentTemplateSpecializationType(

      ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,

      const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;

 

  TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);

 

  /// Get a template argument list with one argument per template parameter

  /// in a template parameter list, such as for the injected class name of

  /// a class template.

  void getInjectedTemplateArgs(const TemplateParameterList *Params,

                               SmallVectorImpl<TemplateArgument> &Args);

 

  /// Form a pack expansion type with the given pattern.

  /// \param NumExpansions The number of expansions for the pack, if known.

  /// \param ExpectPackInType If \c false, we should not expect \p Pattern to

  ///        contain an unexpanded pack. This only makes sense if the pack

  ///        expansion is used in a context where the arity is inferred from

  ///        elsewhere, such as if the pattern contains a placeholder type or

  ///        if this is the canonical type of another pack expansion type.

  QualType getPackExpansionType(QualType Pattern,

                                std::optional<unsigned> NumExpansions,

                                bool ExpectPackInType = true);

 

  QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl,

                                ObjCInterfaceDecl *PrevDecl = nullptr) const;

 

  /// Legacy interface: cannot provide type arguments or __kindof.

  QualType getObjCObjectType(QualType Base,

                             ObjCProtocolDecl * const *Protocols,

                             unsigned NumProtocols) const;

 

  QualType getObjCObjectType(QualType Base,

                             ArrayRef<QualType> typeArgs,

                             ArrayRef<ObjCProtocolDecl *> protocols,

                             bool isKindOf) const;

 

  QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl,

                                ArrayRef<ObjCProtocolDecl *> protocols) const;

  void adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig,

                                    ObjCTypeParamDecl *New) const;

 

  bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl);

 

  /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in

  /// QT's qualified-id protocol list adopt all protocols in IDecl's list

  /// of protocols.

  bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT,

                                            ObjCInterfaceDecl *IDecl);

 

  /// Return a ObjCObjectPointerType type for the given ObjCObjectType.

  QualType getObjCObjectPointerType(QualType OIT) const;

 

  /// C2x feature and GCC extension.

  QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const;

  QualType getTypeOfType(QualType QT, TypeOfKind Kind) const;

 

  QualType getReferenceQualifiedType(const Expr *e) const;

 

  /// C++11 decltype.

  QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;

 

  /// Unary type transforms

  QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,

                                 UnaryTransformType::UTTKind UKind) const;

 

  /// C++11 deduced auto type.

  QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,

                       bool IsDependent, bool IsPack = false,

                       ConceptDecl *TypeConstraintConcept = nullptr,

                       ArrayRef<TemplateArgument> TypeConstraintArgs ={}) const;

 

  /// C++11 deduction pattern for 'auto' type.

  QualType getAutoDeductType() const;

 

  /// C++11 deduction pattern for 'auto &&' type.

  QualType getAutoRRefDeductType() const;

 

  /// C++17 deduced class template specialization type.

  QualType getDeducedTemplateSpecializationType(TemplateName Template,

                                                QualType DeducedType,

                                                bool IsDependent) const;

 

  /// Return the unique reference to the type for the specified TagDecl

  /// (struct/union/class/enum) decl.

  QualType getTagDeclType(const TagDecl *Decl) const;

 

  /// Return the unique type for "size_t" (C99 7.17), defined in

  /// <stddef.h>.

  ///

  /// The sizeof operator requires this (C99 6.5.3.4p4).

  CanQualType getSizeType() const;

 

  /// Return the unique signed counterpart of

  /// the integer type corresponding to size_t.

  CanQualType getSignedSizeType() const;

 

  /// Return the unique type for "intmax_t" (C99 7.18.1.5), defined in

  /// <stdint.h>.

  CanQualType getIntMaxType() const;

 

  /// Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in

  /// <stdint.h>.

  CanQualType getUIntMaxType() const;

 

  /// Return the unique wchar_t type available in C++ (and available as

  /// __wchar_t as a Microsoft extension).

  QualType getWCharType() const { return WCharTy; }

 

  /// Return the type of wide characters. In C++, this returns the

  /// unique wchar_t type. In C99, this returns a type compatible with the type

  /// defined in <stddef.h> as defined by the target.

  QualType getWideCharType() const { return WideCharTy; }

 

  /// Return the type of "signed wchar_t".

  ///

  /// Used when in C++, as a GCC extension.

  QualType getSignedWCharType() const;

 

  /// Return the type of "unsigned wchar_t".

  ///

  /// Used when in C++, as a GCC extension.

  QualType getUnsignedWCharType() const;

 

  /// In C99, this returns a type compatible with the type

  /// defined in <stddef.h> as defined by the target.

  QualType getWIntType() const { return WIntTy; }

 

  /// Return a type compatible with "intptr_t" (C99 7.18.1.4),

  /// as defined by the target.

  QualType getIntPtrType() const;

 

  /// Return a type compatible with "uintptr_t" (C99 7.18.1.4),

  /// as defined by the target.

  QualType getUIntPtrType() const;

 

  /// Return the unique type for "ptrdiff_t" (C99 7.17) defined in

  /// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).

  QualType getPointerDiffType() const;

 

  /// Return the unique unsigned counterpart of "ptrdiff_t"

  /// integer type. The standard (C11 7.21.6.1p7) refers to this type

  /// in the definition of %tu format specifier.

  QualType getUnsignedPointerDiffType() const;

 

  /// Return the unique type for "pid_t" defined in

  /// <sys/types.h>. We need this to compute the correct type for vfork().

  QualType getProcessIDType() const;

 

  /// Return the C structure type used to represent constant CFStrings.

  QualType getCFConstantStringType() const;

 

  /// Returns the C struct type for objc_super

  QualType getObjCSuperType() const;

  void setObjCSuperType(QualType ST) { ObjCSuperType = ST; }

 

  /// Get the structure type used to representation CFStrings, or NULL

  /// if it hasn't yet been built.

  QualType getRawCFConstantStringType() const {

    if (CFConstantStringTypeDecl)

      return getTypedefType(CFConstantStringTypeDecl);

    return QualType();

  }

  void setCFConstantStringType(QualType T);

  TypedefDecl *getCFConstantStringDecl() const;

  RecordDecl *getCFConstantStringTagDecl() const;

 

  // This setter/getter represents the ObjC type for an NSConstantString.

  void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl);

  QualType getObjCConstantStringInterface() const {

    return ObjCConstantStringType;

  }

 

  QualType getObjCNSStringType() const {

    return ObjCNSStringType;

  }

 

  void setObjCNSStringType(QualType T) {

    ObjCNSStringType = T;

  }

 

  /// Retrieve the type that \c id has been defined to, which may be

  /// different from the built-in \c id if \c id has been typedef'd.

  QualType getObjCIdRedefinitionType() const {

    if (ObjCIdRedefinitionType.isNull())

      return getObjCIdType();

    return ObjCIdRedefinitionType;

  }

 

  /// Set the user-written type that redefines \c id.

  void setObjCIdRedefinitionType(QualType RedefType) {

    ObjCIdRedefinitionType = RedefType;

  }

 

  /// Retrieve the type that \c Class has been defined to, which may be

  /// different from the built-in \c Class if \c Class has been typedef'd.

  QualType getObjCClassRedefinitionType() const {

    if (ObjCClassRedefinitionType.isNull())

      return getObjCClassType();

    return ObjCClassRedefinitionType;

  }

 

  /// Set the user-written type that redefines 'SEL'.

  void setObjCClassRedefinitionType(QualType RedefType) {

    ObjCClassRedefinitionType = RedefType;

  }

 

  /// Retrieve the type that 'SEL' has been defined to, which may be

  /// different from the built-in 'SEL' if 'SEL' has been typedef'd.

  QualType getObjCSelRedefinitionType() const {

    if (ObjCSelRedefinitionType.isNull())

      return getObjCSelType();

    return ObjCSelRedefinitionType;

  }

 

  /// Set the user-written type that redefines 'SEL'.

  void setObjCSelRedefinitionType(QualType RedefType) {

    ObjCSelRedefinitionType = RedefType;

  }

 

  /// Retrieve the identifier 'NSObject'.

  IdentifierInfo *getNSObjectName() const {

    if (!NSObjectName) {

      NSObjectName = &Idents.get("NSObject");

    }

 

    return NSObjectName;

  }

 

  /// Retrieve the identifier 'NSCopying'.

  IdentifierInfo *getNSCopyingName() {

    if (!NSCopyingName) {

      NSCopyingName = &Idents.get("NSCopying");

    }

 

    return NSCopyingName;

  }

 

  CanQualType getNSUIntegerType() const;

 

  CanQualType getNSIntegerType() const;

 

  /// Retrieve the identifier 'bool'.

  IdentifierInfo *getBoolName() const {

    if (!BoolName)