Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

namespace clang {

 

class ASTContext;

class ClassTemplateDecl;

class ConstructorUsingShadowDecl;

class CXXBasePath;

class CXXBasePaths;

class CXXConstructorDecl;

class CXXDestructorDecl;

class CXXFinalOverriderMap;

class CXXIndirectPrimaryBaseSet;

class CXXMethodDecl;

class DecompositionDecl;

class FriendDecl;

class FunctionTemplateDecl;

class IdentifierInfo;

class MemberSpecializationInfo;

class BaseUsingDecl;

class TemplateDecl;

class TemplateParameterList;

class UsingDecl;

 

class AccessSpecDecl : public Decl {

  /// The location of the ':'.

  SourceLocation ColonLoc;

 

  AccessSpecDecl(AccessSpecifier AS, DeclContext *DC,

                 SourceLocation ASLoc, SourceLocation ColonLoc)

    : Decl(AccessSpec, DC, ASLoc), ColonLoc(ColonLoc) {

    setAccess(AS);

  }

 

  AccessSpecDecl(EmptyShell Empty) : Decl(AccessSpec, Empty) {}

 

  virtual void anchor();

 

  /// The location of the access specifier.

  SourceLocation getAccessSpecifierLoc() const { return getLocation(); }

 

  /// Sets the location of the access specifier.

  void setAccessSpecifierLoc(SourceLocation ASLoc) { setLocation(ASLoc); }

 

  /// The location of the colon following the access specifier.

  SourceLocation getColonLoc() const { return ColonLoc; }

 

  /// Sets the location of the colon.

  void setColonLoc(SourceLocation CLoc) { ColonLoc = CLoc; }

 

  SourceRange getSourceRange() const override LLVM_READONLY {

    return SourceRange(getAccessSpecifierLoc(), getColonLoc());

  }

 

  static AccessSpecDecl *Create(ASTContext &C, AccessSpecifier AS,

                                DeclContext *DC, SourceLocation ASLoc,

                                SourceLocation ColonLoc) {

    return new (C, DC) AccessSpecDecl(AS, DC, ASLoc, ColonLoc);

  }

 

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

 

  // Implement isa/cast/dyncast/etc.

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

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

 

class CXXBaseSpecifier {

  /// The source code range that covers the full base

  /// specifier, including the "virtual" (if present) and access

  /// specifier (if present).

  SourceRange Range;

 

  /// The source location of the ellipsis, if this is a pack

  /// expansion.

  SourceLocation EllipsisLoc;

 

  /// Whether this is a virtual base class or not.

  unsigned Virtual : 1;

 

  /// Whether this is the base of a class (true) or of a struct (false).

  ///

  /// This determines the mapping from the access specifier as written in the

  /// source code to the access specifier used for semantic analysis.

  unsigned BaseOfClass : 1;

 

  /// Access specifier as written in the source code (may be AS_none).

  ///

  /// The actual type of data stored here is an AccessSpecifier, but we use

  /// "unsigned" here to work around a VC++ bug.

  unsigned Access : 2;

 

  /// Whether the class contains a using declaration

  /// to inherit the named class's constructors.

  unsigned InheritConstructors : 1;

 

  /// The type of the base class.

  ///

  /// This will be a class or struct (or a typedef of such). The source code

  /// range does not include the \c virtual or the access specifier.

  TypeSourceInfo *BaseTypeInfo;

 

  CXXBaseSpecifier() = default;

  CXXBaseSpecifier(SourceRange R, bool V, bool BC, AccessSpecifier A,

                   TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)

    : Range(R), EllipsisLoc(EllipsisLoc), Virtual(V), BaseOfClass(BC),

      Access(A), InheritConstructors(false), BaseTypeInfo(TInfo) {}

 

  /// Retrieves the source range that contains the entire base specifier.

  SourceRange getSourceRange() const LLVM_READONLY { return Range; }

  SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }

  SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }

 

  /// Get the location at which the base class type was written.

  SourceLocation getBaseTypeLoc() const LLVM_READONLY {

    return BaseTypeInfo->getTypeLoc().getBeginLoc();

  }

 

  /// Determines whether the base class is a virtual base class (or not).

  bool isVirtual() const { return Virtual; }

 

  /// Determine whether this base class is a base of a class declared

  /// with the 'class' keyword (vs. one declared with the 'struct' keyword).

  bool isBaseOfClass() const { return BaseOfClass; }

 

  /// Determine whether this base specifier is a pack expansion.

  bool isPackExpansion() const { return EllipsisLoc.isValid(); }

 

  /// Determine whether this base class's constructors get inherited.

  bool getInheritConstructors() const { return InheritConstructors; }

 

  /// Set that this base class's constructors should be inherited.

  void setInheritConstructors(bool Inherit = true) {

    InheritConstructors = Inherit;

  }

 

  /// For a pack expansion, determine the location of the ellipsis.

  SourceLocation getEllipsisLoc() const {

    return EllipsisLoc;

  }

 

  /// Returns the access specifier for this base specifier.

  ///

  /// This is the actual base specifier as used for semantic analysis, so

  /// the result can never be AS_none. To retrieve the access specifier as

  /// written in the source code, use getAccessSpecifierAsWritten().

  AccessSpecifier getAccessSpecifier() const {

    if ((AccessSpecifier)Access == AS_none)

      return BaseOfClass? AS_private : AS_public;

    else

      return (AccessSpecifier)Access;

  }

 

  /// Retrieves the access specifier as written in the source code

  /// (which may mean that no access specifier was explicitly written).

  ///

  /// Use getAccessSpecifier() to retrieve the access specifier for use in

  /// semantic analysis.

  AccessSpecifier getAccessSpecifierAsWritten() const {

    return (AccessSpecifier)Access;

  }

 

  /// Retrieves the type of the base class.

  ///

  /// This type will always be an unqualified class type.

  QualType getType() const {

    return BaseTypeInfo->getType().getUnqualifiedType();

  }

 

  /// Retrieves the type and source location of the base class.

  TypeSourceInfo *getTypeSourceInfo() const { return BaseTypeInfo; }

 

class CXXRecordDecl : public RecordDecl {

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  friend class ASTNodeImporter;

  friend class ASTReader;

  friend class ASTRecordWriter;

  friend class ASTWriter;

  friend class DeclContext;

  friend class LambdaExpr;

  friend class ODRDiagsEmitter;

 

  friend void FunctionDecl::setPure(bool);

  friend void TagDecl::startDefinition();

 

  /// Values used in DefinitionData fields to represent special members.

  enum SpecialMemberFlags {

    SMF_DefaultConstructor = 0x1,

    SMF_CopyConstructor = 0x2,

    SMF_MoveConstructor = 0x4,

    SMF_CopyAssignment = 0x8,

    SMF_MoveAssignment = 0x10,

    SMF_Destructor = 0x20,

    SMF_All = 0x3f

  };

 

  enum LambdaDependencyKind {

    LDK_Unknown = 0,

    LDK_AlwaysDependent,

    LDK_NeverDependent,

  };

 

  struct DefinitionData {

    #define FIELD(Name, Width, Merge) \

    #include "CXXRecordDeclDefinitionBits.def"

 

    /// Whether this class describes a C++ lambda.

    unsigned IsLambda : 1;

 

    /// Whether we are currently parsing base specifiers.

    unsigned IsParsingBaseSpecifiers : 1;

 

    /// True when visible conversion functions are already computed

    /// and are available.

    unsigned ComputedVisibleConversions : 1;

 

    unsigned HasODRHash : 1;

 

    /// A hash of parts of the class to help in ODR checking.

    unsigned ODRHash = 0;

 

    /// The number of base class specifiers in Bases.

    unsigned NumBases = 0;

 

    /// The number of virtual base class specifiers in VBases.

    unsigned NumVBases = 0;

 

    /// Base classes of this class.

    ///

    /// FIXME: This is wasted space for a union.

    LazyCXXBaseSpecifiersPtr Bases;

 

    /// direct and indirect virtual base classes of this class.

    LazyCXXBaseSpecifiersPtr VBases;

 

