//===- DeclCXX.cpp - C++ Declaration AST Node Implementation --------------===//

//

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

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

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

//

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

//

// This file implements the C++ related Decl classes.

//

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

#include "clang/AST/DeclCXX.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/ASTMutationListener.h"

#include "clang/AST/ASTUnresolvedSet.h"

#include "clang/AST/Attr.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/LambdaCapture.h"

#include "clang/AST/NestedNameSpecifier.h"

#include "clang/AST/ODRHash.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeLoc.h"

#include "clang/AST/UnresolvedSet.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/None.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>

#include <cassert>

#include <cstddef>

#include <cstdint>

using namespace clang;

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

// Decl Allocation/Deallocation Method Implementations

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

void AccessSpecDecl::anchor() {}

AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {

  return new (C, ID) AccessSpecDecl(EmptyShell());

}

void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const {

  ExternalASTSource *Source = C.getExternalSource();

  assert(Impl.Decls.isLazy() && "getFromExternalSource for non-lazy set");

  assert(Source && "getFromExternalSource with no external source");

  for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); 
++I279
)

    I.setDecl(cast<NamedDecl>(Source->GetExternalDecl(

        reinterpret_cast<uintptr_t>(I.getDecl()) >> 2)));

  Impl.Decls.setLazy(false);

}

CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)

    : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),

      Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),

      Abstract(false), IsStandardLayout(true), IsCXX11StandardLayout(true),

      HasBasesWithFields(false), HasBasesWithNonStaticDataMembers(false),

      HasPrivateFields(false), HasProtectedFields(false),

      HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),

      HasOnlyCMembers(true), HasInClassInitializer(false),

      HasUninitializedReferenceMember(false), HasUninitializedFields(false),

      HasInheritedConstructor(false), HasInheritedAssignment(false),

      NeedOverloadResolutionForCopyConstructor(false),

      NeedOverloadResolutionForMoveConstructor(false),

      NeedOverloadResolutionForMoveAssignment(false),

      NeedOverloadResolutionForDestructor(false),

      DefaultedCopyConstructorIsDeleted(false),

      DefaultedMoveConstructorIsDeleted(false),

      DefaultedMoveAssignmentIsDeleted(false),

      DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All),

      HasTrivialSpecialMembersForCall(SMF_All),

      DeclaredNonTrivialSpecialMembers(0),

      DeclaredNonTrivialSpecialMembersForCall(0), HasIrrelevantDestructor(true),

      HasConstexprNonCopyMoveConstructor(false),

      HasDefaultedDefaultConstructor(false),

      DefaultedDefaultConstructorIsConstexpr(true),

      HasConstexprDefaultConstructor(false),

      DefaultedDestructorIsConstexpr(true),

      HasNonLiteralTypeFieldsOrBases(false),

      UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),

      ImplicitCopyConstructorCanHaveConstParamForVBase(true),

      ImplicitCopyConstructorCanHaveConstParamForNonVBase(true),

      ImplicitCopyAssignmentHasConstParam(true),

      HasDeclaredCopyConstructorWithConstParam(false),

      HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false),

      IsParsingBaseSpecifiers(false), ComputedVisibleConversions(false),

      HasODRHash(false), Definition(D) {}

CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {

  return Bases.get(Definition->getASTContext().getExternalSource());

}

CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {

  return VBases.get(Definition->getASTContext().getExternalSource());

}

CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C,

                             DeclContext *DC, SourceLocation StartLoc,

                             SourceLocation IdLoc, IdentifierInfo *Id,

                             CXXRecordDecl *PrevDecl)

    : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl),

      DefinitionData(PrevDecl ? PrevDecl->DefinitionData

                              : nullptr) {}

CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,

                                     DeclContext *DC, SourceLocation StartLoc,

                                     SourceLocation IdLoc, IdentifierInfo *Id,

                                     CXXRecordDecl *PrevDecl,

                                     bool DelayTypeCreation) {

  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, IdLoc, Id,

                                      PrevDecl);

  R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);

  // FIXME: DelayTypeCreation seems like such a hack

  if (!DelayTypeCreation)

    C.getTypeDeclType(R, PrevDecl);

  return R;

}

CXXRecordDecl *

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

                            TypeSourceInfo *Info, SourceLocation Loc,

                            bool Dependent, bool IsGeneric,

                            LambdaCaptureDefault CaptureDefault) {

  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,

                                      nullptr, nullptr);

  R->setBeingDefined(true);

  R->DefinitionData =

      new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,

                                          CaptureDefault);

  R->setMayHaveOutOfDateDef(false);

  R->setImplicit(true);

  C.getTypeDeclType(R, /*PrevDecl=*/nullptr);

  return R;

}

CXXRecordDecl *

CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {

  auto *R = new (C, ID) CXXRecordDecl(

      CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),

      nullptr, nullptr);

  R->setMayHaveOutOfDateDef(false);

  return R;

}

/// Determine whether a class has a repeated base class. This is intended for

/// use when determining if a class is standard-layout, so makes no attempt to

/// handle virtual bases.

static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD) {

  llvm::SmallPtrSet<const CXXRecordDecl*, 8> SeenBaseTypes;

  SmallVector<const CXXRecordDecl*, 8> WorkList = {StartRD};

  while (!WorkList.empty()) {

    const CXXRecordDecl *RD = WorkList.pop_back_val();

    for (const CXXBaseSpecifier &BaseSpec : RD->bases()) {

      if (const CXXRecordDecl *B = BaseSpec.getType()->getAsCXXRecordDecl()) {

        if (!SeenBaseTypes.insert(B).second)

          return true;

        WorkList.push_back(B);

      }

    }

  }

  
return false5.63k
;

}

void

CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,

                        unsigned NumBases) {

  ASTContext &C = getASTContext();

  if (!data().Bases.isOffset() && data().NumBases > 0)

    C.Deallocate(data().getBases());

  if (NumBases) {

    if (!C.getLangOpts().CPlusPlus17) {

      // C++ [dcl.init.aggr]p1:

      //   An aggregate is [...] a class with [...] no base classes [...].

      data().Aggregate = false;

    }

    // C++ [class]p4:

    //   A POD-struct is an aggregate class...

    data().PlainOldData = false;

  }

  // The set of seen virtual base types.

  llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;

  // The virtual bases of this class.

  SmallVector<const CXXBaseSpecifier *, 8> VBases;

  data().Bases = new(C) CXXBaseSpecifier [NumBases];

  data().NumBases = NumBases;

  for (unsigned i = 0; i < NumBases; 
++i483k
) {

    data().getBases()[i] = *Bases[i];

    // Keep track of inherited vbases for this base class.

    const CXXBaseSpecifier *Base = Bases[i];

    QualType BaseType = Base->getType();

    // Skip dependent types; we can't do any checking on them now.

    if (BaseType->isDependentType())

      continue;

    auto *BaseClassDecl =

        cast<CXXRecordDecl>(BaseType->castAs<RecordType>()->getDecl());

    // C++2a [class]p7:

    //   A standard-layout class is a class that:

    //    [...]

    //    -- has all non-static data members and bit-fields in the class and

    //       its base classes first declared in the same class

    if (BaseClassDecl->data().HasBasesWithFields ||

        
!BaseClassDecl->field_empty()356k
) {

      if (data().HasBasesWithFields)

        // Two bases have members or bit-fields: not standard-layout.

        data().IsStandardLayout = false;

      data().HasBasesWithFields = true;

    }

    // C++11 [class]p7:

    //   A standard-layout class is a class that:

    //     -- [...] has [...] at most one base class with non-static data

    //        members

    if (BaseClassDecl->data().HasBasesWithNonStaticDataMembers ||

        
BaseClassDecl->hasDirectFields()356k
) {

      if (data().HasBasesWithNonStaticDataMembers)

        data().IsCXX11StandardLayout = false;

      data().HasBasesWithNonStaticDataMembers = true;

    }

    if (!BaseClassDecl->isEmpty()) {

      // C++14 [meta.unary.prop]p4:

      //   T is a class type [...] with [...] no base class B for which

      //   is_empty<B>::value is false.

      data().Empty = false;

    }

    // C++1z [dcl.init.agg]p1:

    //   An aggregate is a class with [...] no private or protected base classes

    if (Base->getAccessSpecifier() != AS_public)

      data().Aggregate = false;

    // C++ [class.virtual]p1:

    //   A class that declares or inherits a virtual function is called a

    //   polymorphic class.

    if (BaseClassDecl->isPolymorphic()) {

      data().Polymorphic = true;

      //   An aggregate is a class with [...] no virtual functions.

      data().Aggregate = false;

    }

    // C++0x [class]p7:

    //   A standard-layout class is a class that: [...]

    //    -- has no non-standard-layout base classes

    if (!BaseClassDecl->isStandardLayout())

      data().IsStandardLayout = false;

    if (!BaseClassDecl->isCXX11StandardLayout())

      data().IsCXX11StandardLayout = false;

    // Record if this base is the first non-literal field or base.

    if (!hasNonLiteralTypeFieldsOrBases() && 
!BaseType->isLiteralType(C)359k
)

      data().HasNonLiteralTypeFieldsOrBases = true;

    // Now go through all virtual bases of this base and add them.

    for (const auto &VBase : BaseClassDecl->vbases()) {

      // Add this base if it's not already in the list.

      if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {

        VBases.push_back(&VBase);

        // C++11 [class.copy]p8:

        //   The implicitly-declared copy constructor for a class X will have

        //   the form 'X::X(const X&)' if each [...] virtual base class B of X

        //   has a copy constructor whose first parameter is of type

        //   'const B&' or 'const volatile B&' [...]

        if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())

          if (!VBaseDecl->hasCopyConstructorWithConstParam())

            data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;

        // C++1z [dcl.init.agg]p1:

        //   An aggregate is a class with [...] no virtual base classes

        data().Aggregate = false;

      }

    }

    if (Base->isVirtual()) {

      // Add this base if it's not already in the list.

      if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)

        VBases.push_back(Base);

      // C++14 [meta.unary.prop] is_empty:

      //   T is a class type, but not a union type, with ... no virtual base

      //   classes

      data().Empty = false;

      // C++1z [dcl.init.agg]p1:

      //   An aggregate is a class with [...] no virtual base classes

      data().Aggregate = false;

      // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:

      //   A [default constructor, copy/move constructor, or copy/move assignment

      //   operator for a class X] is trivial [...] if:

      //    -- class X has [...] no virtual base classes

      data().HasTrivialSpecialMembers &= SMF_Destructor;

      data().HasTrivialSpecialMembersForCall &= SMF_Destructor;

      // C++0x [class]p7:

      //   A standard-layout class is a class that: [...]

      //    -- has [...] no virtual base classes

      data().IsStandardLayout = false;

      data().IsCXX11StandardLayout = false;

      // C++20 [dcl.constexpr]p3:

      //   In the definition of a constexpr function [...]

      //    -- if the function is a constructor or destructor,

      //       its class shall not have any virtual base classes

      data().DefaultedDefaultConstructorIsConstexpr = false;

      data().DefaultedDestructorIsConstexpr = false;

      // C++1z [class.copy]p8:

      //   The implicitly-declared copy constructor for a class X will have

      //   the form 'X::X(const X&)' if each potentially constructed subobject

      //   has a copy constructor whose first parameter is of type

      //   'const B&' or 'const volatile B&' [...]

      if (!BaseClassDecl->hasCopyConstructorWithConstParam())

        data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;

    } else {

      // C++ [class.ctor]p5:

      //   A default constructor is trivial [...] if:

      //    -- all the direct base classes of its class have trivial default

      //       constructors.

      if (!BaseClassDecl->hasTrivialDefaultConstructor())

        data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;

      // C++0x [class.copy]p13:

      //   A copy/move constructor for class X is trivial if [...]

      //    [...]

      //    -- the constructor selected to copy/move each direct base class

      //       subobject is trivial, and

      if (!BaseClassDecl->hasTrivialCopyConstructor())

        data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;

      if (!BaseClassDecl->hasTrivialCopyConstructorForCall())

        data().HasTrivialSpecialMembersForCall &= ~SMF_CopyConstructor;

      // If the base class doesn't have a simple move constructor, we'll eagerly

      // declare it and perform overload resolution to determine which function

      // it actually calls. If it does have a simple move constructor, this

      // check is correct.

      if (!BaseClassDecl->hasTrivialMoveConstructor())

        data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;

      if (!BaseClassDecl->hasTrivialMoveConstructorForCall())

        data().HasTrivialSpecialMembersForCall &= ~SMF_MoveConstructor;

      // C++0x [class.copy]p27:

      //   A copy/move assignment operator for class X is trivial if [...]

      //    [...]

      //    -- the assignment operator selected to copy/move each direct base

      //       class subobject is trivial, and

      if (!BaseClassDecl->hasTrivialCopyAssignment())

        data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;

      // If the base class doesn't have a simple move assignment, we'll eagerly

      // declare it and perform overload resolution to determine which function

      // it actually calls. If it does have a simple move assignment, this

      // check is correct.

      if (!BaseClassDecl->hasTrivialMoveAssignment())

        data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;

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

      //   If that user-written default constructor would satisfy the

      //   requirements of a constexpr constructor, the implicitly-defined

      //   default constructor is constexpr.

      if (!BaseClassDecl->hasConstexprDefaultConstructor())

        data().DefaultedDefaultConstructorIsConstexpr = false;

      // C++1z [class.copy]p8:

      //   The implicitly-declared copy constructor for a class X will have

      //   the form 'X::X(const X&)' if each potentially constructed subobject

      //   has a copy constructor whose first parameter is of type

      //   'const B&' or 'const volatile B&' [...]

      if (!BaseClassDecl->hasCopyConstructorWithConstParam())

        data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;

    }

    // C++ [class.ctor]p3:

    //   A destructor is trivial if all the direct base classes of its class

    //   have trivial destructors.

    if (!BaseClassDecl->hasTrivialDestructor())

      data().HasTrivialSpecialMembers &= ~SMF_Destructor;

    if (!BaseClassDecl->hasTrivialDestructorForCall())

      data().HasTrivialSpecialMembersForCall &= ~SMF_Destructor;

    if (!BaseClassDecl->hasIrrelevantDestructor())

      data().HasIrrelevantDestructor = false;

    // C++11 [class.copy]p18:

    //   The implicitly-declared copy assignment operator for a class X will

    //   have the form 'X& X::operator=(const X&)' if each direct base class B

    //   of X has a copy assignment operator whose parameter is of type 'const

    //   B&', 'const volatile B&', or 'B' [...]

    if (!BaseClassDecl->hasCopyAssignmentWithConstParam())

      data().ImplicitCopyAssignmentHasConstParam = false;

    // A class has an Objective-C object member if... or any of its bases

    // has an Objective-C object member.

    if (BaseClassDecl->hasObjectMember())

      setHasObjectMember(true);

    if (BaseClassDecl->hasVolatileMember())

      setHasVolatileMember(true);

    if (BaseClassDecl->getArgPassingRestrictions() ==

        RecordDecl::APK_CanNeverPassInRegs)

      setArgPassingRestrictions(RecordDecl::APK_CanNeverPassInRegs);

    // Keep track of the presence of mutable fields.

    if (BaseClassDecl->hasMutableFields()) {

      data().HasMutableFields = true;

      data().NeedOverloadResolutionForCopyConstructor = true;

    }

    if (BaseClassDecl->hasUninitializedReferenceMember())

      data().HasUninitializedReferenceMember = true;

    if (!BaseClassDecl->allowConstDefaultInit())

      data().HasUninitializedFields = true;

    addedClassSubobject(BaseClassDecl);

  }

  // C++2a [class]p7:

  //   A class S is a standard-layout class if it:

  //     -- has at most one base class subobject of any given type

  //

  // Note that we only need to check this for classes with more than one base

  // class. If there's only one base class, and it's standard layout, then

  // we know there are no repeated base classes.

  if (data().IsStandardLayout && 
NumBases > 1446k
 && 
hasRepeatedBaseClass(this)5.69k
)

    data().IsStandardLayout = false;

  if (VBases.empty()) {

    data().IsParsingBaseSpecifiers = false;

    return;

  }

  // Create base specifier for any direct or indirect virtual bases.

  data().VBases = new (C) CXXBaseSpecifier[VBases.size()];

  data().NumVBases = VBases.size();

  for (int I = 0, E = VBases.size(); I != E; 
++I4.90k
) {

    QualType Type = VBases[I]->getType();

    if (!Type->isDependentType())

      addedClassSubobject(Type->getAsCXXRecordDecl());

    data().getVBases()[I] = *VBases[I];

  }

  data().IsParsingBaseSpecifiers = false;

}

