Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

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

//

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

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

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

//

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

//

/// \file

/// Defines the C++ Decl subclasses, other than those for templates

/// (found in DeclTemplate.h) and friends (in DeclFriend.h).

//

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

#ifndef LLVM_CLANG_AST_DECLCXX_H

#define LLVM_CLANG_AST_DECLCXX_H

#include "clang/AST/ASTUnresolvedSet.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/LambdaCapture.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/Redeclarable.h"

#include "clang/AST/Stmt.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeLoc.h"

#include "clang/AST/UnresolvedSet.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/Lambda.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/TinyPtrVector.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/PointerLikeTypeTraits.h"

#include "llvm/Support/TrailingObjects.h"

#include <cassert>

#include <cstddef>

#include <iterator>

#include <memory>

#include <vector>

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;

/// Represents an access specifier followed by colon ':'.

///

/// An objects of this class represents sugar for the syntactic occurrence

/// of an access specifier followed by a colon in the list of member

/// specifiers of a C++ class definition.

///

/// Note that they do not represent other uses of access specifiers,

/// such as those occurring in a list of base specifiers.

/// Also note that this class has nothing to do with so-called

/// "access declarations" (C++98 11.3 [class.access.dcl]).

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

public:

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

};

/// Represents a base class of a C++ class.

///

/// Each CXXBaseSpecifier represents a single, direct base class (or

/// struct) of a C++ class (or struct). It specifies the type of that

/// base class, whether it is a virtual or non-virtual base, and what

/// level of access (public, protected, private) is used for the

/// derivation. For example:

///

/// \code

///   class A { };

///   class B { };

///   class C : public virtual A, protected B { };

/// \endcode

///

/// In this code, C will have two CXXBaseSpecifiers, one for "public

/// virtual A" and the other for "protected B".

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;

public:

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

};

/// Represents a C++ struct/union/class.

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

  };

public:

  enum LambdaDependencyKind {

    LDK_Unknown = 0,

    LDK_AlwaysDependent,

    LDK_NeverDependent,

  };

private:

  struct DefinitionData {

    #define FIELD(Name, Width, Merge) \

    unsigned Name : Width;

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

protected:

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

                SourceLocation StartLoc, SourceLocation IdLoc,

                IdentifierInfo *Id, CXXRecordDecl *PrevDecl);

public:

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