    /// The conversion functions of this C++ class (but not its

    /// inherited conversion functions).

    ///

    /// Each of the entries in this overload set is a CXXConversionDecl.

    LazyASTUnresolvedSet Conversions;

 

    /// The conversion functions of this C++ class and all those

    /// inherited conversion functions that are visible in this class.

    ///

    /// Each of the entries in this overload set is a CXXConversionDecl or a

    /// FunctionTemplateDecl.

    LazyASTUnresolvedSet VisibleConversions;

 

    /// The declaration which defines this record.

    CXXRecordDecl *Definition;

 

    /// The first friend declaration in this class, or null if there

    /// aren't any.

    ///

    /// This is actually currently stored in reverse order.

    LazyDeclPtr FirstFriend;

 

    DefinitionData(CXXRecordDecl *D);

 

    /// Retrieve the set of direct base classes.

    CXXBaseSpecifier *getBases() const {

      if (!Bases.isOffset())

        return Bases.get(nullptr);

      return getBasesSlowCase();

    }

 

    /// Retrieve the set of virtual base classes.

    CXXBaseSpecifier *getVBases() const {

      if (!VBases.isOffset())

        return VBases.get(nullptr);

      return getVBasesSlowCase();

    }

 

    ArrayRef<CXXBaseSpecifier> bases() const {

      return llvm::ArrayRef(getBases(), NumBases);

    }

 

    ArrayRef<CXXBaseSpecifier> vbases() const {

      return llvm::ArrayRef(getVBases(), NumVBases);

    }

 

  private:

    CXXBaseSpecifier *getBasesSlowCase() const;

    CXXBaseSpecifier *getVBasesSlowCase() const;

  };

 

  struct DefinitionData *DefinitionData;

 

  /// Describes a C++ closure type (generated by a lambda expression).

  struct LambdaDefinitionData : public DefinitionData {

    using Capture = LambdaCapture;

 

    /// Whether this lambda is known to be dependent, even if its

    /// context isn't dependent.

    ///

    /// A lambda with a non-dependent context can be dependent if it occurs

    /// within the default argument of a function template, because the

    /// lambda will have been created with the enclosing context as its

    /// declaration context, rather than function. This is an unfortunate

    /// artifact of having to parse the default arguments before.

    unsigned DependencyKind : 2;

 

    /// Whether this lambda is a generic lambda.

    unsigned IsGenericLambda : 1;

 

    /// The Default Capture.

    unsigned CaptureDefault : 2;

 

    /// The number of captures in this lambda is limited 2^NumCaptures.

    unsigned NumCaptures : 15;

 

    /// The number of explicit captures in this lambda.

    unsigned NumExplicitCaptures : 13;

 

    /// Has known `internal` linkage.

    unsigned HasKnownInternalLinkage : 1;

 

    /// The number used to indicate this lambda expression for name

    /// mangling in the Itanium C++ ABI.

    unsigned ManglingNumber : 31;

 

    /// The declaration that provides context for this lambda, if the

    /// actual DeclContext does not suffice. This is used for lambdas that

    /// occur within default arguments of function parameters within the class

    /// or within a data member initializer.

    LazyDeclPtr ContextDecl;

 

    /// The lists of captures, both explicit and implicit, for this

    /// lambda. One list is provided for each merged copy of the lambda.

    /// The first list corresponds to the canonical definition.

    /// The destructor is registered by AddCaptureList when necessary.

    llvm::TinyPtrVector<Capture*> Captures;

 

    /// The type of the call method.

    TypeSourceInfo *MethodTyInfo;

 

    LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, unsigned DK,

                         bool IsGeneric, LambdaCaptureDefault CaptureDefault)

        : DefinitionData(D), DependencyKind(DK), IsGenericLambda(IsGeneric),

          CaptureDefault(CaptureDefault), NumCaptures(0),

          NumExplicitCaptures(0), HasKnownInternalLinkage(0), ManglingNumber(0),

          MethodTyInfo(Info) {

      IsLambda = true;

 

      // C++1z [expr.prim.lambda]p4:

      //   This class type is not an aggregate type.

      Aggregate = false;

      PlainOldData = false;

    }

 

    // Add a list of captures.

    void AddCaptureList(ASTContext &Ctx, Capture *CaptureList);

  };

 

  struct DefinitionData *dataPtr() const {

    // Complete the redecl chain (if necessary).

    getMostRecentDecl();

    return DefinitionData;

  }

 

  struct DefinitionData &data() const {

    auto *DD = dataPtr();

    assert(DD && "queried property of class with no definition");

    return *DD;

  }

 

  struct LambdaDefinitionData &getLambdaData() const {

    // No update required: a merged definition cannot change any lambda

    // properties.

    auto *DD = DefinitionData;

    assert(DD && DD->IsLambda && "queried lambda property of non-lambda class");

    return static_cast<LambdaDefinitionData&>(*DD);

  }

 

  /// The template or declaration that this declaration

  /// describes or was instantiated from, respectively.

  ///

  /// For non-templates, this value will be null. For record

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

  /// pointer to a ClassTemplateDecl. For member

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

  /// MemberSpecializationInfo referring to the member class that was

  /// instantiated or specialized.

  llvm::PointerUnion<ClassTemplateDecl *, MemberSpecializationInfo *>

      TemplateOrInstantiation;

 

  /// Called from setBases and addedMember to notify the class that a

  /// direct or virtual base class or a member of class type has been added.

  void addedClassSubobject(CXXRecordDecl *Base);

 

  /// Notify the class that member has been added.

  ///

  /// This routine helps maintain information about the class based on which

  /// members have been added. It will be invoked by DeclContext::addDecl()

  /// whenever a member is added to this record.

  void addedMember(Decl *D);

 

  void markedVirtualFunctionPure();

 

  /// Get the head of our list of friend declarations, possibly

  /// deserializing the friends from an external AST source.

  FriendDecl *getFirstFriend() const;

 

  /// Determine whether this class has an empty base class subobject of type X

  /// or of one of the types that might be at offset 0 within X (per the C++

  /// "standard layout" rules).

  bool hasSubobjectAtOffsetZeroOfEmptyBaseType(ASTContext &Ctx,

                                               const CXXRecordDecl *X);

 

  CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, DeclContext *DC,

                SourceLocation StartLoc, SourceLocation IdLoc,