unsigned CXXRecordDecl::getODRHash() const {

  assert(hasDefinition() && "ODRHash only for records with definitions");

  // Previously calculated hash is stored in DefinitionData.

  if (DefinitionData->HasODRHash)

    return DefinitionData->ODRHash;

  // Only calculate hash on first call of getODRHash per record.

  ODRHash Hash;

  Hash.AddCXXRecordDecl(getDefinition());

  DefinitionData->HasODRHash = true;

  DefinitionData->ODRHash = Hash.CalculateHash();

  return DefinitionData->ODRHash;

}

void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) {

  // C++11 [class.copy]p11:

  //   A defaulted copy/move constructor for a class X is defined as

  //   deleted if X has:

  //    -- a direct or virtual base class B that cannot be copied/moved [...]

  //    -- a non-static data member of class type M (or array thereof)

  //       that cannot be copied or moved [...]

  if (!Subobj->hasSimpleCopyConstructor())

    data().NeedOverloadResolutionForCopyConstructor = true;

  if (!Subobj->hasSimpleMoveConstructor())

    data().NeedOverloadResolutionForMoveConstructor = true;

  // C++11 [class.copy]p23:

  //   A defaulted copy/move assignment operator for a class X is defined as

  //   deleted if X has:

  //    -- a direct or virtual base class B that cannot be copied/moved [...]

  //    -- a non-static data member of class type M (or array thereof)

  //        that cannot be copied or moved [...]

  if (!Subobj->hasSimpleMoveAssignment())

    data().NeedOverloadResolutionForMoveAssignment = true;

  // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5:

  //   A defaulted [ctor or dtor] for a class X is defined as

  //   deleted if X has:

  //    -- any direct or virtual base class [...] has a type with a destructor

  //       that is deleted or inaccessible from the defaulted [ctor or dtor].

  //    -- any non-static data member has a type with a destructor

  //       that is deleted or inaccessible from the defaulted [ctor or dtor].

  if (!Subobj->hasSimpleDestructor()) {

    data().NeedOverloadResolutionForCopyConstructor = true;

    data().NeedOverloadResolutionForMoveConstructor = true;

    data().NeedOverloadResolutionForDestructor = true;

  }

  // C++2a [dcl.constexpr]p4:

  //   The definition of a constexpr destructor [shall] satisfy the

  //   following requirement:

  //   -- for every subobject of class type or (possibly multi-dimensional)

  //      array thereof, that class type shall have a constexpr destructor

  if (!Subobj->hasConstexprDestructor())

    data().DefaultedDestructorIsConstexpr = false;

}