                IdentifierInfo *Id, CXXRecordDecl *PrevDecl);

 

  /// Iterator that traverses the base classes of a class.

  using base_class_iterator = CXXBaseSpecifier *;

 

  /// Iterator that traverses the base classes of a class.

  using base_class_const_iterator = const CXXBaseSpecifier *;

 

  CXXRecordDecl *getCanonicalDecl() override {

    return cast<CXXRecordDecl>(RecordDecl::getCanonicalDecl());

  }

 

  const CXXRecordDecl *getCanonicalDecl() const {

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

  }

 

  CXXRecordDecl *getPreviousDecl() {

    return cast_or_null<CXXRecordDecl>(

            static_cast<RecordDecl *>(this)->getPreviousDecl());

  }

 

  const CXXRecordDecl *getPreviousDecl() const {

    return const_cast<CXXRecordDecl*>(this)->getPreviousDecl();

  }

 

  CXXRecordDecl *getMostRecentDecl() {

    return cast<CXXRecordDecl>(

            static_cast<RecordDecl *>(this)->getMostRecentDecl());

  }

 

  const CXXRecordDecl *getMostRecentDecl() const {

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

  }

 

  CXXRecordDecl *getMostRecentNonInjectedDecl() {

    CXXRecordDecl *Recent =

        static_cast<CXXRecordDecl *>(this)->getMostRecentDecl();

    while (Recent->isInjectedClassName()) {

      // FIXME: Does injected class name need to be in the redeclarations chain?

      assert(Recent->getPreviousDecl());

      Recent = Recent->getPreviousDecl();

    }

    return Recent;

  }

 

  const CXXRecordDecl *getMostRecentNonInjectedDecl() const {

    return const_cast<CXXRecordDecl*>(this)->getMostRecentNonInjectedDecl();

  }

 

  CXXRecordDecl *getDefinition() const {

    // We only need an update if we don't already know which

    // declaration is the definition.

    auto *DD = DefinitionData ? DefinitionData : dataPtr();

    return DD ? DD->Definition : nullptr;

  }

 

  bool hasDefinition() const { return DefinitionData || dataPtr(); }

 

  static CXXRecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,

                               SourceLocation StartLoc, SourceLocation IdLoc,

                               IdentifierInfo *Id,

                               CXXRecordDecl *PrevDecl = nullptr,

                               bool DelayTypeCreation = false);

  static CXXRecordDecl *CreateLambda(const ASTContext &C, DeclContext *DC,

                                     TypeSourceInfo *Info, SourceLocation Loc,

                                     unsigned DependencyKind, bool IsGeneric,

                                     LambdaCaptureDefault CaptureDefault);

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

 

  bool isDynamicClass() const {

    return data().Polymorphic || data().NumVBases != 0;

  }

 

  /// @returns true if class is dynamic or might be dynamic because the

  /// definition is incomplete of dependent.

  bool mayBeDynamicClass() const {

    return !hasDefinition() || isDynamicClass() || hasAnyDependentBases();

  }

 

  /// @returns true if class is non dynamic or might be non dynamic because the

  /// definition is incomplete of dependent.

  bool mayBeNonDynamicClass() const {

    return !hasDefinition() || !isDynamicClass() || hasAnyDependentBases();

  }

 

  void setIsParsingBaseSpecifiers() { data().IsParsingBaseSpecifiers = true; }

 

  bool isParsingBaseSpecifiers() const {

    return data().IsParsingBaseSpecifiers;

  }

 

  unsigned getODRHash() const;

 

  /// Sets the base classes of this struct or class.

  void setBases(CXXBaseSpecifier const * const *Bases, unsigned NumBases);

 

  /// Retrieves the number of base classes of this class.

  unsigned getNumBases() const { return data().NumBases; }

 

  using base_class_range = llvm::iterator_range<base_class_iterator>;

  using base_class_const_range =

      llvm::iterator_range<base_class_const_iterator>;

 

  base_class_range bases() {

    return base_class_range(bases_begin(), bases_end());

  }

  base_class_const_range bases() const {

    return base_class_const_range(bases_begin(), bases_end());

  }

 

  base_class_iterator bases_begin() { return data().getBases(); }

  base_class_const_iterator bases_begin() const { return data().getBases(); }

  base_class_iterator bases_end() { return bases_begin() + data().NumBases; }

  base_class_const_iterator bases_end() const {

    return bases_begin() + data().NumBases;

  }

 

  /// Retrieves the number of virtual base classes of this class.

  unsigned getNumVBases() const { return data().NumVBases; }

 

  base_class_range vbases() {

    return base_class_range(vbases_begin(), vbases_end());

  }

  base_class_const_range vbases() const {

    return base_class_const_range(vbases_begin(), vbases_end());

  }

 

  base_class_iterator vbases_begin() { return data().getVBases(); }

  base_class_const_iterator vbases_begin() const { return data().getVBases(); }

  base_class_iterator vbases_end() { return vbases_begin() + data().NumVBases; }

  base_class_const_iterator vbases_end() const {

    return vbases_begin() + data().NumVBases;

  }

 

  /// Determine whether this class has any dependent base classes which

  /// are not the current instantiation.

  bool hasAnyDependentBases() const;

 

  /// Iterator access to method members.  The method iterator visits

  /// all method members of the class, including non-instance methods,

  /// special methods, etc.

  using method_iterator = specific_decl_iterator<CXXMethodDecl>;

  using method_range =

      llvm::iterator_range<specific_decl_iterator<CXXMethodDecl>>;

 

  method_range methods() const {

    return method_range(method_begin(), method_end());

  }

 

  /// Method begin iterator.  Iterates in the order the methods

  /// were declared.

  method_iterator method_begin() const {

    return method_iterator(decls_begin());

  }

 

  /// Method past-the-end iterator.

  method_iterator method_end() const {

    return method_iterator(decls_end());

  }

 

  /// Iterator access to constructor members.

  using ctor_iterator = specific_decl_iterator<CXXConstructorDecl>;

  using ctor_range =

      llvm::iterator_range<specific_decl_iterator<CXXConstructorDecl>>;

 

  ctor_range ctors() const { return ctor_range(ctor_begin(), ctor_end()); }

 

  ctor_iterator ctor_begin() const {

    return ctor_iterator(decls_begin());

  }

 

  ctor_iterator ctor_end() const {

    return ctor_iterator(decls_end());

  }

 

  /// An iterator over friend declarations.  All of these are defined

  /// in DeclFriend.h.

  class friend_iterator;

  using friend_range = llvm::iterator_range<friend_iterator>;

 

  friend_range friends() const;

  friend_iterator friend_begin() const;

  friend_iterator friend_end() const;

  void pushFriendDecl(FriendDecl *FD);

 

  /// Determines whether this record has any friends.

  bool hasFriends() const {

    return data().FirstFriend.isValid();

  }

 

  /// \c true if a defaulted copy constructor for this class would be

  /// deleted.

  bool defaultedCopyConstructorIsDeleted() const {

    assert((!needsOverloadResolutionForCopyConstructor() ||

            (data().DeclaredSpecialMembers & SMF_CopyConstructor)) &&

           "this property has not yet been computed by Sema");

    return data().DefaultedCopyConstructorIsDeleted;

  }

 

  /// \c true if a defaulted move constructor for this class would be

  /// deleted.

  bool defaultedMoveConstructorIsDeleted() const {

    assert((!needsOverloadResolutionForMoveConstructor() ||

            (data().DeclaredSpecialMembers & SMF_MoveConstructor)) &&

           "this property has not yet been computed by Sema");

    return data().DefaultedMoveConstructorIsDeleted;

  }

 

  /// \c true if a defaulted destructor for this class would be deleted.

  bool defaultedDestructorIsDeleted() const {

    assert((!needsOverloadResolutionForDestructor() ||

            (data().DeclaredSpecialMembers & SMF_Destructor)) &&

           "this property has not yet been computed by Sema");

    return data().DefaultedDestructorIsDeleted;

  }

 

  /// \c true if we know for sure that this class has a single,

  /// accessible, unambiguous copy constructor that is not deleted.

  bool hasSimpleCopyConstructor() const {

    return !hasUserDeclaredCopyConstructor() &&

           !data().DefaultedCopyConstructorIsDeleted;

  }

 

  /// \c true if we know for sure that this class has a single,

  /// accessible, unambiguous move constructor that is not deleted.

  bool hasSimpleMoveConstructor() const {

    return !hasUserDeclaredMoveConstructor() && hasMoveConstructor() &&

           !data().DefaultedMoveConstructorIsDeleted;

  }

 

  /// \c true if we know for sure that this class has a single,

  /// accessible, unambiguous copy assignment operator that is not deleted.

  bool hasSimpleCopyAssignment() const {

    return !hasUserDeclaredCopyAssignment() &&

           !data().DefaultedCopyAssignmentIsDeleted;

  }

 

  /// \c true if we know for sure that this class has a single,

  /// accessible, unambiguous move assignment operator that is not deleted.

  bool hasSimpleMoveAssignment() const {

    return !hasUserDeclaredMoveAssignment() && hasMoveAssignment() &&

           !data().DefaultedMoveAssignmentIsDeleted;

  }

 

  /// \c true if we know for sure that this class has an accessible

  /// destructor that is not deleted.

  bool hasSimpleDestructor() const {

    return !hasUserDeclaredDestructor() &&

           !data().DefaultedDestructorIsDeleted;

  }

 

  /// Determine whether this class has any default constructors.

  bool hasDefaultConstructor() const {

    return (data().DeclaredSpecialMembers & SMF_DefaultConstructor) ||

           needsImplicitDefaultConstructor();

  }

 

  /// Determine if we need to declare a default constructor for

  /// this class.

  ///

  /// This value is used for lazy creation of default constructors.

  bool needsImplicitDefaultConstructor() const {

    return (!data().UserDeclaredConstructor &&

            !(data().DeclaredSpecialMembers & SMF_DefaultConstructor) &&

            (!isLambda() || lambdaIsDefaultConstructibleAndAssignable())) ||

           // FIXME: Proposed fix to core wording issue: if a class inherits

           // a default constructor and doesn't explicitly declare one, one

           // is declared implicitly.

           (data().HasInheritedDefaultConstructor &&

            !(data().DeclaredSpecialMembers & SMF_DefaultConstructor));

  }

 

  /// Determine whether this class has any user-declared constructors.

  ///

  /// When true, a default constructor will not be implicitly declared.

  bool hasUserDeclaredConstructor() const {

    return data().UserDeclaredConstructor;

  }

 

  /// Whether this class has a user-provided default constructor

  /// per C++11.

  bool hasUserProvidedDefaultConstructor() const {

    return data().UserProvidedDefaultConstructor;

  }

 

  /// Determine whether this class has a user-declared copy constructor.

  ///

  /// When false, a copy constructor will be implicitly declared.

  bool hasUserDeclaredCopyConstructor() const {

    return data().UserDeclaredSpecialMembers & SMF_CopyConstructor;

  }

 

  /// Determine whether this class needs an implicit copy

  /// constructor to be lazily declared.

  bool needsImplicitCopyConstructor() const {

    return !(data().DeclaredSpecialMembers & SMF_CopyConstructor);

  }

 

  /// Determine whether we need to eagerly declare a defaulted copy

  /// constructor for this class.

  bool needsOverloadResolutionForCopyConstructor() const {

    // C++17 [class.copy.ctor]p6:

    //   If the class definition declares a move constructor or move assignment

    //   operator, the implicitly declared copy constructor is defined as

    //   deleted.

    // In MSVC mode, sometimes a declared move assignment does not delete an

    // implicit copy constructor, so defer this choice to Sema.

    if (data().UserDeclaredSpecialMembers &

        (SMF_MoveConstructor | SMF_MoveAssignment))

      return true;

    return data().NeedOverloadResolutionForCopyConstructor;

  }

 

  /// Determine whether an implicit copy constructor for this type

  /// would have a parameter with a const-qualified reference type.

  bool implicitCopyConstructorHasConstParam() const {

    return data().ImplicitCopyConstructorCanHaveConstParamForNonVBase &&

           (isAbstract() ||

            data().ImplicitCopyConstructorCanHaveConstParamForVBase);

  }

 

  /// Determine whether this class has a copy constructor with

  /// a parameter type which is a reference to a const-qualified type.

  bool hasCopyConstructorWithConstParam() const {

    return data().HasDeclaredCopyConstructorWithConstParam ||

           (needsImplicitCopyConstructor() &&

            implicitCopyConstructorHasConstParam());

  }

 

  /// Whether this class has a user-declared move constructor or

  /// assignment operator.

  ///

  /// When false, a move constructor and assignment operator may be

  /// implicitly declared.

  bool hasUserDeclaredMoveOperation() const {

    return data().UserDeclaredSpecialMembers &

             (SMF_MoveConstructor | SMF_MoveAssignment);

  }

 

  /// Determine whether this class has had a move constructor

  /// declared by the user.

  bool hasUserDeclaredMoveConstructor() const {

    return data().UserDeclaredSpecialMembers & SMF_MoveConstructor;

  }

 

  /// Determine whether this class has a move constructor.

  bool hasMoveConstructor() const {

    return (data().DeclaredSpecialMembers & SMF_MoveConstructor) ||

           needsImplicitMoveConstructor();

  }

 

  /// Set that we attempted to declare an implicit copy

  /// constructor, but overload resolution failed so we deleted it.

  void setImplicitCopyConstructorIsDeleted() {

    assert((data().DefaultedCopyConstructorIsDeleted ||

            needsOverloadResolutionForCopyConstructor()) &&

           "Copy constructor should not be deleted");

    data().DefaultedCopyConstructorIsDeleted = true;

  }

 

  /// Set that we attempted to declare an implicit move

  /// constructor, but overload resolution failed so we deleted it.

  void setImplicitMoveConstructorIsDeleted() {

    assert((data().DefaultedMoveConstructorIsDeleted ||

            needsOverloadResolutionForMoveConstructor()) &&

           "move constructor should not be deleted");

    data().DefaultedMoveConstructorIsDeleted = true;

  }

 

  /// Set that we attempted to declare an implicit destructor,

  /// but overload resolution failed so we deleted it.

  void setImplicitDestructorIsDeleted() {

    assert((data().DefaultedDestructorIsDeleted ||

            needsOverloadResolutionForDestructor()) &&

           "destructor should not be deleted");

    data().DefaultedDestructorIsDeleted = true;

  }

 

  /// Determine whether this class should get an implicit move

  /// constructor or if any existing special member function inhibits this.

  bool needsImplicitMoveConstructor() const {

    return !(data().DeclaredSpecialMembers & SMF_MoveConstructor) &&

           !hasUserDeclaredCopyConstructor() &&

           !hasUserDeclaredCopyAssignment() &&

           !hasUserDeclaredMoveAssignment() &&

           !hasUserDeclaredDestructor();

  }

 

  /// Determine whether we need to eagerly declare a defaulted move

  /// constructor for this class.

  bool needsOverloadResolutionForMoveConstructor() const {

    return data().NeedOverloadResolutionForMoveConstructor;

  }

 

  /// Determine whether this class has a user-declared copy assignment

  /// operator.

  ///

  /// When false, a copy assignment operator will be implicitly declared.

  bool hasUserDeclaredCopyAssignment() const {

    return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;

  }

 

  /// Set that we attempted to declare an implicit copy assignment

  /// operator, but overload resolution failed so we deleted it.

  void setImplicitCopyAssignmentIsDeleted() {

    assert((data().DefaultedCopyAssignmentIsDeleted ||

            needsOverloadResolutionForCopyAssignment()) &&

           "copy assignment should not be deleted");

    data().DefaultedCopyAssignmentIsDeleted = true;

  }

 

  /// Determine whether this class needs an implicit copy

  /// assignment operator to be lazily declared.

  bool needsImplicitCopyAssignment() const {

    return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);

  }

 

  /// Determine whether we need to eagerly declare a defaulted copy

  /// assignment operator for this class.

  bool needsOverloadResolutionForCopyAssignment() const {

    // C++20 [class.copy.assign]p2:

    //   If the class definition declares a move constructor or move assignment

    //   operator, the implicitly declared copy assignment operator is defined

    //   as deleted.

    // In MSVC mode, sometimes a declared move constructor does not delete an

    // implicit copy assignment, so defer this choice to Sema.

    if (data().UserDeclaredSpecialMembers &

        (SMF_MoveConstructor | SMF_MoveAssignment))

      return true;

    return data().NeedOverloadResolutionForCopyAssignment;

  }

 

  /// Determine whether an implicit copy assignment operator for this

  /// type would have a parameter with a const-qualified reference type.

  bool implicitCopyAssignmentHasConstParam() const {

    return data().ImplicitCopyAssignmentHasConstParam;

  }

 

  /// Determine whether this class has a copy assignment operator with

  /// a parameter type which is a reference to a const-qualified type or is not

  /// a reference.

  bool hasCopyAssignmentWithConstParam() const {

    return data().HasDeclaredCopyAssignmentWithConstParam ||

           (needsImplicitCopyAssignment() &&

            implicitCopyAssignmentHasConstParam());

  }

 

  /// Determine whether this class has had a move assignment

  /// declared by the user.

  bool hasUserDeclaredMoveAssignment() const {

    return data().UserDeclaredSpecialMembers & SMF_MoveAssignment;

  }

 

  /// Determine whether this class has a move assignment operator.

  bool hasMoveAssignment() const {

    return (data().DeclaredSpecialMembers & SMF_MoveAssignment) ||

           needsImplicitMoveAssignment();

  }

 

  /// Set that we attempted to declare an implicit move assignment

  /// operator, but overload resolution failed so we deleted it.

  void setImplicitMoveAssignmentIsDeleted() {

    assert((data().DefaultedMoveAssignmentIsDeleted ||

            needsOverloadResolutionForMoveAssignment()) &&

           "move assignment should not be deleted");

    data().DefaultedMoveAssignmentIsDeleted = true;

  }

 

  /// Determine whether this class should get an implicit move

  /// assignment operator or if any existing special member function inhibits

  /// this.

  bool needsImplicitMoveAssignment() const {

    return !(data().DeclaredSpecialMembers & SMF_MoveAssignment) &&

           !hasUserDeclaredCopyConstructor() &&

           !hasUserDeclaredCopyAssignment() &&

           !hasUserDeclaredMoveConstructor() &&

           !hasUserDeclaredDestructor() &&

           (!isLambda() || lambdaIsDefaultConstructibleAndAssignable());

  }

 

  /// Determine whether we need to eagerly declare a move assignment

  /// operator for this class.

  bool needsOverloadResolutionForMoveAssignment() const {

    return data().NeedOverloadResolutionForMoveAssignment;

  }

 

  /// Determine whether this class has a user-declared destructor.

  ///

  /// When false, a destructor will be implicitly declared.

  bool hasUserDeclaredDestructor() const {

    return data().UserDeclaredSpecialMembers & SMF_Destructor;

  }

 

  /// Determine whether this class needs an implicit destructor to

  /// be lazily declared.

  bool needsImplicitDestructor() const {

    return !(data().DeclaredSpecialMembers & SMF_Destructor);

  }

 

  /// Determine whether we need to eagerly declare a destructor for this

  /// class.

  bool needsOverloadResolutionForDestructor() const {

    return data().NeedOverloadResolutionForDestructor;

  }

 

  /// Determine whether this class describes a lambda function object.

  bool isLambda() const {

    // An update record can't turn a non-lambda into a lambda.

    auto *DD = DefinitionData;

    return DD && DD->IsLambda;

  }

 

  /// Determine whether this class describes a generic

  /// lambda function object (i.e. function call operator is

  /// a template).

  bool isGenericLambda() const;

 

  /// Determine whether this lambda should have an implicit default constructor

  /// and copy and move assignment operators.

  bool lambdaIsDefaultConstructibleAndAssignable() const;

 

  /// Retrieve the lambda call operator of the closure type

  /// if this is a closure type.

  CXXMethodDecl *getLambdaCallOperator() const;

 

  /// Retrieve the dependent lambda call operator of the closure type

  /// if this is a templated closure type.

  FunctionTemplateDecl *getDependentLambdaCallOperator() const;

 

  /// Retrieve the lambda static invoker, the address of which

  /// is returned by the conversion operator, and the body of which

  /// is forwarded to the lambda call operator. The version that does not

  /// take a calling convention uses the 'default' calling convention for free

  /// functions if the Lambda's calling convention was not modified via

  /// attribute. Otherwise, it will return the calling convention specified for

  /// the lambda.

  CXXMethodDecl *getLambdaStaticInvoker() const;

  CXXMethodDecl *getLambdaStaticInvoker(CallingConv CC) const;

 

  /// Retrieve the generic lambda's template parameter list.

  /// Returns null if the class does not represent a lambda or a generic

  /// lambda.

  TemplateParameterList *getGenericLambdaTemplateParameterList() const;

 

  /// Retrieve the lambda template parameters that were specified explicitly.

  ArrayRef<NamedDecl *> getLambdaExplicitTemplateParameters() const;

 

  LambdaCaptureDefault getLambdaCaptureDefault() const {

    assert(isLambda());

    return static_cast<LambdaCaptureDefault>(getLambdaData().CaptureDefault);

  }

 

  /// Set the captures for this lambda closure type.

  void setCaptures(ASTContext &Context, ArrayRef<LambdaCapture> Captures);

 

  /// For a closure type, retrieve the mapping from captured

  /// variables and \c this to the non-static data members that store the

  /// values or references of the captures.

  ///

  /// \param Captures Will be populated with the mapping from captured

  /// variables to the corresponding fields.

  ///

  /// \param ThisCapture Will be set to the field declaration for the

  /// \c this capture.

  ///

  /// \note No entries will be added for init-captures, as they do not capture

  /// variables.

  ///

  /// \note If multiple versions of the lambda are merged together, they may

  /// have different variable declarations corresponding to the same capture.

  /// In that case, all of those variable declarations will be added to the

  /// Captures list, so it may have more than one variable listed per field.

  void

  getCaptureFields(llvm::DenseMap<const ValueDecl *, FieldDecl *> &Captures,

                   FieldDecl *&ThisCapture) const;

 

  using capture_const_iterator = const LambdaCapture *;

  using capture_const_range = llvm::iterator_range<capture_const_iterator>;

 

  capture_const_range captures() const {

    return capture_const_range(captures_begin(), captures_end());

  }

 

  capture_const_iterator captures_begin() const {

    if (!isLambda()) return nullptr;

    LambdaDefinitionData &LambdaData = getLambdaData();

    return LambdaData.Captures.empty() ? nullptr : LambdaData.Captures.front();

  }

 

  capture_const_iterator captures_end() const {

    return isLambda() ? captures_begin() + getLambdaData().NumCaptures

                      : nullptr;

  }

 

  unsigned capture_size() const { return getLambdaData().NumCaptures; }

 

  using conversion_iterator = UnresolvedSetIterator;

 

  conversion_iterator conversion_begin() const {

    return data().Conversions.get(getASTContext()).begin();

  }

 

  conversion_iterator conversion_end() const {

    return data().Conversions.get(getASTContext()).end();

  }

 

  /// Removes a conversion function from this class.  The conversion

  /// function must currently be a member of this class.  Furthermore,

  /// this class must currently be in the process of being defined.

  void removeConversion(const NamedDecl *Old);

 

  /// Get all conversion functions visible in current class,

  /// including conversion function templates.

  llvm::iterator_range<conversion_iterator>

  getVisibleConversionFunctions() const;

 

  /// Determine whether this class is an aggregate (C++ [dcl.init.aggr]),

  /// which is a class with no user-declared constructors, no private

  /// or protected non-static data members, no base classes, and no virtual

  /// functions (C++ [dcl.init.aggr]p1).

  bool isAggregate() const { return data().Aggregate; }

 

  /// Whether this class has any in-class initializers

  /// for non-static data members (including those in anonymous unions or

  /// structs).

  bool hasInClassInitializer() const { return data().HasInClassInitializer; }

 

  /// Whether this class or any of its subobjects has any members of

  /// reference type which would make value-initialization ill-formed.

  ///

  /// Per C++03 [dcl.init]p5:

  ///  - if T is a non-union class type without a user-declared constructor,

  ///    then every non-static data member and base-class component of T is

  ///    value-initialized [...] A program that calls for [...]

  ///    value-initialization of an entity of reference type is ill-formed.

  bool hasUninitializedReferenceMember() const {

    return !isUnion() && !hasUserDeclaredConstructor() &&

           data().HasUninitializedReferenceMember;

  }

 

  /// Whether this class is a POD-type (C++ [class]p4)

  ///

  /// For purposes of this function a class is POD if it is an aggregate

  /// that has no non-static non-POD data members, no reference data

  /// members, no user-defined copy assignment operator and no

  /// user-defined destructor.

  ///

  /// Note that this is the C++ TR1 definition of POD.

  bool isPOD() const { return data().PlainOldData; }

 

  /// True if this class is C-like, without C++-specific features, e.g.

  /// it contains only public fields, no bases, tag kind is not 'class', etc.

  bool isCLike() const;

 

  /// Determine whether this is an empty class in the sense of

  /// (C++11 [meta.unary.prop]).

  ///

  /// The CXXRecordDecl is a class type, but not a union type,

  /// with no non-static data members other than bit-fields of length 0,

  /// no virtual member functions, no virtual base classes,

  /// and no base class B for which is_empty<B>::value is false.

  ///

  /// \note This does NOT include a check for union-ness.

  bool isEmpty() const { return data().Empty; }

 

  void setInitMethod(bool Val) { data().HasInitMethod = Val; }

  bool hasInitMethod() const { return data().HasInitMethod; }

 

  bool hasPrivateFields() const {

    return data().HasPrivateFields;

  }

 

  bool hasProtectedFields() const {

    return data().HasProtectedFields;

  }

 

  /// Determine whether this class has direct non-static data members.

  bool hasDirectFields() const {

    auto &D = data();

    return D.HasPublicFields || D.HasProtectedFields || D.HasPrivateFields;

  }

 

  /// Whether this class is polymorphic (C++ [class.virtual]),

  /// which means that the class contains or inherits a virtual function.

  bool isPolymorphic() const { return data().Polymorphic; }

 

  /// Determine whether this class has a pure virtual function.

  ///

  /// The class is abstract per (C++ [class.abstract]p2) if it declares

  /// a pure virtual function or inherits a pure virtual function that is

  /// not overridden.

  bool isAbstract() const { return data().Abstract; }

 

  /// Determine whether this class is standard-layout per

  /// C++ [class]p7.

  bool isStandardLayout() const { return data().IsStandardLayout; }

 

  /// Determine whether this class was standard-layout per

  /// C++11 [class]p7, specifically using the C++11 rules without any DRs.

  bool isCXX11StandardLayout() const { return data().IsCXX11StandardLayout; }

 

  /// Determine whether this class, or any of its class subobjects,

  /// contains a mutable field.

  bool hasMutableFields() const { return data().HasMutableFields; }

 

  /// Determine whether this class has any variant members.

  bool hasVariantMembers() const { return data().HasVariantMembers; }

 

  /// Determine whether this class has a trivial default constructor

  /// (C++11 [class.ctor]p5).

  bool hasTrivialDefaultConstructor() const {

    return hasDefaultConstructor() &&

           (data().HasTrivialSpecialMembers & SMF_DefaultConstructor);

  }

 

  /// Determine whether this class has a non-trivial default constructor

  /// (C++11 [class.ctor]p5).

  bool hasNonTrivialDefaultConstructor() const {

    return (data().DeclaredNonTrivialSpecialMembers & SMF_DefaultConstructor) ||

           (needsImplicitDefaultConstructor() &&

            !(data().HasTrivialSpecialMembers & SMF_DefaultConstructor));

  }

 

  /// Determine whether this class has at least one constexpr constructor

  /// other than the copy or move constructors.

  bool hasConstexprNonCopyMoveConstructor() const {

    return data().HasConstexprNonCopyMoveConstructor ||

           (needsImplicitDefaultConstructor() &&

            defaultedDefaultConstructorIsConstexpr());

  }

 

  /// Determine whether a defaulted default constructor for this class

  /// would be constexpr.

  bool defaultedDefaultConstructorIsConstexpr() const {

    return data().DefaultedDefaultConstructorIsConstexpr &&

           (!isUnion() || hasInClassInitializer() || !hasVariantMembers() ||

            getLangOpts().CPlusPlus20);

  }

 

  /// Determine whether this class has a constexpr default constructor.

  bool hasConstexprDefaultConstructor() const {

    return data().HasConstexprDefaultConstructor ||

           (needsImplicitDefaultConstructor() &&

            defaultedDefaultConstructorIsConstexpr());

  }

 

  /// Determine whether this class has a trivial copy constructor

  /// (C++ [class.copy]p6, C++11 [class.copy]p12)

  bool hasTrivialCopyConstructor() const {

    return data().HasTrivialSpecialMembers & SMF_CopyConstructor;

  }

 

  bool hasTrivialCopyConstructorForCall() const {

    return data().HasTrivialSpecialMembersForCall & SMF_CopyConstructor;

  }

 

  /// Determine whether this class has a non-trivial copy constructor

  /// (C++ [class.copy]p6, C++11 [class.copy]p12)

  bool hasNonTrivialCopyConstructor() const {

    return data().DeclaredNonTrivialSpecialMembers & SMF_CopyConstructor ||

           !hasTrivialCopyConstructor();

  }

 

  bool hasNonTrivialCopyConstructorForCall() const {

    return (data().DeclaredNonTrivialSpecialMembersForCall &

            SMF_CopyConstructor) ||

           !hasTrivialCopyConstructorForCall();

  }

 

  /// Determine whether this class has a trivial move constructor

  /// (C++11 [class.copy]p12)

  bool hasTrivialMoveConstructor() const {

    return hasMoveConstructor() &&

           (data().HasTrivialSpecialMembers & SMF_MoveConstructor);

  }

 

  bool hasTrivialMoveConstructorForCall() const {

    return hasMoveConstructor() &&

           (data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor);

  }

 

  /// Determine whether this class has a non-trivial move constructor

  /// (C++11 [class.copy]p12)

  bool hasNonTrivialMoveConstructor() const {

    return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveConstructor) ||

           (needsImplicitMoveConstructor() &&

            !(data().HasTrivialSpecialMembers & SMF_MoveConstructor));

  }

 

  bool hasNonTrivialMoveConstructorForCall() const {

    return (data().DeclaredNonTrivialSpecialMembersForCall &

            SMF_MoveConstructor) ||

           (needsImplicitMoveConstructor() &&

            !(data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor));

  }

 

  /// Determine whether this class has a trivial copy assignment operator

  /// (C++ [class.copy]p11, C++11 [class.copy]p25)

  bool hasTrivialCopyAssignment() const {

    return data().HasTrivialSpecialMembers & SMF_CopyAssignment;

  }

 

  /// Determine whether this class has a non-trivial copy assignment

  /// operator (C++ [class.copy]p11, C++11 [class.copy]p25)

  bool hasNonTrivialCopyAssignment() const {

    return data().DeclaredNonTrivialSpecialMembers & SMF_CopyAssignment ||

           !hasTrivialCopyAssignment();

  }

 

  /// Determine whether this class has a trivial move assignment operator

  /// (C++11 [class.copy]p25)

  bool hasTrivialMoveAssignment() const {

    return hasMoveAssignment() &&

           (data().HasTrivialSpecialMembers & SMF_MoveAssignment);

  }

 

  /// Determine whether this class has a non-trivial move assignment

  /// operator (C++11 [class.copy]p25)

  bool hasNonTrivialMoveAssignment() const {

    return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveAssignment) ||

           (needsImplicitMoveAssignment() &&

            !(data().HasTrivialSpecialMembers & SMF_MoveAssignment));

  }

 

  /// Determine whether a defaulted default constructor for this class

  /// would be constexpr.

  bool defaultedDestructorIsConstexpr() const {

    return data().DefaultedDestructorIsConstexpr &&

           getLangOpts().CPlusPlus20;

  }

 

  /// Determine whether this class has a constexpr destructor.

  bool hasConstexprDestructor() const;

 

  /// Determine whether this class has a trivial destructor

  /// (C++ [class.dtor]p3)

  bool hasTrivialDestructor() const {

    return data().HasTrivialSpecialMembers & SMF_Destructor;

  }

 

  bool hasTrivialDestructorForCall() const {

    return data().HasTrivialSpecialMembersForCall & SMF_Destructor;

  }

 

  /// Determine whether this class has a non-trivial destructor

  /// (C++ [class.dtor]p3)

  bool hasNonTrivialDestructor() const {

    return !(data().HasTrivialSpecialMembers & SMF_Destructor);

  }

 

  bool hasNonTrivialDestructorForCall() const {

    return !(data().HasTrivialSpecialMembersForCall & SMF_Destructor);

  }

 

  void setHasTrivialSpecialMemberForCall() {

    data().HasTrivialSpecialMembersForCall =

        (SMF_CopyConstructor | SMF_MoveConstructor | SMF_Destructor);

  }

 

  /// Determine whether declaring a const variable with this type is ok

  /// per core issue 253.

  bool allowConstDefaultInit() const {

    return !data().HasUninitializedFields ||

           !(data().HasDefaultedDefaultConstructor ||

             needsImplicitDefaultConstructor());

  }

 

  /// Determine whether this class has a destructor which has no

  /// semantic effect.

  ///

  /// Any such destructor will be trivial, public, defaulted and not deleted,

  /// and will call only irrelevant destructors.

  bool hasIrrelevantDestructor() const {

    return data().HasIrrelevantDestructor;

  }

 

  /// Determine whether this class has a non-literal or/ volatile type

  /// non-static data member or base class.

  bool hasNonLiteralTypeFieldsOrBases() const {

    return data().HasNonLiteralTypeFieldsOrBases;

  }

 

  /// Determine whether this class has a using-declaration that names

  /// a user-declared base class constructor.

  bool hasInheritedConstructor() const {

    return data().HasInheritedConstructor;

  }

 

  /// Determine whether this class has a using-declaration that names

  /// a base class assignment operator.

  bool hasInheritedAssignment() const {

    return data().HasInheritedAssignment;

  }

 

  /// Determine whether this class is considered trivially copyable per

  /// (C++11 [class]p6).

  bool isTriviallyCopyable() const;

 

  /// Determine whether this class is considered trivial.

  ///

  /// C++11 [class]p6:

  ///    "A trivial class is a class that has a trivial default constructor and

  ///    is trivially copyable."

  bool isTrivial() const {

    return isTriviallyCopyable() && hasTrivialDefaultConstructor();

  }

 

  /// Determine whether this class is a literal type.

  ///

  /// C++11 [basic.types]p10:

  ///   A class type that has all the following properties:

  ///     - it has a trivial destructor

  ///     - every constructor call and full-expression in the

  ///       brace-or-equal-intializers for non-static data members (if any) is

  ///       a constant expression.

  ///     - it is an aggregate type or has at least one constexpr constructor

  ///       or constructor template that is not a copy or move constructor, and

  ///     - all of its non-static data members and base classes are of literal

  ///       types

  ///

  /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by

  /// treating types with trivial default constructors as literal types.

  ///

  /// Only in C++17 and beyond, are lambdas literal types.

  bool isLiteral() const {

    const LangOptions &LangOpts = getLangOpts();

    return (LangOpts.CPlusPlus20 ? hasConstexprDestructor()

                                          : hasTrivialDestructor()) &&

           (!isLambda() || LangOpts.CPlusPlus17) &&

           !hasNonLiteralTypeFieldsOrBases() &&

           (isAggregate() || isLambda() ||

            hasConstexprNonCopyMoveConstructor() ||

            hasTrivialDefaultConstructor());

  }

 

  /// Determine whether this is a structural type.

  bool isStructural() const {

    return isLiteral() && data().StructuralIfLiteral;

  }

 

  /// Notify the class that this destructor is now selected.

  ///

  /// Important properties of the class depend on destructor properties. Since

  /// C++20, it is possible to have multiple destructor declarations in a class

  /// out of which one will be selected at the end.

  /// This is called separately from addedMember because it has to be deferred

  /// to the completion of the class.

  void addedSelectedDestructor(CXXDestructorDecl *DD);

 

  /// Notify the class that an eligible SMF has been added.

  /// This updates triviality and destructor based properties of the class accordingly.

  void addedEligibleSpecialMemberFunction(const CXXMethodDecl *MD, unsigned SMKind);

 

  /// If this record is an instantiation of a member class,

  /// retrieves the member class from which it was instantiated.

  ///

  /// This routine will return non-null for (non-templated) member

  /// classes of class templates. For example, given:

  ///

  /// \code

  /// template<typename T>

  /// struct X {

  ///   struct A { };

  /// };

  /// \endcode

  ///

  /// The declaration for X<int>::A is a (non-templated) CXXRecordDecl

  /// whose parent is the class template specialization X<int>. For

  /// this declaration, getInstantiatedFromMemberClass() will return

  /// the CXXRecordDecl X<T>::A. When a complete definition of

  /// X<int>::A is required, it will be instantiated from the

  /// declaration returned by getInstantiatedFromMemberClass().

  CXXRecordDecl *getInstantiatedFromMemberClass() const;

 

  /// If this class is an instantiation of a member class of a

  /// class template specialization, retrieves the member specialization

  /// information.

  MemberSpecializationInfo *getMemberSpecializationInfo() const;

 

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

  /// member class \p RD.

  void setInstantiationOfMemberClass(CXXRecordDecl *RD,

                                     TemplateSpecializationKind TSK);

 

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

  /// class declaration.

  ///

  /// Every class template is represented as a ClassTemplateDecl and a

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

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

  /// actual description of the template's

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

  /// CXXRecordDecl that from a ClassTemplateDecl, while

  /// getDescribedClassTemplate() retrieves the ClassTemplateDecl from

  /// a CXXRecordDecl.

  ClassTemplateDecl *getDescribedClassTemplate() const;

 

  void setDescribedClassTemplate(ClassTemplateDecl *Template);

 

  /// Determine whether this particular class is a specialization or

  /// instantiation of a class template or member class of a class template,

  /// and how it was instantiated or specialized.

  TemplateSpecializationKind getTemplateSpecializationKind() const;

 

  /// Set the kind of specialization or template instantiation this is.

  void setTemplateSpecializationKind(TemplateSpecializationKind TSK);

 

  /// Retrieve the record declaration from which this record could be

  /// instantiated. Returns null if this class is not a template instantiation.

  const CXXRecordDecl *getTemplateInstantiationPattern() const;

 

  CXXRecordDecl *getTemplateInstantiationPattern() {

    return const_cast<CXXRecordDecl *>(const_cast<const CXXRecordDecl *>(this)

                                           ->getTemplateInstantiationPattern());

  }

 

  /// Returns the destructor decl for this class.

  CXXDestructorDecl *getDestructor() const;

 

  /// Returns true if the class destructor, or any implicitly invoked

  /// destructors are marked noreturn.

  bool isAnyDestructorNoReturn() const { return data().IsAnyDestructorNoReturn; }

 

  /// If the class is a local class [class.local], returns

  /// the enclosing function declaration.

  const FunctionDecl *isLocalClass() const {

    if (const auto *RD = dyn_cast<CXXRecordDecl>(getDeclContext()))

      return RD->isLocalClass();

 

    return dyn_cast<FunctionDecl>(getDeclContext());

  }

 

  FunctionDecl *isLocalClass() {

    return const_cast<FunctionDecl*>(

        const_cast<const CXXRecordDecl*>(this)->isLocalClass());

  }

 

  /// Determine whether this dependent class is a current instantiation,

  /// when viewed from within the given context.

  bool isCurrentInstantiation(const DeclContext *CurContext) const;

 

  /// Determine whether this class is derived from the class \p Base.

  ///

  /// This routine only determines whether this class is derived from \p Base,

  /// but does not account for factors that may make a Derived -> Base class

  /// ill-formed, such as private/protected inheritance or multiple, ambiguous

  /// base class subobjects.

  ///

  /// \param Base the base class we are searching for.

  ///

  /// \returns true if this class is derived from Base, false otherwise.

  bool isDerivedFrom(const CXXRecordDecl *Base) const;

 

  /// Determine whether this class is derived from the type \p Base.

  ///

  /// This routine only determines whether this class is derived from \p Base,

  /// but does not account for factors that may make a Derived -> Base class

  /// ill-formed, such as private/protected inheritance or multiple, ambiguous

  /// base class subobjects.

  ///

  /// \param Base the base class we are searching for.

  ///

  /// \param Paths will contain the paths taken from the current class to the

  /// given \p Base class.

  ///

  /// \returns true if this class is derived from \p Base, false otherwise.

  ///

  /// \todo add a separate parameter to configure IsDerivedFrom, rather than

  /// tangling input and output in \p Paths

  bool isDerivedFrom(const CXXRecordDecl *Base, CXXBasePaths &Paths) const;

 

  /// Determine whether this class is virtually derived from

  /// the class \p Base.

  ///

  /// This routine only determines whether this class is virtually

  /// derived from \p Base, but does not account for factors that may

  /// make a Derived -> Base class ill-formed, such as

  /// private/protected inheritance or multiple, ambiguous base class

  /// subobjects.

  ///

  /// \param Base the base class we are searching for.

  ///

  /// \returns true if this class is virtually derived from Base,

  /// false otherwise.

  bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const;

 

  /// Determine whether this class is provably not derived from

  /// the type \p Base.

  bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const;

 

  /// Function type used by forallBases() as a callback.

  ///

  /// \param BaseDefinition the definition of the base class

  ///

  /// \returns true if this base matched the search criteria

  using ForallBasesCallback =

      llvm::function_ref<bool(const CXXRecordDecl *BaseDefinition)>;

 

  /// Determines if the given callback holds for all the direct

  /// or indirect base classes of this type.

  ///

  /// The class itself does not count as a base class.  This routine

  /// returns false if the class has non-computable base classes.

  ///

  /// \param BaseMatches Callback invoked for each (direct or indirect) base

  /// class of this type until a call returns false.

  bool forallBases(ForallBasesCallback BaseMatches) const;

 

  /// Function type used by lookupInBases() to determine whether a

  /// specific base class subobject matches the lookup criteria.

  ///

  /// \param Specifier the base-class specifier that describes the inheritance

  /// from the base class we are trying to match.

  ///

  /// \param Path the current path, from the most-derived class down to the

  /// base named by the \p Specifier.

  ///

  /// \returns true if this base matched the search criteria, false otherwise.

  using BaseMatchesCallback =

      llvm::function_ref<bool(const CXXBaseSpecifier *Specifier,

                              CXXBasePath &Path)>;

 

  /// Look for entities within the base classes of this C++ class,

  /// transitively searching all base class subobjects.

  ///

  /// This routine uses the callback function \p BaseMatches to find base

  /// classes meeting some search criteria, walking all base class subobjects

  /// and populating the given \p Paths structure with the paths through the

  /// inheritance hierarchy that resulted in a match. On a successful search,

  /// the \p Paths structure can be queried to retrieve the matching paths and

  /// to determine if there were any ambiguities.

  ///

  /// \param BaseMatches callback function used to determine whether a given

  /// base matches the user-defined search criteria.

  ///

  /// \param Paths used to record the paths from this class to its base class

  /// subobjects that match the search criteria.

  ///

  /// \param LookupInDependent can be set to true to extend the search to

  /// dependent base classes.

  ///

  /// \returns true if there exists any path from this class to a base class

  /// subobject that matches the search criteria.

  bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths,

                     bool LookupInDependent = false) const;

 

  /// Base-class lookup callback that determines whether the given

  /// base class specifier refers to a specific class declaration.

  ///

  /// This callback can be used with \c lookupInBases() to determine whether

  /// a given derived class has is a base class subobject of a particular type.

  /// The base record pointer should refer to the canonical CXXRecordDecl of the

  /// base class that we are searching for.

  static bool FindBaseClass(const CXXBaseSpecifier *Specifier,

                            CXXBasePath &Path, const CXXRecordDecl *BaseRecord);

 

  /// Base-class lookup callback that determines whether the

  /// given base class specifier refers to a specific class

  /// declaration and describes virtual derivation.

  ///

  /// This callback can be used with \c lookupInBases() to determine

  /// whether a given derived class has is a virtual base class

  /// subobject of a particular type.  The base record pointer should

  /// refer to the canonical CXXRecordDecl of the base class that we

  /// are searching for.

  static bool FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,

                                   CXXBasePath &Path,

                                   const CXXRecordDecl *BaseRecord);

 

  /// Retrieve the final overriders for each virtual member

  /// function in the class hierarchy where this class is the

  /// most-derived class in the class hierarchy.

  void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const;

 

  /// Get the indirect primary bases for this class.

  void getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const;

 

  /// Determine whether this class has a member with the given name, possibly

  /// in a non-dependent base class.

  ///

  /// No check for ambiguity is performed, so this should never be used when

  /// implementing language semantics, but it may be appropriate for warnings,

  /// static analysis, or similar.

  bool hasMemberName(DeclarationName N) const;

 

  /// Performs an imprecise lookup of a dependent name in this class.

  ///

  /// This function does not follow strict semantic rules and should be used

  /// only when lookup rules can be relaxed, e.g. indexing.

  std::vector<const NamedDecl *>

  lookupDependentName(DeclarationName Name,

                      llvm::function_ref<bool(const NamedDecl *ND)> Filter);

 

  /// Renders and displays an inheritance diagram

  /// for this C++ class and all of its base classes (transitively) using

  /// GraphViz.

  void viewInheritance(ASTContext& Context) const;

 

  /// Calculates the access of a decl that is reached

  /// along a path.

  static AccessSpecifier MergeAccess(AccessSpecifier PathAccess,

                                     AccessSpecifier DeclAccess) {

    assert(DeclAccess != AS_none);

    if (DeclAccess == AS_private) return AS_none;

    return (PathAccess > DeclAccess ? PathAccess : DeclAccess);

  }

 

  /// Indicates that the declaration of a defaulted or deleted special

  /// member function is now complete.

  void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD);

 

  void setTrivialForCallFlags(CXXMethodDecl *MD);

 

  /// Indicates that the definition of this class is now complete.

  void completeDefinition() override;

 

  /// Indicates that the definition of this class is now complete,

  /// and provides a final overrider map to help determine

  ///

  /// \param FinalOverriders The final overrider map for this class, which can

  /// be provided as an optimization for abstract-class checking. If NULL,

  /// final overriders will be computed if they are needed to complete the

  /// definition.

  void completeDefinition(CXXFinalOverriderMap *FinalOverriders);

 

  /// Determine whether this class may end up being abstract, even though

  /// it is not yet known to be abstract.

  ///

  /// \returns true if this class is not known to be abstract but has any

  /// base classes that are abstract. In this case, \c completeDefinition()

  /// will need to compute final overriders to determine whether the class is

  /// actually abstract.

  bool mayBeAbstract() const;

 

  /// Determine whether it's impossible for a class to be derived from this

  /// class. This is best-effort, and may conservatively return false.

  bool isEffectivelyFinal() const;

 

  /// If this is the closure type of a lambda expression, retrieve the

  /// number to be used for name mangling in the Itanium C++ ABI.

  ///

  /// Zero indicates that this closure type has internal linkage, so the

  /// mangling number does not matter, while a non-zero value indicates which

  /// lambda expression this is in this particular context.

  unsigned getLambdaManglingNumber() const {

    assert(isLambda() && "Not a lambda closure type!");

    return getLambdaData().ManglingNumber;

  }

 

  /// The lambda is known to has internal linkage no matter whether it has name

  /// mangling number.

  bool hasKnownLambdaInternalLinkage() const {

    assert(isLambda() && "Not a lambda closure type!");

    return getLambdaData().HasKnownInternalLinkage;

  }

 

  /// Retrieve the declaration that provides additional context for a

  /// lambda, when the normal declaration context is not specific enough.

  ///

  /// Certain contexts (default arguments of in-class function parameters and

  /// the initializers of data members) have separate name mangling rules for

  /// lambdas within the Itanium C++ ABI. For these cases, this routine provides

  /// the declaration in which the lambda occurs, e.g., the function parameter

  /// or the non-static data member. Otherwise, it returns NULL to imply that

  /// the declaration context suffices.

  Decl *getLambdaContextDecl() const;

 

  /// Set the mangling number and context declaration for a lambda

  /// class.

  void setLambdaMangling(unsigned ManglingNumber, Decl *ContextDecl,

                         bool HasKnownInternalLinkage = false) {

    assert(isLambda() && "Not a lambda closure type!");

    getLambdaData().ManglingNumber = ManglingNumber;

    getLambdaData().ContextDecl = ContextDecl;

    getLambdaData().HasKnownInternalLinkage = HasKnownInternalLinkage;

  }

 

  /// Set the device side mangling number.

  void setDeviceLambdaManglingNumber(unsigned Num) const;

 

  /// Retrieve the device side mangling number.

  unsigned getDeviceLambdaManglingNumber() const;

 

  /// Returns the inheritance model used for this record.

  MSInheritanceModel getMSInheritanceModel() const;

 

  /// Calculate what the inheritance model would be for this class.

  MSInheritanceModel calculateInheritanceModel() const;