bool CXXRecordDecl::hasConstexprDestructor() const {

  auto *Dtor = getDestructor();

  return Dtor ? 
Dtor->isConstexpr()199k
 : 
defaultedDestructorIsConstexpr()445k
;

}

bool CXXRecordDecl::hasAnyDependentBases() const {

  if (!isDependentContext())

    return false;

  return !forallBases([](const CXXRecordDecl *) 
{ return true; }318
);

}

bool CXXRecordDecl::isTriviallyCopyable() const {

  // C++0x [class]p5:

  //   A trivially copyable class is a class that:

  //   -- has no non-trivial copy constructors,

  if (hasNonTrivialCopyConstructor()) 
return false31.2k
;

  //   -- has no non-trivial move constructors,

  if (hasNonTrivialMoveConstructor()) 
return false5.27k
;

  //   -- has no non-trivial copy assignment operators,

  if (hasNonTrivialCopyAssignment()) 
return false3.00k
;

  //   -- has no non-trivial move assignment operators, and

  if (hasNonTrivialMoveAssignment()) 
return false239
;

  //   -- has a trivial destructor.

  if (!hasTrivialDestructor()) 
return false8.04k
;

  return true;

}

void CXXRecordDecl::markedVirtualFunctionPure() {

  // C++ [class.abstract]p2:

  //   A class is abstract if it has at least one pure virtual function.

  data().Abstract = true;

}

bool CXXRecordDecl::hasSubobjectAtOffsetZeroOfEmptyBaseType(

    ASTContext &Ctx, const CXXRecordDecl *XFirst) {

  if (!getNumBases())

    return false;

  llvm::SmallPtrSet<const CXXRecordDecl*, 8> Bases;

  llvm::SmallPtrSet<const CXXRecordDecl*, 8> M;

  SmallVector<const CXXRecordDecl*, 8> WorkList;

  // Visit a type that we have determined is an element of M(S).

  auto Visit = [&](const CXXRecordDecl *RD) -> bool {

    RD = RD->getCanonicalDecl();

    // C++2a [class]p8:

    //   A class S is a standard-layout class if it [...] has no element of the

    //   set M(S) of types as a base class.

    //

    // If we find a subobject of an empty type, it might also be a base class,

    // so we'll need to walk the base classes to check.

    if (!RD->data().HasBasesWithFields) {

      // Walk the bases the first time, stopping if we find the type. Build a

      // set of them so we don't need to walk them again.

      if (Bases.empty()) {

        bool RDIsBase = !forallBases([&](const CXXRecordDecl *Base) -> bool {

          Base = Base->getCanonicalDecl();

          if (RD == Base)

            return false;

          Bases.insert(Base);

          return true;

        });

        if (RDIsBase)

          return true;

      } else {

        if (Bases.count(RD))

          return true;

      }

    }

    if (M.insert(RD).second)

      WorkList.push_back(RD);

    return false;

  };

  if (Visit(XFirst))

    return true;

  
while (913
!WorkList.empty()) {

    const CXXRecordDecl *X = WorkList.pop_back_val();

    // FIXME: We don't check the bases of X. That matches the standard, but

    // that sure looks like a wording bug.

    //   -- If X is a non-union class type with a non-static data member

    //      [recurse to each field] that is either of zero size or is the

    //      first non-static data member of X

    //   -- If X is a union type, [recurse to union members]

    bool IsFirstField = true;

    for (auto *FD : X->fields()) {

      // FIXME: Should we really care about the type of the first non-static

      // data member of a non-union if there are preceding unnamed bit-fields?

      if (FD->isUnnamedBitfield())

        continue;

      if (!IsFirstField && 
!FD->isZeroSize(Ctx)430
)

        continue;

      //   -- If X is n array type, [visit the element type]

      QualType T = Ctx.getBaseElementType(FD->getType());

      if (auto *RD = T->getAsCXXRecordDecl())

        if (Visit(RD))

          return true;

      if (!X->isUnion())

        IsFirstField = false;

    }

  }

  
return false879
;

}

bool CXXRecordDecl::lambdaIsDefaultConstructibleAndAssignable() const {

  assert(isLambda() && "not a lambda");

  // C++2a [expr.prim.lambda.capture]p11:

  //   The closure type associated with a lambda-expression has no default

  //   constructor if the lambda-expression has a lambda-capture and a

  //   defaulted default constructor otherwise. It has a deleted copy

  //   assignment operator if the lambda-expression has a lambda-capture and

  //   defaulted copy and move assignment operators otherwise.

  //

  // C++17 [expr.prim.lambda]p21:

  //   The closure type associated with a lambda-expression has no default

  //   constructor and a deleted copy assignment operator.

  if (getLambdaCaptureDefault() != LCD_None ||

      
getLambdaData().NumCaptures != 020.6k
)

    return false;

  return getASTContext().getLangOpts().CPlusPlus2a;

}

void CXXRecordDecl::addedMember(Decl *D) {

  if (!D->isImplicit() &&

      
!isa<FieldDecl>(D)4.91M
 &&

      
!isa<IndirectFieldDecl>(D)3.58M
 &&

      
(3.58M
!isa<TagDecl>(D)3.58M
 || 
cast<TagDecl>(D)->getTagKind() == TTK_Class73.5k
 ||

        
cast<TagDecl>(D)->getTagKind() == TTK_Interface69.3k
))

    data().HasOnlyCMembers = false;

  // Ignore friends and invalid declarations.

  if (
D->getFriendObjectKind()6.89M
 || D->isInvalidDecl())

    return;

  auto *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);

  if (FunTmpl)

    D = FunTmpl->getTemplatedDecl();

  // FIXME: Pass NamedDecl* to addedMember?

  Decl *DUnderlying = D;

  if (auto *ND = dyn_cast<NamedDecl>(DUnderlying)) {

    DUnderlying = ND->getUnderlyingDecl();

    if (auto *UnderlyingFunTmpl = dyn_cast<FunctionTemplateDecl>(DUnderlying))

      DUnderlying = UnderlyingFunTmpl->getTemplatedDecl();

  }

  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {

    if (Method->isVirtual()) {

      // C++ [dcl.init.aggr]p1:

      //   An aggregate is an array or a class with [...] no virtual functions.

      data().Aggregate = false;

      // C++ [class]p4:

      //   A POD-struct is an aggregate class...

      data().PlainOldData = false;

      // C++14 [meta.unary.prop]p4:

      //   T is a class type [...] with [...] no virtual member functions...

      data().Empty = false;

      // C++ [class.virtual]p1:

      //   A class that declares or inherits a virtual function is called a

      //   polymorphic class.

      data().Polymorphic = true;

      // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:

      //   A [default constructor, copy/move constructor, or copy/move

      //   assignment operator for a class X] is trivial [...] if:

      //    -- class X has no virtual functions [...]

      data().HasTrivialSpecialMembers &= SMF_Destructor;

      data().HasTrivialSpecialMembersForCall &= SMF_Destructor;

      // C++0x [class]p7:

      //   A standard-layout class is a class that: [...]

      //    -- has no virtual functions

      data().IsStandardLayout = false;

      data().IsCXX11StandardLayout = false;

    }

  }

  // Notify the listener if an implicit member was added after the definition

  // was completed.

  if (!isBeingDefined() && 
D->isImplicit()369k
)

    if (ASTMutationListener *L = getASTMutationListener())

      L->AddedCXXImplicitMember(data().Definition, D);

  // The kind of special member this declaration is, if any.

  unsigned SMKind = 0;

  // Handle constructors.

  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {

    if (Constructor->isInheritingConstructor()) {

      // Ignore constructor shadow declarations. They are lazily created and

      // so shouldn't affect any properties of the class.

    } else {

      if (!Constructor->isImplicit()) {

        // Note that we have a user-declared constructor.

        data().UserDeclaredConstructor = true;

        // C++ [class]p4:

        //   A POD-struct is an aggregate class [...]

        // Since the POD bit is meant to be C++03 POD-ness, clear it even if

        // the type is technically an aggregate in C++0x since it wouldn't be

        // in 03.

        data().PlainOldData = false;

      }

      if (Constructor->isDefaultConstructor()) {

        SMKind |= SMF_DefaultConstructor;

        if (Constructor->isUserProvided())

          data().UserProvidedDefaultConstructor = true;

        if (Constructor->isConstexpr())

          data().HasConstexprDefaultConstructor = true;

        if (Constructor->isDefaulted())

          data().HasDefaultedDefaultConstructor = true;

      }

      if (!FunTmpl) {

        unsigned Quals;

        if (Constructor->isCopyConstructor(Quals)) {

          SMKind |= SMF_CopyConstructor;

          if (Quals & Qualifiers::Const)

            data().HasDeclaredCopyConstructorWithConstParam = true;

        } else if (Constructor->isMoveConstructor())

          SMKind |= SMF_MoveConstructor;

      }

      // C++11 [dcl.init.aggr]p1: DR1518

      //   An aggregate is an array or a class with no user-provided [or]

      //   explicit [...] constructors

      // C++20 [dcl.init.aggr]p1:

      //   An aggregate is an array or a class with no user-declared [...]

      //   constructors

      if (getASTContext().getLangOpts().CPlusPlus2a

              ? 
!Constructor->isImplicit()3.26k

              : 
(619k
Constructor->isUserProvided()619k
 || 
Constructor->isExplicit()255k
))

        data().Aggregate = false;

    }

  }

  // Handle constructors, including those inherited from base classes.

  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {

    // Record if we see any constexpr constructors which are neither copy

    // nor move constructors.

    // C++1z [basic.types]p10:

    //   [...] has at least one constexpr constructor or constructor template

    //   (possibly inherited from a base class) that is not a copy or move

    //   constructor [...]

    if (Constructor->isConstexpr() && 
!Constructor->isCopyOrMoveConstructor()255k
)

      data().HasConstexprNonCopyMoveConstructor = true;

  }

  // Handle destructors.

  if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) {

    SMKind |= SMF_Destructor;

    if (DD->isUserProvided())

      data().HasIrrelevantDestructor = false;

    // If the destructor is explicitly defaulted and not trivial or not public

    // or if the destructor is deleted, we clear HasIrrelevantDestructor in

    // finishedDefaultedOrDeletedMember.

    // C++11 [class.dtor]p5:

    //   A destructor is trivial if [...] the destructor is not virtual.

    if (DD->isVirtual()) {

      data().HasTrivialSpecialMembers &= ~SMF_Destructor;

      data().HasTrivialSpecialMembersForCall &= ~SMF_Destructor;

    }

  }

  // Handle member functions.

  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {

    if (Method->isCopyAssignmentOperator()) {

      SMKind |= SMF_CopyAssignment;

      const auto *ParamTy =

          Method->getParamDecl(0)->getType()->getAs<ReferenceType>();

      if (!ParamTy || 
ParamTy->getPointeeType().isConstQualified()63.0k
)

        data().HasDeclaredCopyAssignmentWithConstParam = true;

    }

    if (Method->isMoveAssignmentOperator())

      SMKind |= SMF_MoveAssignment;

    // Keep the list of conversion functions up-to-date.

    if (auto *Conversion = dyn_cast<CXXConversionDecl>(D)) {

      // FIXME: We use the 'unsafe' accessor for the access specifier here,

      // because Sema may not have set it yet. That's really just a misdesign

      // in Sema. However, LLDB *will* have set the access specifier correctly,

      // and adds declarations after the class is technically completed,

      // so completeDefinition()'s overriding of the access specifiers doesn't

      // work.

      AccessSpecifier AS = Conversion->getAccessUnsafe();

      if (Conversion->getPrimaryTemplate()) {

        // We don't record specializations.

      } else {

        ASTContext &Ctx = getASTContext();

        ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);

        NamedDecl *Primary =

            FunTmpl ? 
cast<NamedDecl>(FunTmpl)2.31k
 : 
cast<NamedDecl>(Conversion)24.2k
;

        if (Primary->getPreviousDecl())

          Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),

                              Primary, AS);

        else

          Conversions.addDecl(Ctx, Primary, AS);

      }

    }

    if (SMKind) {

      // If this is the first declaration of a special member, we no longer have

      // an implicit trivial special member.

      data().HasTrivialSpecialMembers &=

          data().DeclaredSpecialMembers | ~SMKind;

      data().HasTrivialSpecialMembersForCall &=

          data().DeclaredSpecialMembers | ~SMKind;

      if (!Method->isImplicit() && 
!Method->isUserProvided()229k
) {

        // This method is user-declared but not user-provided. We can't work out

        // whether it's trivial yet (not until we get to the end of the class).

        // We'll handle this method in finishedDefaultedOrDeletedMember.

      } else if (Method->isTrivial()) {

        data().HasTrivialSpecialMembers |= SMKind;

        data().HasTrivialSpecialMembersForCall |= SMKind;

      } else 
if (253k
Method->isTrivialForCall()253k
) {

        data().HasTrivialSpecialMembersForCall |= SMKind;

        data().DeclaredNonTrivialSpecialMembers |= SMKind;

      } else {

        data().DeclaredNonTrivialSpecialMembers |= SMKind;

        // If this is a user-provided function, do not set

        // DeclaredNonTrivialSpecialMembersForCall here since we don't know

        // yet whether the method would be considered non-trivial for the

        // purpose of calls (attribute "trivial_abi" can be dropped from the

        // class later, which can change the special method's triviality).

        if (!Method->isUserProvided())

          data().DeclaredNonTrivialSpecialMembersForCall |= SMKind;

      }

      // Note when we have declared a declared special member, and suppress the

      // implicit declaration of this special member.

      data().DeclaredSpecialMembers |= SMKind;

      if (!Method->isImplicit()) {

        data().UserDeclaredSpecialMembers |= SMKind;

        // C++03 [class]p4:

        //   A POD-struct is an aggregate class that has [...] no user-defined

        //   copy assignment operator and no user-defined destructor.

        //

        // Since the POD bit is meant to be C++03 POD-ness, and in C++03,

        // aggregates could not have any constructors, clear it even for an

        // explicitly defaulted or deleted constructor.

        // type is technically an aggregate in C++0x since it wouldn't be in 03.

        //

        // Also, a user-declared move assignment operator makes a class non-POD.

        // This is an extension in C++03.

        data().PlainOldData = false;

      }

    }

    return;

  }

  // Handle non-static data members.

  if (const auto *Field = dyn_cast<FieldDecl>(D)) {

    ASTContext &Context = getASTContext();

    // C++2a [class]p7:

    //   A standard-layout class is a class that:

    //    [...]

    //    -- has all non-static data members and bit-fields in the class and

    //       its base classes first declared in the same class

    if (data().HasBasesWithFields)

      data().IsStandardLayout = false;

    // C++ [class.bit]p2:

    //   A declaration for a bit-field that omits the identifier declares an

    //   unnamed bit-field. Unnamed bit-fields are not members and cannot be

    //   initialized.

    if (Field->isUnnamedBitfield()) {

      // C++ [meta.unary.prop]p4: [LWG2358]

      //   T is a class type [...] with [...] no unnamed bit-fields of non-zero

      //   length

      if (data().Empty && 
!Field->isZeroLengthBitField(Context)113
 &&

          Context.getLangOpts().getClangABICompat() >

              LangOptions::ClangABI::Ver6)

        data().Empty = false;

      return;

    }

    // C++11 [class]p7:

    //   A standard-layout class is a class that:

    //    -- either has no non-static data members in the most derived class

    //       [...] or has no base classes with non-static data members

    if (data().HasBasesWithNonStaticDataMembers)

      data().IsCXX11StandardLayout = false;

    // C++ [dcl.init.aggr]p1:

    //   An aggregate is an array or a class (clause 9) with [...] no

    //   private or protected non-static data members (clause 11).

    //

    // A POD must be an aggregate.

    if (D->getAccess() == AS_private || 
D->getAccess() == AS_protected1.24M
) {

      data().Aggregate = false;

      data().PlainOldData = false;

    }

    // Track whether this is the first field. We use this when checking

    // whether the class is standard-layout below.

    bool IsFirstField = !data().HasPrivateFields &&

                        
!data().HasProtectedFields1.48M
 && 
!data().HasPublicFields1.47M
;

    // C++0x [class]p7:

    //   A standard-layout class is a class that:

    //    [...]

    //    -- has the same access control for all non-static data members,

    switch (D->getAccess()) {

    case AS_private:    data().HasPrivateFields = true;   break;

    case AS_protected:  data().HasProtectedFields = true; break;

    case AS_public:     data().HasPublicFields = true;    break;

    case AS_none:       llvm_unreachable("Invalid access specifier");

    };

    if ((data().HasPrivateFields + data().HasProtectedFields +

         data().HasPublicFields) > 1) {

      data().IsStandardLayout = false;

      data().IsCXX11StandardLayout = false;

    }

    // Keep track of the presence of mutable fields.

    if (Field->isMutable()) {

      data().HasMutableFields = true;

      data().NeedOverloadResolutionForCopyConstructor = true;

    }

    // C++11 [class.union]p8, DR1460:

    //   If X is a union, a non-static data member of X that is not an anonymous

    //   union is a variant member of X.

    if (isUnion() && 
!Field->isAnonymousStructOrUnion()51.7k
)

      data().HasVariantMembers = true;

    // C++0x [class]p9:

    //   A POD struct is a class that is both a trivial class and a

    //   standard-layout class, and has no non-static data members of type

    //   non-POD struct, non-POD union (or array of such types).

    //

    // Automatic Reference Counting: the presence of a member of Objective-C pointer type

    // that does not explicitly have no lifetime makes the class a non-POD.

    QualType T = Context.getBaseElementType(Field->getType());

    if (T->isObjCRetainableType() || 
T.isObjCGCStrong()1.64M
) {

      if (T.hasNonTrivialObjCLifetime()) {