1193326Sed//===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements the C++ related Decl classes. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "clang/AST/DeclCXX.h" 15193326Sed#include "clang/AST/ASTContext.h" 16218893Sdim#include "clang/AST/ASTMutationListener.h" 17218893Sdim#include "clang/AST/CXXInheritance.h" 18249423Sdim#include "clang/AST/DeclTemplate.h" 19193326Sed#include "clang/AST/Expr.h" 20234353Sdim#include "clang/AST/ExprCXX.h" 21200583Srdivacky#include "clang/AST/TypeLoc.h" 22193326Sed#include "clang/Basic/IdentifierTable.h" 23193326Sed#include "llvm/ADT/STLExtras.h" 24198092Srdivacky#include "llvm/ADT/SmallPtrSet.h" 25193326Sedusing namespace clang; 26193326Sed 27193326Sed//===----------------------------------------------------------------------===// 28193326Sed// Decl Allocation/Deallocation Method Implementations 29193326Sed//===----------------------------------------------------------------------===// 30193326Sed 31234353Sdimvoid AccessSpecDecl::anchor() { } 32234353Sdim 33234353SdimAccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 34234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(AccessSpecDecl)); 35234353Sdim return new (Mem) AccessSpecDecl(EmptyShell()); 36234353Sdim} 37234353Sdim 38203955SrdivackyCXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D) 39249423Sdim : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0), 40198092Srdivacky Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false), 41221345Sdim Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true), 42221345Sdim HasPrivateFields(false), HasProtectedFields(false), HasPublicFields(false), 43234353Sdim HasMutableFields(false), HasOnlyCMembers(true), 44249423Sdim HasInClassInitializer(false), HasUninitializedReferenceMember(false), 45249423Sdim NeedOverloadResolutionForMoveConstructor(false), 46249423Sdim NeedOverloadResolutionForMoveAssignment(false), 47249423Sdim NeedOverloadResolutionForDestructor(false), 48249423Sdim DefaultedMoveConstructorIsDeleted(false), 49249423Sdim DefaultedMoveAssignmentIsDeleted(false), 50249423Sdim DefaultedDestructorIsDeleted(false), 51249423Sdim HasTrivialSpecialMembers(SMF_All), 52249423Sdim DeclaredNonTrivialSpecialMembers(0), 53249423Sdim HasIrrelevantDestructor(true), 54234353Sdim HasConstexprNonCopyMoveConstructor(false), 55234353Sdim DefaultedDefaultConstructorIsConstexpr(true), 56249423Sdim HasConstexprDefaultConstructor(false), 57223017Sdim HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false), 58249423Sdim UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0), 59249423Sdim ImplicitCopyConstructorHasConstParam(true), 60249423Sdim ImplicitCopyAssignmentHasConstParam(true), 61249423Sdim HasDeclaredCopyConstructorWithConstParam(false), 62249423Sdim HasDeclaredCopyAssignmentWithConstParam(false), 63249423Sdim FailedImplicitMoveConstructor(false), FailedImplicitMoveAssignment(false), 64249423Sdim IsLambda(false), NumBases(0), NumVBases(0), Bases(), VBases(), 65249423Sdim Definition(D), FirstFriend(0) { 66203955Srdivacky} 67203955Srdivacky 68239462SdimCXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const { 69239462Sdim return Bases.get(Definition->getASTContext().getExternalSource()); 70239462Sdim} 71239462Sdim 72239462SdimCXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const { 73239462Sdim return VBases.get(Definition->getASTContext().getExternalSource()); 74239462Sdim} 75239462Sdim 76203955SrdivackyCXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, DeclContext *DC, 77221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 78221345Sdim IdentifierInfo *Id, CXXRecordDecl *PrevDecl) 79221345Sdim : RecordDecl(K, TK, DC, StartLoc, IdLoc, Id, PrevDecl), 80203955Srdivacky DefinitionData(PrevDecl ? PrevDecl->DefinitionData : 0), 81193326Sed TemplateOrInstantiation() { } 82193326Sed 83218893SdimCXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK, 84221345Sdim DeclContext *DC, SourceLocation StartLoc, 85221345Sdim SourceLocation IdLoc, IdentifierInfo *Id, 86193326Sed CXXRecordDecl* PrevDecl, 87193326Sed bool DelayTypeCreation) { 88221345Sdim CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TK, DC, StartLoc, IdLoc, 89221345Sdim Id, PrevDecl); 90249423Sdim R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 91198092Srdivacky 92198092Srdivacky // FIXME: DelayTypeCreation seems like such a hack 93193326Sed if (!DelayTypeCreation) 94198092Srdivacky C.getTypeDeclType(R, PrevDecl); 95193326Sed return R; 96193326Sed} 97193326Sed 98234353SdimCXXRecordDecl *CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC, 99243830Sdim TypeSourceInfo *Info, SourceLocation Loc, 100243830Sdim bool Dependent) { 101234353Sdim CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TTK_Class, DC, Loc, Loc, 102234353Sdim 0, 0); 103234353Sdim R->IsBeingDefined = true; 104243830Sdim R->DefinitionData = new (C) struct LambdaDefinitionData(R, Info, Dependent); 105249423Sdim R->MayHaveOutOfDateDef = false; 106234353Sdim C.getTypeDeclType(R, /*PrevDecl=*/0); 107234353Sdim return R; 108210299Sed} 109210299Sed 110234353SdimCXXRecordDecl * 111234353SdimCXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { 112234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXRecordDecl)); 113249423Sdim CXXRecordDecl *R = new (Mem) CXXRecordDecl(CXXRecord, TTK_Struct, 0, 114249423Sdim SourceLocation(), SourceLocation(), 115249423Sdim 0, 0); 116249423Sdim R->MayHaveOutOfDateDef = false; 117249423Sdim return R; 118234353Sdim} 119234353Sdim 120198092Srdivackyvoid 121203955SrdivackyCXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases, 122193326Sed unsigned NumBases) { 123203955Srdivacky ASTContext &C = getASTContext(); 124193326Sed 125218893Sdim if (!data().Bases.isOffset() && data().NumBases > 0) 126218893Sdim C.Deallocate(data().getBases()); 127193326Sed 128234353Sdim if (NumBases) { 129234353Sdim // C++ [dcl.init.aggr]p1: 130234353Sdim // An aggregate is [...] a class with [...] no base classes [...]. 131234353Sdim data().Aggregate = false; 132234353Sdim 133234353Sdim // C++ [class]p4: 134234353Sdim // A POD-struct is an aggregate class... 135234353Sdim data().PlainOldData = false; 136234353Sdim } 137234353Sdim 138206084Srdivacky // The set of seen virtual base types. 139206084Srdivacky llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes; 140206084Srdivacky 141206084Srdivacky // The virtual bases of this class. 142226633Sdim SmallVector<const CXXBaseSpecifier *, 8> VBases; 143198092Srdivacky 144203955Srdivacky data().Bases = new(C) CXXBaseSpecifier [NumBases]; 145203955Srdivacky data().NumBases = NumBases; 146198092Srdivacky for (unsigned i = 0; i < NumBases; ++i) { 147218893Sdim data().getBases()[i] = *Bases[i]; 148198092Srdivacky // Keep track of inherited vbases for this base class. 149198092Srdivacky const CXXBaseSpecifier *Base = Bases[i]; 150198092Srdivacky QualType BaseType = Base->getType(); 151204643Srdivacky // Skip dependent types; we can't do any checking on them now. 152198092Srdivacky if (BaseType->isDependentType()) 153198092Srdivacky continue; 154198092Srdivacky CXXRecordDecl *BaseClassDecl 155198092Srdivacky = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 156206084Srdivacky 157218893Sdim // A class with a non-empty base class is not empty. 158218893Sdim // FIXME: Standard ref? 159221345Sdim if (!BaseClassDecl->isEmpty()) { 160221345Sdim if (!data().Empty) { 161221345Sdim // C++0x [class]p7: 162221345Sdim // A standard-layout class is a class that: 163221345Sdim // [...] 164221345Sdim // -- either has no non-static data members in the most derived 165221345Sdim // class and at most one base class with non-static data members, 166221345Sdim // or has no base classes with non-static data members, and 167221345Sdim // If this is the second non-empty base, then neither of these two 168221345Sdim // clauses can be true. 169221345Sdim data().IsStandardLayout = false; 170221345Sdim } 171221345Sdim 172218893Sdim data().Empty = false; 173221345Sdim data().HasNoNonEmptyBases = false; 174221345Sdim } 175218893Sdim 176218893Sdim // C++ [class.virtual]p1: 177218893Sdim // A class that declares or inherits a virtual function is called a 178218893Sdim // polymorphic class. 179218893Sdim if (BaseClassDecl->isPolymorphic()) 180218893Sdim data().Polymorphic = true; 181221345Sdim 182221345Sdim // C++0x [class]p7: 183221345Sdim // A standard-layout class is a class that: [...] 184221345Sdim // -- has no non-standard-layout base classes 185221345Sdim if (!BaseClassDecl->isStandardLayout()) 186221345Sdim data().IsStandardLayout = false; 187221345Sdim 188221345Sdim // Record if this base is the first non-literal field or base. 189251662Sdim if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C)) 190221345Sdim data().HasNonLiteralTypeFieldsOrBases = true; 191218893Sdim 192206084Srdivacky // Now go through all virtual bases of this base and add them. 193198092Srdivacky for (CXXRecordDecl::base_class_iterator VBase = 194198092Srdivacky BaseClassDecl->vbases_begin(), 195198092Srdivacky E = BaseClassDecl->vbases_end(); VBase != E; ++VBase) { 196206084Srdivacky // Add this base if it's not already in the list. 197249423Sdim if (SeenVBaseTypes.insert(C.getCanonicalType(VBase->getType()))) { 198206084Srdivacky VBases.push_back(VBase); 199249423Sdim 200249423Sdim // C++11 [class.copy]p8: 201249423Sdim // The implicitly-declared copy constructor for a class X will have 202249423Sdim // the form 'X::X(const X&)' if each [...] virtual base class B of X 203249423Sdim // has a copy constructor whose first parameter is of type 204249423Sdim // 'const B&' or 'const volatile B&' [...] 205249423Sdim if (CXXRecordDecl *VBaseDecl = VBase->getType()->getAsCXXRecordDecl()) 206249423Sdim if (!VBaseDecl->hasCopyConstructorWithConstParam()) 207249423Sdim data().ImplicitCopyConstructorHasConstParam = false; 208249423Sdim } 209198092Srdivacky } 210206084Srdivacky 211206084Srdivacky if (Base->isVirtual()) { 212206084Srdivacky // Add this base if it's not already in the list. 213206084Srdivacky if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType))) 214249423Sdim VBases.push_back(Base); 215249423Sdim 216218893Sdim // C++0x [meta.unary.prop] is_empty: 217218893Sdim // T is a class type, but not a union type, with ... no virtual base 218218893Sdim // classes 219218893Sdim data().Empty = false; 220221345Sdim 221249423Sdim // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25: 222249423Sdim // A [default constructor, copy/move constructor, or copy/move assignment 223249423Sdim // operator for a class X] is trivial [...] if: 224249423Sdim // -- class X has [...] no virtual base classes 225249423Sdim data().HasTrivialSpecialMembers &= SMF_Destructor; 226221345Sdim 227221345Sdim // C++0x [class]p7: 228221345Sdim // A standard-layout class is a class that: [...] 229221345Sdim // -- has [...] no virtual base classes 230221345Sdim data().IsStandardLayout = false; 231234353Sdim 232234353Sdim // C++11 [dcl.constexpr]p4: 233234353Sdim // In the definition of a constexpr constructor [...] 234234353Sdim // -- the class shall not have any virtual base classes 235234353Sdim data().DefaultedDefaultConstructorIsConstexpr = false; 236218893Sdim } else { 237218893Sdim // C++ [class.ctor]p5: 238223017Sdim // A default constructor is trivial [...] if: 239223017Sdim // -- all the direct base classes of its class have trivial default 240223017Sdim // constructors. 241223017Sdim if (!BaseClassDecl->hasTrivialDefaultConstructor()) 242249423Sdim data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 243249423Sdim 244221345Sdim // C++0x [class.copy]p13: 245221345Sdim // A copy/move constructor for class X is trivial if [...] 246221345Sdim // [...] 247221345Sdim // -- the constructor selected to copy/move each direct base class 248221345Sdim // subobject is trivial, and 249218893Sdim if (!BaseClassDecl->hasTrivialCopyConstructor()) 250249423Sdim data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor; 251249423Sdim // If the base class doesn't have a simple move constructor, we'll eagerly 252249423Sdim // declare it and perform overload resolution to determine which function 253249423Sdim // it actually calls. If it does have a simple move constructor, this 254249423Sdim // check is correct. 255249423Sdim if (!BaseClassDecl->hasTrivialMoveConstructor()) 256249423Sdim data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor; 257221345Sdim 258221345Sdim // C++0x [class.copy]p27: 259221345Sdim // A copy/move assignment operator for class X is trivial if [...] 260221345Sdim // [...] 261221345Sdim // -- the assignment operator selected to copy/move each direct base 262221345Sdim // class subobject is trivial, and 263218893Sdim if (!BaseClassDecl->hasTrivialCopyAssignment()) 264249423Sdim data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment; 265249423Sdim // If the base class doesn't have a simple move assignment, we'll eagerly 266249423Sdim // declare it and perform overload resolution to determine which function 267249423Sdim // it actually calls. If it does have a simple move assignment, this 268249423Sdim // check is correct. 269249423Sdim if (!BaseClassDecl->hasTrivialMoveAssignment()) 270249423Sdim data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment; 271234353Sdim 272234353Sdim // C++11 [class.ctor]p6: 273234353Sdim // If that user-written default constructor would satisfy the 274234353Sdim // requirements of a constexpr constructor, the implicitly-defined 275234353Sdim // default constructor is constexpr. 276234353Sdim if (!BaseClassDecl->hasConstexprDefaultConstructor()) 277234353Sdim data().DefaultedDefaultConstructorIsConstexpr = false; 278198092Srdivacky } 279249423Sdim 280218893Sdim // C++ [class.ctor]p3: 281218893Sdim // A destructor is trivial if all the direct base classes of its class 282218893Sdim // have trivial destructors. 283218893Sdim if (!BaseClassDecl->hasTrivialDestructor()) 284249423Sdim data().HasTrivialSpecialMembers &= ~SMF_Destructor; 285234353Sdim 286234353Sdim if (!BaseClassDecl->hasIrrelevantDestructor()) 287234353Sdim data().HasIrrelevantDestructor = false; 288234353Sdim 289249423Sdim // C++11 [class.copy]p18: 290249423Sdim // The implicitly-declared copy assignment oeprator for a class X will 291249423Sdim // have the form 'X& X::operator=(const X&)' if each direct base class B 292249423Sdim // of X has a copy assignment operator whose parameter is of type 'const 293249423Sdim // B&', 'const volatile B&', or 'B' [...] 294249423Sdim if (!BaseClassDecl->hasCopyAssignmentWithConstParam()) 295249423Sdim data().ImplicitCopyAssignmentHasConstParam = false; 296249423Sdim 297249423Sdim // C++11 [class.copy]p8: 298249423Sdim // The implicitly-declared copy constructor for a class X will have 299249423Sdim // the form 'X::X(const X&)' if each direct [...] base class B of X 300249423Sdim // has a copy constructor whose first parameter is of type 301249423Sdim // 'const B&' or 'const volatile B&' [...] 302249423Sdim if (!BaseClassDecl->hasCopyConstructorWithConstParam()) 303249423Sdim data().ImplicitCopyConstructorHasConstParam = false; 304249423Sdim 305224145Sdim // A class has an Objective-C object member if... or any of its bases 306224145Sdim // has an Objective-C object member. 307224145Sdim if (BaseClassDecl->hasObjectMember()) 308224145Sdim setHasObjectMember(true); 309249423Sdim 310249423Sdim if (BaseClassDecl->hasVolatileMember()) 311249423Sdim setHasVolatileMember(true); 312224145Sdim 313223017Sdim // Keep track of the presence of mutable fields. 314223017Sdim if (BaseClassDecl->hasMutableFields()) 315223017Sdim data().HasMutableFields = true; 316249423Sdim 317249423Sdim if (BaseClassDecl->hasUninitializedReferenceMember()) 318249423Sdim data().HasUninitializedReferenceMember = true; 319249423Sdim 320249423Sdim addedClassSubobject(BaseClassDecl); 321198092Srdivacky } 322206084Srdivacky 323206084Srdivacky if (VBases.empty()) 324206084Srdivacky return; 325206084Srdivacky 326206084Srdivacky // Create base specifier for any direct or indirect virtual bases. 327206084Srdivacky data().VBases = new (C) CXXBaseSpecifier[VBases.size()]; 328206084Srdivacky data().NumVBases = VBases.size(); 329249423Sdim for (int I = 0, E = VBases.size(); I != E; ++I) { 330249423Sdim QualType Type = VBases[I]->getType(); 331249423Sdim if (!Type->isDependentType()) 332249423Sdim addedClassSubobject(Type->getAsCXXRecordDecl()); 333224145Sdim data().getVBases()[I] = *VBases[I]; 334249423Sdim } 335193326Sed} 336193326Sed 337249423Sdimvoid CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) { 338249423Sdim // C++11 [class.copy]p11: 339249423Sdim // A defaulted copy/move constructor for a class X is defined as 340249423Sdim // deleted if X has: 341249423Sdim // -- a direct or virtual base class B that cannot be copied/moved [...] 342249423Sdim // -- a non-static data member of class type M (or array thereof) 343249423Sdim // that cannot be copied or moved [...] 344249423Sdim if (!Subobj->hasSimpleMoveConstructor()) 345249423Sdim data().NeedOverloadResolutionForMoveConstructor = true; 346249423Sdim 347249423Sdim // C++11 [class.copy]p23: 348249423Sdim // A defaulted copy/move assignment operator for a class X is defined as 349249423Sdim // deleted if X has: 350249423Sdim // -- a direct or virtual base class B that cannot be copied/moved [...] 351249423Sdim // -- a non-static data member of class type M (or array thereof) 352249423Sdim // that cannot be copied or moved [...] 353249423Sdim if (!Subobj->hasSimpleMoveAssignment()) 354249423Sdim data().NeedOverloadResolutionForMoveAssignment = true; 355249423Sdim 356249423Sdim // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5: 357249423Sdim // A defaulted [ctor or dtor] for a class X is defined as 358249423Sdim // deleted if X has: 359249423Sdim // -- any direct or virtual base class [...] has a type with a destructor 360249423Sdim // that is deleted or inaccessible from the defaulted [ctor or dtor]. 361249423Sdim // -- any non-static data member has a type with a destructor 362249423Sdim // that is deleted or inaccessible from the defaulted [ctor or dtor]. 363249423Sdim if (!Subobj->hasSimpleDestructor()) { 364249423Sdim data().NeedOverloadResolutionForMoveConstructor = true; 365249423Sdim data().NeedOverloadResolutionForDestructor = true; 366249423Sdim } 367249423Sdim} 368249423Sdim 369202379Srdivacky/// Callback function for CXXRecordDecl::forallBases that acknowledges 370202379Srdivacky/// that it saw a base class. 371202379Srdivackystatic bool SawBase(const CXXRecordDecl *, void *) { 372202379Srdivacky return true; 373202379Srdivacky} 374202379Srdivacky 375202379Srdivackybool CXXRecordDecl::hasAnyDependentBases() const { 376202379Srdivacky if (!isDependentContext()) 377202379Srdivacky return false; 378202379Srdivacky 379202379Srdivacky return !forallBases(SawBase, 0); 380202379Srdivacky} 381202379Srdivacky 382221345Sdimbool CXXRecordDecl::isTriviallyCopyable() const { 383221345Sdim // C++0x [class]p5: 384221345Sdim // A trivially copyable class is a class that: 385221345Sdim // -- has no non-trivial copy constructors, 386249423Sdim if (hasNonTrivialCopyConstructor()) return false; 387221345Sdim // -- has no non-trivial move constructors, 388249423Sdim if (hasNonTrivialMoveConstructor()) return false; 389221345Sdim // -- has no non-trivial copy assignment operators, 390249423Sdim if (hasNonTrivialCopyAssignment()) return false; 391221345Sdim // -- has no non-trivial move assignment operators, and 392249423Sdim if (hasNonTrivialMoveAssignment()) return false; 393221345Sdim // -- has a trivial destructor. 394221345Sdim if (!hasTrivialDestructor()) return false; 395221345Sdim 396221345Sdim return true; 397221345Sdim} 398221345Sdim 399218893Sdimvoid CXXRecordDecl::markedVirtualFunctionPure() { 400218893Sdim // C++ [class.abstract]p2: 401218893Sdim // A class is abstract if it has at least one pure virtual function. 402218893Sdim data().Abstract = true; 403218893Sdim} 404193326Sed 405218893Sdimvoid CXXRecordDecl::addedMember(Decl *D) { 406234353Sdim if (!D->isImplicit() && 407234353Sdim !isa<FieldDecl>(D) && 408234353Sdim !isa<IndirectFieldDecl>(D) && 409243830Sdim (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class || 410243830Sdim cast<TagDecl>(D)->getTagKind() == TTK_Interface)) 411234353Sdim data().HasOnlyCMembers = false; 412234353Sdim 413218893Sdim // Ignore friends and invalid declarations. 414218893Sdim if (D->getFriendObjectKind() || D->isInvalidDecl()) 415218893Sdim return; 416210299Sed 417218893Sdim FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D); 418218893Sdim if (FunTmpl) 419218893Sdim D = FunTmpl->getTemplatedDecl(); 420218893Sdim 421218893Sdim if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 422218893Sdim if (Method->isVirtual()) { 423218893Sdim // C++ [dcl.init.aggr]p1: 424218893Sdim // An aggregate is an array or a class with [...] no virtual functions. 425218893Sdim data().Aggregate = false; 426218893Sdim 427218893Sdim // C++ [class]p4: 428218893Sdim // A POD-struct is an aggregate class... 429218893Sdim data().PlainOldData = false; 430218893Sdim 431218893Sdim // Virtual functions make the class non-empty. 432218893Sdim // FIXME: Standard ref? 433218893Sdim data().Empty = false; 434193326Sed 435218893Sdim // C++ [class.virtual]p1: 436218893Sdim // A class that declares or inherits a virtual function is called a 437218893Sdim // polymorphic class. 438218893Sdim data().Polymorphic = true; 439221345Sdim 440249423Sdim // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25: 441249423Sdim // A [default constructor, copy/move constructor, or copy/move 442249423Sdim // assignment operator for a class X] is trivial [...] if: 443221345Sdim // -- class X has no virtual functions [...] 444249423Sdim data().HasTrivialSpecialMembers &= SMF_Destructor; 445221345Sdim 446221345Sdim // C++0x [class]p7: 447221345Sdim // A standard-layout class is a class that: [...] 448221345Sdim // -- has no virtual functions 449221345Sdim data().IsStandardLayout = false; 450218893Sdim } 451218893Sdim } 452193326Sed 453249423Sdim // Notify the listener if an implicit member was added after the definition 454249423Sdim // was completed. 455249423Sdim if (!isBeingDefined() && D->isImplicit()) 456249423Sdim if (ASTMutationListener *L = getASTMutationListener()) 457249423Sdim L->AddedCXXImplicitMember(data().Definition, D); 458218893Sdim 459249423Sdim // The kind of special member this declaration is, if any. 460249423Sdim unsigned SMKind = 0; 461249423Sdim 462249423Sdim // Handle constructors. 463218893Sdim if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 464249423Sdim if (!Constructor->isImplicit()) { 465249423Sdim // Note that we have a user-declared constructor. 466249423Sdim data().UserDeclaredConstructor = true; 467218893Sdim 468249423Sdim // C++ [class]p4: 469249423Sdim // A POD-struct is an aggregate class [...] 470249423Sdim // Since the POD bit is meant to be C++03 POD-ness, clear it even if the 471249423Sdim // type is technically an aggregate in C++0x since it wouldn't be in 03. 472249423Sdim data().PlainOldData = false; 473249423Sdim } 474249423Sdim 475226633Sdim // Technically, "user-provided" is only defined for special member 476226633Sdim // functions, but the intent of the standard is clearly that it should apply 477226633Sdim // to all functions. 478226633Sdim bool UserProvided = Constructor->isUserProvided(); 479218893Sdim 480223017Sdim if (Constructor->isDefaultConstructor()) { 481249423Sdim SMKind |= SMF_DefaultConstructor; 482249423Sdim 483249423Sdim if (UserProvided) 484223017Sdim data().UserProvidedDefaultConstructor = true; 485249423Sdim if (Constructor->isConstexpr()) 486234353Sdim data().HasConstexprDefaultConstructor = true; 487223017Sdim } 488218893Sdim 489221345Sdim if (!FunTmpl) { 490249423Sdim unsigned Quals; 491249423Sdim if (Constructor->isCopyConstructor(Quals)) { 492249423Sdim SMKind |= SMF_CopyConstructor; 493221345Sdim 494249423Sdim if (Quals & Qualifiers::Const) 495249423Sdim data().HasDeclaredCopyConstructorWithConstParam = true; 496249423Sdim } else if (Constructor->isMoveConstructor()) 497249423Sdim SMKind |= SMF_MoveConstructor; 498249423Sdim } 499223017Sdim 500249423Sdim // Record if we see any constexpr constructors which are neither copy 501249423Sdim // nor move constructors. 502249423Sdim if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor()) 503226633Sdim data().HasConstexprNonCopyMoveConstructor = true; 504221345Sdim 505223017Sdim // C++ [dcl.init.aggr]p1: 506223017Sdim // An aggregate is an array or a class with no user-declared 507223017Sdim // constructors [...]. 508251662Sdim // C++11 [dcl.init.aggr]p1: 509223017Sdim // An aggregate is an array or a class with no user-provided 510223017Sdim // constructors [...]. 511249423Sdim if (getASTContext().getLangOpts().CPlusPlus11 512249423Sdim ? UserProvided : !Constructor->isImplicit()) 513223017Sdim data().Aggregate = false; 514198092Srdivacky } 515193326Sed 516249423Sdim // Handle destructors. 517223017Sdim if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) { 518249423Sdim SMKind |= SMF_Destructor; 519234353Sdim 520249423Sdim if (!DD->isImplicit()) 521249423Sdim data().HasIrrelevantDestructor = false; 522239462Sdim 523249423Sdim // C++11 [class.dtor]p5: 524249423Sdim // A destructor is trivial if [...] the destructor is not virtual. 525249423Sdim if (DD->isVirtual()) 526249423Sdim data().HasTrivialSpecialMembers &= ~SMF_Destructor; 527218893Sdim } 528249423Sdim 529249423Sdim // Handle member functions. 530218893Sdim if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 531223017Sdim if (Method->isCopyAssignmentOperator()) { 532249423Sdim SMKind |= SMF_CopyAssignment; 533221345Sdim 534249423Sdim const ReferenceType *ParamTy = 535249423Sdim Method->getParamDecl(0)->getType()->getAs<ReferenceType>(); 536249423Sdim if (!ParamTy || ParamTy->getPointeeType().isConstQualified()) 537249423Sdim data().HasDeclaredCopyAssignmentWithConstParam = true; 538223017Sdim } 539223017Sdim 540249423Sdim if (Method->isMoveAssignmentOperator()) 541249423Sdim SMKind |= SMF_MoveAssignment; 542223017Sdim 543218893Sdim // Keep the list of conversion functions up-to-date. 544218893Sdim if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { 545251662Sdim // FIXME: We use the 'unsafe' accessor for the access specifier here, 546251662Sdim // because Sema may not have set it yet. That's really just a misdesign 547251662Sdim // in Sema. However, LLDB *will* have set the access specifier correctly, 548251662Sdim // and adds declarations after the class is technically completed, 549251662Sdim // so completeDefinition()'s overriding of the access specifiers doesn't 550251662Sdim // work. 551251662Sdim AccessSpecifier AS = Conversion->getAccessUnsafe(); 552251662Sdim 553249423Sdim if (Conversion->getPrimaryTemplate()) { 554249423Sdim // We don't record specializations. 555249423Sdim } else if (FunTmpl) { 556234353Sdim if (FunTmpl->getPreviousDecl()) 557234353Sdim data().Conversions.replace(FunTmpl->getPreviousDecl(), 558251662Sdim FunTmpl, AS); 559218893Sdim else 560251662Sdim data().Conversions.addDecl(getASTContext(), FunTmpl, AS); 561218893Sdim } else { 562234353Sdim if (Conversion->getPreviousDecl()) 563234353Sdim data().Conversions.replace(Conversion->getPreviousDecl(), 564251662Sdim Conversion, AS); 565218893Sdim else 566251662Sdim data().Conversions.addDecl(getASTContext(), Conversion, AS); 567218893Sdim } 568218893Sdim } 569249423Sdim 570249423Sdim if (SMKind) { 571249423Sdim // If this is the first declaration of a special member, we no longer have 572249423Sdim // an implicit trivial special member. 573249423Sdim data().HasTrivialSpecialMembers &= 574249423Sdim data().DeclaredSpecialMembers | ~SMKind; 575249423Sdim 576249423Sdim if (!Method->isImplicit() && !Method->isUserProvided()) { 577249423Sdim // This method is user-declared but not user-provided. We can't work out 578249423Sdim // whether it's trivial yet (not until we get to the end of the class). 579249423Sdim // We'll handle this method in finishedDefaultedOrDeletedMember. 580249423Sdim } else if (Method->isTrivial()) 581249423Sdim data().HasTrivialSpecialMembers |= SMKind; 582249423Sdim else 583249423Sdim data().DeclaredNonTrivialSpecialMembers |= SMKind; 584249423Sdim 585249423Sdim // Note when we have declared a declared special member, and suppress the 586249423Sdim // implicit declaration of this special member. 587249423Sdim data().DeclaredSpecialMembers |= SMKind; 588249423Sdim 589249423Sdim if (!Method->isImplicit()) { 590249423Sdim data().UserDeclaredSpecialMembers |= SMKind; 591249423Sdim 592249423Sdim // C++03 [class]p4: 593249423Sdim // A POD-struct is an aggregate class that has [...] no user-defined 594249423Sdim // copy assignment operator and no user-defined destructor. 595249423Sdim // 596249423Sdim // Since the POD bit is meant to be C++03 POD-ness, and in C++03, 597249423Sdim // aggregates could not have any constructors, clear it even for an 598249423Sdim // explicitly defaulted or deleted constructor. 599249423Sdim // type is technically an aggregate in C++0x since it wouldn't be in 03. 600249423Sdim // 601249423Sdim // Also, a user-declared move assignment operator makes a class non-POD. 602249423Sdim // This is an extension in C++03. 603249423Sdim data().PlainOldData = false; 604249423Sdim } 605249423Sdim } 606249423Sdim 607193326Sed return; 608218893Sdim } 609249423Sdim 610218893Sdim // Handle non-static data members. 611218893Sdim if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) { 612226633Sdim // C++ [class.bit]p2: 613226633Sdim // A declaration for a bit-field that omits the identifier declares an 614226633Sdim // unnamed bit-field. Unnamed bit-fields are not members and cannot be 615226633Sdim // initialized. 616226633Sdim if (Field->isUnnamedBitfield()) 617226633Sdim return; 618226633Sdim 619218893Sdim // C++ [dcl.init.aggr]p1: 620218893Sdim // An aggregate is an array or a class (clause 9) with [...] no 621218893Sdim // private or protected non-static data members (clause 11). 622218893Sdim // 623218893Sdim // A POD must be an aggregate. 624218893Sdim if (D->getAccess() == AS_private || D->getAccess() == AS_protected) { 625218893Sdim data().Aggregate = false; 626218893Sdim data().PlainOldData = false; 627218893Sdim } 628221345Sdim 629221345Sdim // C++0x [class]p7: 630221345Sdim // A standard-layout class is a class that: 631221345Sdim // [...] 632221345Sdim // -- has the same access control for all non-static data members, 633221345Sdim switch (D->getAccess()) { 634221345Sdim case AS_private: data().HasPrivateFields = true; break; 635221345Sdim case AS_protected: data().HasProtectedFields = true; break; 636221345Sdim case AS_public: data().HasPublicFields = true; break; 637226633Sdim case AS_none: llvm_unreachable("Invalid access specifier"); 638221345Sdim }; 639221345Sdim if ((data().HasPrivateFields + data().HasProtectedFields + 640221345Sdim data().HasPublicFields) > 1) 641221345Sdim data().IsStandardLayout = false; 642221345Sdim 643223017Sdim // Keep track of the presence of mutable fields. 644223017Sdim if (Field->isMutable()) 645223017Sdim data().HasMutableFields = true; 646223017Sdim 647221345Sdim // C++0x [class]p9: 648218893Sdim // A POD struct is a class that is both a trivial class and a 649218893Sdim // standard-layout class, and has no non-static data members of type 650218893Sdim // non-POD struct, non-POD union (or array of such types). 651224145Sdim // 652224145Sdim // Automatic Reference Counting: the presence of a member of Objective-C pointer type 653224145Sdim // that does not explicitly have no lifetime makes the class a non-POD. 654224145Sdim // However, we delay setting PlainOldData to false in this case so that 655224145Sdim // Sema has a chance to diagnostic causes where the same class will be 656239462Sdim // non-POD with Automatic Reference Counting but a POD without ARC. 657224145Sdim // In this case, the class will become a non-POD class when we complete 658224145Sdim // the definition. 659218893Sdim ASTContext &Context = getASTContext(); 660218893Sdim QualType T = Context.getBaseElementType(Field->getType()); 661224145Sdim if (T->isObjCRetainableType() || T.isObjCGCStrong()) { 662234353Sdim if (!Context.getLangOpts().ObjCAutoRefCount || 663224145Sdim T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) 664224145Sdim setHasObjectMember(true); 665224145Sdim } else if (!T.isPODType(Context)) 666218893Sdim data().PlainOldData = false; 667224145Sdim 668221345Sdim if (T->isReferenceType()) { 669249423Sdim if (!Field->hasInClassInitializer()) 670249423Sdim data().HasUninitializedReferenceMember = true; 671221345Sdim 672221345Sdim // C++0x [class]p7: 673221345Sdim // A standard-layout class is a class that: 674221345Sdim // -- has no non-static data members of type [...] reference, 675221345Sdim data().IsStandardLayout = false; 676221345Sdim } 677221345Sdim 678234353Sdim // Record if this field is the first non-literal or volatile field or base. 679251662Sdim if (!T->isLiteralType(Context) || T.isVolatileQualified()) 680221345Sdim data().HasNonLiteralTypeFieldsOrBases = true; 681221345Sdim 682223017Sdim if (Field->hasInClassInitializer()) { 683239462Sdim data().HasInClassInitializer = true; 684239462Sdim 685239462Sdim // C++11 [class]p5: 686223017Sdim // A default constructor is trivial if [...] no non-static data member 687223017Sdim // of its class has a brace-or-equal-initializer. 688249423Sdim data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 689223017Sdim 690239462Sdim // C++11 [dcl.init.aggr]p1: 691223017Sdim // An aggregate is a [...] class with [...] no 692223017Sdim // brace-or-equal-initializers for non-static data members. 693251662Sdim // 694251662Sdim // This rule was removed in C++1y. 695251662Sdim if (!getASTContext().getLangOpts().CPlusPlus1y) 696251662Sdim data().Aggregate = false; 697223017Sdim 698239462Sdim // C++11 [class]p10: 699223017Sdim // A POD struct is [...] a trivial class. 700223017Sdim data().PlainOldData = false; 701223017Sdim } 702223017Sdim 703249423Sdim // C++11 [class.copy]p23: 704249423Sdim // A defaulted copy/move assignment operator for a class X is defined 705249423Sdim // as deleted if X has: 706249423Sdim // -- a non-static data member of reference type 707249423Sdim if (T->isReferenceType()) 708249423Sdim data().DefaultedMoveAssignmentIsDeleted = true; 709249423Sdim 710218893Sdim if (const RecordType *RecordTy = T->getAs<RecordType>()) { 711218893Sdim CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl()); 712218893Sdim if (FieldRec->getDefinition()) { 713249423Sdim addedClassSubobject(FieldRec); 714249423Sdim 715249423Sdim // C++11 [class.ctor]p5, C++11 [class.copy]p11: 716249423Sdim // A defaulted [special member] for a class X is defined as 717249423Sdim // deleted if: 718249423Sdim // -- X is a union-like class that has a variant member with a 719249423Sdim // non-trivial [corresponding special member] 720249423Sdim if (isUnion()) { 721249423Sdim if (FieldRec->hasNonTrivialMoveConstructor()) 722249423Sdim data().DefaultedMoveConstructorIsDeleted = true; 723249423Sdim if (FieldRec->hasNonTrivialMoveAssignment()) 724249423Sdim data().DefaultedMoveAssignmentIsDeleted = true; 725249423Sdim if (FieldRec->hasNonTrivialDestructor()) 726249423Sdim data().DefaultedDestructorIsDeleted = true; 727249423Sdim } 728249423Sdim 729223017Sdim // C++0x [class.ctor]p5: 730234353Sdim // A default constructor is trivial [...] if: 731223017Sdim // -- for all the non-static data members of its class that are of 732223017Sdim // class type (or array thereof), each such class has a trivial 733223017Sdim // default constructor. 734223017Sdim if (!FieldRec->hasTrivialDefaultConstructor()) 735249423Sdim data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 736221345Sdim 737221345Sdim // C++0x [class.copy]p13: 738221345Sdim // A copy/move constructor for class X is trivial if [...] 739221345Sdim // [...] 740221345Sdim // -- for each non-static data member of X that is of class type (or 741221345Sdim // an array thereof), the constructor selected to copy/move that 742221345Sdim // member is trivial; 743218893Sdim if (!FieldRec->hasTrivialCopyConstructor()) 744249423Sdim data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor; 745249423Sdim // If the field doesn't have a simple move constructor, we'll eagerly 746249423Sdim // declare the move constructor for this class and we'll decide whether 747249423Sdim // it's trivial then. 748249423Sdim if (!FieldRec->hasTrivialMoveConstructor()) 749249423Sdim data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor; 750221345Sdim 751221345Sdim // C++0x [class.copy]p27: 752221345Sdim // A copy/move assignment operator for class X is trivial if [...] 753221345Sdim // [...] 754221345Sdim // -- for each non-static data member of X that is of class type (or 755221345Sdim // an array thereof), the assignment operator selected to 756221345Sdim // copy/move that member is trivial; 757218893Sdim if (!FieldRec->hasTrivialCopyAssignment()) 758249423Sdim data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment; 759249423Sdim // If the field doesn't have a simple move assignment, we'll eagerly 760249423Sdim // declare the move assignment for this class and we'll decide whether 761249423Sdim // it's trivial then. 762249423Sdim if (!FieldRec->hasTrivialMoveAssignment()) 763249423Sdim data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment; 764221345Sdim 765218893Sdim if (!FieldRec->hasTrivialDestructor()) 766249423Sdim data().HasTrivialSpecialMembers &= ~SMF_Destructor; 767234353Sdim if (!FieldRec->hasIrrelevantDestructor()) 768234353Sdim data().HasIrrelevantDestructor = false; 769224145Sdim if (FieldRec->hasObjectMember()) 770224145Sdim setHasObjectMember(true); 771249423Sdim if (FieldRec->hasVolatileMember()) 772249423Sdim setHasVolatileMember(true); 773221345Sdim 774221345Sdim // C++0x [class]p7: 775221345Sdim // A standard-layout class is a class that: 776221345Sdim // -- has no non-static data members of type non-standard-layout 777221345Sdim // class (or array of such types) [...] 778221345Sdim if (!FieldRec->isStandardLayout()) 779221345Sdim data().IsStandardLayout = false; 780221345Sdim 781221345Sdim // C++0x [class]p7: 782221345Sdim // A standard-layout class is a class that: 783221345Sdim // [...] 784221345Sdim // -- has no base classes of the same type as the first non-static 785221345Sdim // data member. 786221345Sdim // We don't want to expend bits in the state of the record decl 787221345Sdim // tracking whether this is the first non-static data member so we 788221345Sdim // cheat a bit and use some of the existing state: the empty bit. 789221345Sdim // Virtual bases and virtual methods make a class non-empty, but they 790221345Sdim // also make it non-standard-layout so we needn't check here. 791221345Sdim // A non-empty base class may leave the class standard-layout, but not 792221345Sdim // if we have arrived here, and have at least on non-static data 793221345Sdim // member. If IsStandardLayout remains true, then the first non-static 794221345Sdim // data member must come through here with Empty still true, and Empty 795221345Sdim // will subsequently be set to false below. 796221345Sdim if (data().IsStandardLayout && data().Empty) { 797221345Sdim for (CXXRecordDecl::base_class_const_iterator BI = bases_begin(), 798221345Sdim BE = bases_end(); 799221345Sdim BI != BE; ++BI) { 800221345Sdim if (Context.hasSameUnqualifiedType(BI->getType(), T)) { 801221345Sdim data().IsStandardLayout = false; 802221345Sdim break; 803221345Sdim } 804221345Sdim } 805221345Sdim } 806223017Sdim 807223017Sdim // Keep track of the presence of mutable fields. 808223017Sdim if (FieldRec->hasMutableFields()) 809223017Sdim data().HasMutableFields = true; 810234353Sdim 811234353Sdim // C++11 [class.copy]p13: 812234353Sdim // If the implicitly-defined constructor would satisfy the 813234353Sdim // requirements of a constexpr constructor, the implicitly-defined 814234353Sdim // constructor is constexpr. 815234353Sdim // C++11 [dcl.constexpr]p4: 816234353Sdim // -- every constructor involved in initializing non-static data 817234353Sdim // members [...] shall be a constexpr constructor 818234353Sdim if (!Field->hasInClassInitializer() && 819239462Sdim !FieldRec->hasConstexprDefaultConstructor() && !isUnion()) 820234353Sdim // The standard requires any in-class initializer to be a constant 821234353Sdim // expression. We consider this to be a defect. 822234353Sdim data().DefaultedDefaultConstructorIsConstexpr = false; 823249423Sdim 824249423Sdim // C++11 [class.copy]p8: 825249423Sdim // The implicitly-declared copy constructor for a class X will have 826249423Sdim // the form 'X::X(const X&)' if [...] for all the non-static data 827249423Sdim // members of X that are of a class type M (or array thereof), each 828249423Sdim // such class type has a copy constructor whose first parameter is 829249423Sdim // of type 'const M&' or 'const volatile M&'. 830249423Sdim if (!FieldRec->hasCopyConstructorWithConstParam()) 831249423Sdim data().ImplicitCopyConstructorHasConstParam = false; 832249423Sdim 833249423Sdim // C++11 [class.copy]p18: 834249423Sdim // The implicitly-declared copy assignment oeprator for a class X will 835249423Sdim // have the form 'X& X::operator=(const X&)' if [...] for all the 836249423Sdim // non-static data members of X that are of a class type M (or array 837249423Sdim // thereof), each such class type has a copy assignment operator whose 838249423Sdim // parameter is of type 'const M&', 'const volatile M&' or 'M'. 839249423Sdim if (!FieldRec->hasCopyAssignmentWithConstParam()) 840249423Sdim data().ImplicitCopyAssignmentHasConstParam = false; 841249423Sdim 842249423Sdim if (FieldRec->hasUninitializedReferenceMember() && 843249423Sdim !Field->hasInClassInitializer()) 844249423Sdim data().HasUninitializedReferenceMember = true; 845218893Sdim } 846234353Sdim } else { 847234353Sdim // Base element type of field is a non-class type. 848251662Sdim if (!T->isLiteralType(Context) || 849239462Sdim (!Field->hasInClassInitializer() && !isUnion())) 850234353Sdim data().DefaultedDefaultConstructorIsConstexpr = false; 851249423Sdim 852249423Sdim // C++11 [class.copy]p23: 853249423Sdim // A defaulted copy/move assignment operator for a class X is defined 854249423Sdim // as deleted if X has: 855249423Sdim // -- a non-static data member of const non-class type (or array 856249423Sdim // thereof) 857249423Sdim if (T.isConstQualified()) 858249423Sdim data().DefaultedMoveAssignmentIsDeleted = true; 859218893Sdim } 860221345Sdim 861221345Sdim // C++0x [class]p7: 862221345Sdim // A standard-layout class is a class that: 863221345Sdim // [...] 864221345Sdim // -- either has no non-static data members in the most derived 865221345Sdim // class and at most one base class with non-static data members, 866221345Sdim // or has no base classes with non-static data members, and 867221345Sdim // At this point we know that we have a non-static data member, so the last 868221345Sdim // clause holds. 869221345Sdim if (!data().HasNoNonEmptyBases) 870221345Sdim data().IsStandardLayout = false; 871221345Sdim 872218893Sdim // If this is not a zero-length bit-field, then the class is not empty. 873218893Sdim if (data().Empty) { 874226633Sdim if (!Field->isBitField() || 875226633Sdim (!Field->getBitWidth()->isTypeDependent() && 876226633Sdim !Field->getBitWidth()->isValueDependent() && 877226633Sdim Field->getBitWidthValue(Context) != 0)) 878218893Sdim data().Empty = false; 879218893Sdim } 880218893Sdim } 881218893Sdim 882218893Sdim // Handle using declarations of conversion functions. 883218893Sdim if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) 884218893Sdim if (Shadow->getDeclName().getNameKind() 885218893Sdim == DeclarationName::CXXConversionFunctionName) 886249423Sdim data().Conversions.addDecl(getASTContext(), Shadow, Shadow->getAccess()); 887193326Sed} 888193326Sed 889249423Sdimvoid CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) { 890249423Sdim assert(!D->isImplicit() && !D->isUserProvided()); 891249423Sdim 892249423Sdim // The kind of special member this declaration is, if any. 893249423Sdim unsigned SMKind = 0; 894249423Sdim 895249423Sdim if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 896249423Sdim if (Constructor->isDefaultConstructor()) { 897249423Sdim SMKind |= SMF_DefaultConstructor; 898249423Sdim if (Constructor->isConstexpr()) 899249423Sdim data().HasConstexprDefaultConstructor = true; 900249423Sdim } 901249423Sdim if (Constructor->isCopyConstructor()) 902249423Sdim SMKind |= SMF_CopyConstructor; 903249423Sdim else if (Constructor->isMoveConstructor()) 904249423Sdim SMKind |= SMF_MoveConstructor; 905249423Sdim else if (Constructor->isConstexpr()) 906249423Sdim // We may now know that the constructor is constexpr. 907249423Sdim data().HasConstexprNonCopyMoveConstructor = true; 908249423Sdim } else if (isa<CXXDestructorDecl>(D)) 909249423Sdim SMKind |= SMF_Destructor; 910249423Sdim else if (D->isCopyAssignmentOperator()) 911249423Sdim SMKind |= SMF_CopyAssignment; 912249423Sdim else if (D->isMoveAssignmentOperator()) 913249423Sdim SMKind |= SMF_MoveAssignment; 914249423Sdim 915249423Sdim // Update which trivial / non-trivial special members we have. 916249423Sdim // addedMember will have skipped this step for this member. 917249423Sdim if (D->isTrivial()) 918249423Sdim data().HasTrivialSpecialMembers |= SMKind; 919249423Sdim else 920249423Sdim data().DeclaredNonTrivialSpecialMembers |= SMKind; 921249423Sdim} 922249423Sdim 923234353Sdimbool CXXRecordDecl::isCLike() const { 924243830Sdim if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface || 925243830Sdim !TemplateOrInstantiation.isNull()) 926234353Sdim return false; 927234353Sdim if (!hasDefinition()) 928234353Sdim return true; 929234353Sdim 930234353Sdim return isPOD() && data().HasOnlyCMembers; 931234353Sdim} 932234353Sdim 933234353Sdimvoid CXXRecordDecl::getCaptureFields( 934234353Sdim llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures, 935234353Sdim FieldDecl *&ThisCapture) const { 936234353Sdim Captures.clear(); 937234353Sdim ThisCapture = 0; 938234353Sdim 939234353Sdim LambdaDefinitionData &Lambda = getLambdaData(); 940234353Sdim RecordDecl::field_iterator Field = field_begin(); 941234353Sdim for (LambdaExpr::Capture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures; 942234353Sdim C != CEnd; ++C, ++Field) { 943234353Sdim if (C->capturesThis()) { 944234353Sdim ThisCapture = *Field; 945234353Sdim continue; 946234353Sdim } 947234353Sdim 948234353Sdim Captures[C->getCapturedVar()] = *Field; 949234353Sdim } 950234353Sdim} 951234353Sdim 952234353Sdim 953205219Srdivackystatic CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) { 954205219Srdivacky QualType T; 955206084Srdivacky if (isa<UsingShadowDecl>(Conv)) 956206084Srdivacky Conv = cast<UsingShadowDecl>(Conv)->getTargetDecl(); 957205219Srdivacky if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv)) 958205219Srdivacky T = ConvTemp->getTemplatedDecl()->getResultType(); 959205219Srdivacky else 960205219Srdivacky T = cast<CXXConversionDecl>(Conv)->getConversionType(); 961205219Srdivacky return Context.getCanonicalType(T); 962198092Srdivacky} 963198092Srdivacky 964205219Srdivacky/// Collect the visible conversions of a base class. 965205219Srdivacky/// 966239462Sdim/// \param Record a base class of the class we're considering 967205219Srdivacky/// \param InVirtual whether this base class is a virtual base (or a base 968205219Srdivacky/// of a virtual base) 969205219Srdivacky/// \param Access the access along the inheritance path to this base 970205219Srdivacky/// \param ParentHiddenTypes the conversions provided by the inheritors 971205219Srdivacky/// of this base 972205219Srdivacky/// \param Output the set to which to add conversions from non-virtual bases 973205219Srdivacky/// \param VOutput the set to which to add conversions from virtual bases 974205219Srdivacky/// \param HiddenVBaseCs the set of conversions which were hidden in a 975205219Srdivacky/// virtual base along some inheritance path 976205219Srdivackystatic void CollectVisibleConversions(ASTContext &Context, 977205219Srdivacky CXXRecordDecl *Record, 978205219Srdivacky bool InVirtual, 979205219Srdivacky AccessSpecifier Access, 980205219Srdivacky const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes, 981249423Sdim ASTUnresolvedSet &Output, 982205219Srdivacky UnresolvedSetImpl &VOutput, 983205219Srdivacky llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) { 984205219Srdivacky // The set of types which have conversions in this class or its 985205219Srdivacky // subclasses. As an optimization, we don't copy the derived set 986205219Srdivacky // unless it might change. 987205219Srdivacky const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes; 988205219Srdivacky llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer; 989205219Srdivacky 990205219Srdivacky // Collect the direct conversions and figure out which conversions 991205219Srdivacky // will be hidden in the subclasses. 992249423Sdim CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin(); 993249423Sdim CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end(); 994249423Sdim if (ConvI != ConvE) { 995205219Srdivacky HiddenTypesBuffer = ParentHiddenTypes; 996205219Srdivacky HiddenTypes = &HiddenTypesBuffer; 997205219Srdivacky 998249423Sdim for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) { 999239462Sdim CanQualType ConvType(GetConversionType(Context, I.getDecl())); 1000239462Sdim bool Hidden = ParentHiddenTypes.count(ConvType); 1001239462Sdim if (!Hidden) 1002239462Sdim HiddenTypesBuffer.insert(ConvType); 1003205219Srdivacky 1004205219Srdivacky // If this conversion is hidden and we're in a virtual base, 1005205219Srdivacky // remember that it's hidden along some inheritance path. 1006205219Srdivacky if (Hidden && InVirtual) 1007205219Srdivacky HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())); 1008205219Srdivacky 1009205219Srdivacky // If this conversion isn't hidden, add it to the appropriate output. 1010205219Srdivacky else if (!Hidden) { 1011205219Srdivacky AccessSpecifier IAccess 1012205219Srdivacky = CXXRecordDecl::MergeAccess(Access, I.getAccess()); 1013205219Srdivacky 1014205219Srdivacky if (InVirtual) 1015205219Srdivacky VOutput.addDecl(I.getDecl(), IAccess); 1016198092Srdivacky else 1017249423Sdim Output.addDecl(Context, I.getDecl(), IAccess); 1018198092Srdivacky } 1019198092Srdivacky } 1020198092Srdivacky } 1021198893Srdivacky 1022205219Srdivacky // Collect information recursively from any base classes. 1023205219Srdivacky for (CXXRecordDecl::base_class_iterator 1024205219Srdivacky I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) { 1025205219Srdivacky const RecordType *RT = I->getType()->getAs<RecordType>(); 1026205219Srdivacky if (!RT) continue; 1027198893Srdivacky 1028205219Srdivacky AccessSpecifier BaseAccess 1029205219Srdivacky = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier()); 1030205219Srdivacky bool BaseInVirtual = InVirtual || I->isVirtual(); 1031198893Srdivacky 1032205219Srdivacky CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl()); 1033205219Srdivacky CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess, 1034205219Srdivacky *HiddenTypes, Output, VOutput, HiddenVBaseCs); 1035198092Srdivacky } 1036205219Srdivacky} 1037198893Srdivacky 1038205219Srdivacky/// Collect the visible conversions of a class. 1039205219Srdivacky/// 1040205219Srdivacky/// This would be extremely straightforward if it weren't for virtual 1041205219Srdivacky/// bases. It might be worth special-casing that, really. 1042205219Srdivackystatic void CollectVisibleConversions(ASTContext &Context, 1043205219Srdivacky CXXRecordDecl *Record, 1044249423Sdim ASTUnresolvedSet &Output) { 1045205219Srdivacky // The collection of all conversions in virtual bases that we've 1046205219Srdivacky // found. These will be added to the output as long as they don't 1047205219Srdivacky // appear in the hidden-conversions set. 1048205219Srdivacky UnresolvedSet<8> VBaseCs; 1049205219Srdivacky 1050205219Srdivacky // The set of conversions in virtual bases that we've determined to 1051205219Srdivacky // be hidden. 1052205219Srdivacky llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs; 1053205219Srdivacky 1054205219Srdivacky // The set of types hidden by classes derived from this one. 1055205219Srdivacky llvm::SmallPtrSet<CanQualType, 8> HiddenTypes; 1056205219Srdivacky 1057205219Srdivacky // Go ahead and collect the direct conversions and add them to the 1058205219Srdivacky // hidden-types set. 1059249423Sdim CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin(); 1060249423Sdim CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end(); 1061249423Sdim Output.append(Context, ConvI, ConvE); 1062249423Sdim for (; ConvI != ConvE; ++ConvI) 1063249423Sdim HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl())); 1064205219Srdivacky 1065205219Srdivacky // Recursively collect conversions from base classes. 1066205219Srdivacky for (CXXRecordDecl::base_class_iterator 1067205219Srdivacky I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) { 1068205219Srdivacky const RecordType *RT = I->getType()->getAs<RecordType>(); 1069205219Srdivacky if (!RT) continue; 1070205219Srdivacky 1071205219Srdivacky CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()), 1072205219Srdivacky I->isVirtual(), I->getAccessSpecifier(), 1073205219Srdivacky HiddenTypes, Output, VBaseCs, HiddenVBaseCs); 1074198092Srdivacky } 1075205219Srdivacky 1076205219Srdivacky // Add any unhidden conversions provided by virtual bases. 1077205219Srdivacky for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end(); 1078205219Srdivacky I != E; ++I) { 1079205219Srdivacky if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()))) 1080249423Sdim Output.addDecl(Context, I.getDecl(), I.getAccess()); 1081205219Srdivacky } 1082198092Srdivacky} 1083198092Srdivacky 1084198092Srdivacky/// getVisibleConversionFunctions - get all conversion functions visible 1085198092Srdivacky/// in current class; including conversion function templates. 1086249423Sdimstd::pair<CXXRecordDecl::conversion_iterator,CXXRecordDecl::conversion_iterator> 1087249423SdimCXXRecordDecl::getVisibleConversionFunctions() { 1088198092Srdivacky // If root class, all conversions are visible. 1089198092Srdivacky if (bases_begin() == bases_end()) 1090249423Sdim return std::make_pair(data().Conversions.begin(), data().Conversions.end()); 1091198092Srdivacky // If visible conversion list is already evaluated, return it. 1092249423Sdim if (!data().ComputedVisibleConversions) { 1093249423Sdim CollectVisibleConversions(getASTContext(), this, data().VisibleConversions); 1094249423Sdim data().ComputedVisibleConversions = true; 1095249423Sdim } 1096249423Sdim return std::make_pair(data().VisibleConversions.begin(), 1097249423Sdim data().VisibleConversions.end()); 1098198092Srdivacky} 1099198092Srdivacky 1100206084Srdivackyvoid CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) { 1101206084Srdivacky // This operation is O(N) but extremely rare. Sema only uses it to 1102206084Srdivacky // remove UsingShadowDecls in a class that were followed by a direct 1103206084Srdivacky // declaration, e.g.: 1104206084Srdivacky // class A : B { 1105206084Srdivacky // using B::operator int; 1106206084Srdivacky // operator int(); 1107206084Srdivacky // }; 1108206084Srdivacky // This is uncommon by itself and even more uncommon in conjunction 1109206084Srdivacky // with sufficiently large numbers of directly-declared conversions 1110206084Srdivacky // that asymptotic behavior matters. 1111206084Srdivacky 1112249423Sdim ASTUnresolvedSet &Convs = data().Conversions; 1113206084Srdivacky for (unsigned I = 0, E = Convs.size(); I != E; ++I) { 1114206084Srdivacky if (Convs[I].getDecl() == ConvDecl) { 1115206084Srdivacky Convs.erase(I); 1116206084Srdivacky assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end() 1117206084Srdivacky && "conversion was found multiple times in unresolved set"); 1118206084Srdivacky return; 1119206084Srdivacky } 1120206084Srdivacky } 1121206084Srdivacky 1122206084Srdivacky llvm_unreachable("conversion not found in set!"); 1123198092Srdivacky} 1124194613Sed 1125198092SrdivackyCXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const { 1126198092Srdivacky if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 1127198092Srdivacky return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom()); 1128198092Srdivacky 1129198092Srdivacky return 0; 1130198092Srdivacky} 1131198092Srdivacky 1132198092Srdivackyvoid 1133198092SrdivackyCXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD, 1134198092Srdivacky TemplateSpecializationKind TSK) { 1135198092Srdivacky assert(TemplateOrInstantiation.isNull() && 1136198092Srdivacky "Previous template or instantiation?"); 1137198092Srdivacky assert(!isa<ClassTemplateSpecializationDecl>(this)); 1138198092Srdivacky TemplateOrInstantiation 1139198092Srdivacky = new (getASTContext()) MemberSpecializationInfo(RD, TSK); 1140198092Srdivacky} 1141198092Srdivacky 1142200583SrdivackyTemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{ 1143200583Srdivacky if (const ClassTemplateSpecializationDecl *Spec 1144198092Srdivacky = dyn_cast<ClassTemplateSpecializationDecl>(this)) 1145198092Srdivacky return Spec->getSpecializationKind(); 1146198092Srdivacky 1147198092Srdivacky if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 1148198092Srdivacky return MSInfo->getTemplateSpecializationKind(); 1149198092Srdivacky 1150198092Srdivacky return TSK_Undeclared; 1151198092Srdivacky} 1152198092Srdivacky 1153198092Srdivackyvoid 1154198092SrdivackyCXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) { 1155198092Srdivacky if (ClassTemplateSpecializationDecl *Spec 1156198092Srdivacky = dyn_cast<ClassTemplateSpecializationDecl>(this)) { 1157198092Srdivacky Spec->setSpecializationKind(TSK); 1158198092Srdivacky return; 1159198092Srdivacky } 1160198092Srdivacky 1161198092Srdivacky if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) { 1162198092Srdivacky MSInfo->setTemplateSpecializationKind(TSK); 1163198092Srdivacky return; 1164198092Srdivacky } 1165198092Srdivacky 1166226633Sdim llvm_unreachable("Not a class template or member class specialization"); 1167198092Srdivacky} 1168198092Srdivacky 1169210299SedCXXDestructorDecl *CXXRecordDecl::getDestructor() const { 1170210299Sed ASTContext &Context = getASTContext(); 1171193326Sed QualType ClassType = Context.getTypeDeclType(this); 1172193326Sed 1173198092Srdivacky DeclarationName Name 1174198092Srdivacky = Context.DeclarationNames.getCXXDestructorName( 1175198092Srdivacky Context.getCanonicalType(ClassType)); 1176198092Srdivacky 1177249423Sdim DeclContext::lookup_const_result R = lookup(Name); 1178249423Sdim if (R.empty()) 1179212904Sdim return 0; 1180198092Srdivacky 1181249423Sdim CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front()); 1182193326Sed return Dtor; 1183193326Sed} 1184193326Sed 1185218893Sdimvoid CXXRecordDecl::completeDefinition() { 1186218893Sdim completeDefinition(0); 1187218893Sdim} 1188218893Sdim 1189218893Sdimvoid CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) { 1190218893Sdim RecordDecl::completeDefinition(); 1191218893Sdim 1192234353Sdim if (hasObjectMember() && getASTContext().getLangOpts().ObjCAutoRefCount) { 1193224145Sdim // Objective-C Automatic Reference Counting: 1194224145Sdim // If a class has a non-static data member of Objective-C pointer 1195224145Sdim // type (or array thereof), it is a non-POD type and its 1196239462Sdim // default constructor (if any), copy constructor, move constructor, 1197239462Sdim // copy assignment operator, move assignment operator, and destructor are 1198239462Sdim // non-trivial. 1199224145Sdim struct DefinitionData &Data = data(); 1200224145Sdim Data.PlainOldData = false; 1201249423Sdim Data.HasTrivialSpecialMembers = 0; 1202234353Sdim Data.HasIrrelevantDestructor = false; 1203224145Sdim } 1204224145Sdim 1205218893Sdim // If the class may be abstract (but hasn't been marked as such), check for 1206218893Sdim // any pure final overriders. 1207218893Sdim if (mayBeAbstract()) { 1208218893Sdim CXXFinalOverriderMap MyFinalOverriders; 1209218893Sdim if (!FinalOverriders) { 1210218893Sdim getFinalOverriders(MyFinalOverriders); 1211218893Sdim FinalOverriders = &MyFinalOverriders; 1212218893Sdim } 1213218893Sdim 1214218893Sdim bool Done = false; 1215218893Sdim for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(), 1216218893Sdim MEnd = FinalOverriders->end(); 1217218893Sdim M != MEnd && !Done; ++M) { 1218218893Sdim for (OverridingMethods::iterator SO = M->second.begin(), 1219218893Sdim SOEnd = M->second.end(); 1220218893Sdim SO != SOEnd && !Done; ++SO) { 1221218893Sdim assert(SO->second.size() > 0 && 1222218893Sdim "All virtual functions have overridding virtual functions"); 1223218893Sdim 1224218893Sdim // C++ [class.abstract]p4: 1225218893Sdim // A class is abstract if it contains or inherits at least one 1226218893Sdim // pure virtual function for which the final overrider is pure 1227218893Sdim // virtual. 1228218893Sdim if (SO->second.front().Method->isPure()) { 1229218893Sdim data().Abstract = true; 1230218893Sdim Done = true; 1231218893Sdim break; 1232218893Sdim } 1233218893Sdim } 1234218893Sdim } 1235218893Sdim } 1236218893Sdim 1237218893Sdim // Set access bits correctly on the directly-declared conversions. 1238218893Sdim for (UnresolvedSetIterator I = data().Conversions.begin(), 1239218893Sdim E = data().Conversions.end(); 1240218893Sdim I != E; ++I) 1241249423Sdim I.setAccess((*I)->getAccess()); 1242218893Sdim} 1243218893Sdim 1244218893Sdimbool CXXRecordDecl::mayBeAbstract() const { 1245218893Sdim if (data().Abstract || isInvalidDecl() || !data().Polymorphic || 1246218893Sdim isDependentContext()) 1247218893Sdim return false; 1248218893Sdim 1249218893Sdim for (CXXRecordDecl::base_class_const_iterator B = bases_begin(), 1250218893Sdim BEnd = bases_end(); 1251218893Sdim B != BEnd; ++B) { 1252218893Sdim CXXRecordDecl *BaseDecl 1253218893Sdim = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl()); 1254218893Sdim if (BaseDecl->isAbstract()) 1255218893Sdim return true; 1256218893Sdim } 1257218893Sdim 1258218893Sdim return false; 1259218893Sdim} 1260218893Sdim 1261234353Sdimvoid CXXMethodDecl::anchor() { } 1262234353Sdim 1263249423Sdimbool CXXMethodDecl::isStatic() const { 1264251662Sdim const CXXMethodDecl *MD = getCanonicalDecl(); 1265249423Sdim 1266249423Sdim if (MD->getStorageClass() == SC_Static) 1267249423Sdim return true; 1268249423Sdim 1269249423Sdim DeclarationName Name = getDeclName(); 1270249423Sdim // [class.free]p1: 1271249423Sdim // Any allocation function for a class T is a static member 1272249423Sdim // (even if not explicitly declared static). 1273249423Sdim if (Name.getCXXOverloadedOperator() == OO_New || 1274249423Sdim Name.getCXXOverloadedOperator() == OO_Array_New) 1275249423Sdim return true; 1276249423Sdim 1277249423Sdim // [class.free]p6 Any deallocation function for a class X is a static member 1278249423Sdim // (even if not explicitly declared static). 1279249423Sdim if (Name.getCXXOverloadedOperator() == OO_Delete || 1280249423Sdim Name.getCXXOverloadedOperator() == OO_Array_Delete) 1281249423Sdim return true; 1282249423Sdim 1283249423Sdim return false; 1284249423Sdim} 1285249423Sdim 1286239462Sdimstatic bool recursivelyOverrides(const CXXMethodDecl *DerivedMD, 1287239462Sdim const CXXMethodDecl *BaseMD) { 1288239462Sdim for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(), 1289239462Sdim E = DerivedMD->end_overridden_methods(); I != E; ++I) { 1290239462Sdim const CXXMethodDecl *MD = *I; 1291239462Sdim if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl()) 1292239462Sdim return true; 1293239462Sdim if (recursivelyOverrides(MD, BaseMD)) 1294239462Sdim return true; 1295239462Sdim } 1296239462Sdim return false; 1297239462Sdim} 1298239462Sdim 1299193326SedCXXMethodDecl * 1300239462SdimCXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD, 1301239462Sdim bool MayBeBase) { 1302239462Sdim if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl()) 1303239462Sdim return this; 1304239462Sdim 1305239462Sdim // Lookup doesn't work for destructors, so handle them separately. 1306239462Sdim if (isa<CXXDestructorDecl>(this)) { 1307239462Sdim CXXMethodDecl *MD = RD->getDestructor(); 1308239462Sdim if (MD) { 1309239462Sdim if (recursivelyOverrides(MD, this)) 1310239462Sdim return MD; 1311239462Sdim if (MayBeBase && recursivelyOverrides(this, MD)) 1312239462Sdim return MD; 1313239462Sdim } 1314239462Sdim return NULL; 1315239462Sdim } 1316239462Sdim 1317239462Sdim lookup_const_result Candidates = RD->lookup(getDeclName()); 1318249423Sdim for (NamedDecl * const * I = Candidates.begin(); I != Candidates.end(); ++I) { 1319239462Sdim CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I); 1320239462Sdim if (!MD) 1321239462Sdim continue; 1322239462Sdim if (recursivelyOverrides(MD, this)) 1323239462Sdim return MD; 1324239462Sdim if (MayBeBase && recursivelyOverrides(this, MD)) 1325239462Sdim return MD; 1326239462Sdim } 1327239462Sdim 1328239462Sdim for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 1329239462Sdim E = RD->bases_end(); I != E; ++I) { 1330239462Sdim const RecordType *RT = I->getType()->getAs<RecordType>(); 1331239462Sdim if (!RT) 1332239462Sdim continue; 1333239462Sdim const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl()); 1334239462Sdim CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base); 1335239462Sdim if (T) 1336239462Sdim return T; 1337239462Sdim } 1338239462Sdim 1339239462Sdim return NULL; 1340239462Sdim} 1341239462Sdim 1342239462SdimCXXMethodDecl * 1343193326SedCXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD, 1344221345Sdim SourceLocation StartLoc, 1345212904Sdim const DeclarationNameInfo &NameInfo, 1346200583Srdivacky QualType T, TypeSourceInfo *TInfo, 1347249423Sdim StorageClass SC, bool isInline, 1348226633Sdim bool isConstexpr, SourceLocation EndLocation) { 1349221345Sdim return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo, 1350249423Sdim SC, isInline, isConstexpr, 1351226633Sdim EndLocation); 1352193326Sed} 1353193326Sed 1354234353SdimCXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1355234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXMethodDecl)); 1356234353Sdim return new (Mem) CXXMethodDecl(CXXMethod, 0, SourceLocation(), 1357234353Sdim DeclarationNameInfo(), QualType(), 1358249423Sdim 0, SC_None, false, false, 1359234353Sdim SourceLocation()); 1360234353Sdim} 1361234353Sdim 1362198092Srdivackybool CXXMethodDecl::isUsualDeallocationFunction() const { 1363198092Srdivacky if (getOverloadedOperator() != OO_Delete && 1364198092Srdivacky getOverloadedOperator() != OO_Array_Delete) 1365198092Srdivacky return false; 1366204643Srdivacky 1367198092Srdivacky // C++ [basic.stc.dynamic.deallocation]p2: 1368204643Srdivacky // A template instance is never a usual deallocation function, 1369204643Srdivacky // regardless of its signature. 1370204643Srdivacky if (getPrimaryTemplate()) 1371204643Srdivacky return false; 1372204643Srdivacky 1373204643Srdivacky // C++ [basic.stc.dynamic.deallocation]p2: 1374198092Srdivacky // If a class T has a member deallocation function named operator delete 1375198092Srdivacky // with exactly one parameter, then that function is a usual (non-placement) 1376198092Srdivacky // deallocation function. [...] 1377198092Srdivacky if (getNumParams() == 1) 1378198092Srdivacky return true; 1379198092Srdivacky 1380198092Srdivacky // C++ [basic.stc.dynamic.deallocation]p2: 1381198092Srdivacky // [...] If class T does not declare such an operator delete but does 1382198092Srdivacky // declare a member deallocation function named operator delete with 1383198092Srdivacky // exactly two parameters, the second of which has type std::size_t (18.1), 1384198092Srdivacky // then this function is a usual deallocation function. 1385198092Srdivacky ASTContext &Context = getASTContext(); 1386198092Srdivacky if (getNumParams() != 2 || 1387203955Srdivacky !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(), 1388203955Srdivacky Context.getSizeType())) 1389198092Srdivacky return false; 1390198092Srdivacky 1391198092Srdivacky // This function is a usual deallocation function if there are no 1392198092Srdivacky // single-parameter deallocation functions of the same kind. 1393249423Sdim DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName()); 1394249423Sdim for (DeclContext::lookup_const_result::iterator I = R.begin(), E = R.end(); 1395249423Sdim I != E; ++I) { 1396249423Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) 1397198092Srdivacky if (FD->getNumParams() == 1) 1398198092Srdivacky return false; 1399198092Srdivacky } 1400198092Srdivacky 1401198092Srdivacky return true; 1402198092Srdivacky} 1403193326Sed 1404207619Srdivackybool CXXMethodDecl::isCopyAssignmentOperator() const { 1405223017Sdim // C++0x [class.copy]p17: 1406207619Srdivacky // A user-declared copy assignment operator X::operator= is a non-static 1407207619Srdivacky // non-template member function of class X with exactly one parameter of 1408207619Srdivacky // type X, X&, const X&, volatile X& or const volatile X&. 1409207619Srdivacky if (/*operator=*/getOverloadedOperator() != OO_Equal || 1410207619Srdivacky /*non-static*/ isStatic() || 1411223017Sdim /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate()) 1412207619Srdivacky return false; 1413207619Srdivacky 1414207619Srdivacky QualType ParamType = getParamDecl(0)->getType(); 1415207619Srdivacky if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>()) 1416207619Srdivacky ParamType = Ref->getPointeeType(); 1417207619Srdivacky 1418207619Srdivacky ASTContext &Context = getASTContext(); 1419207619Srdivacky QualType ClassType 1420207619Srdivacky = Context.getCanonicalType(Context.getTypeDeclType(getParent())); 1421207619Srdivacky return Context.hasSameUnqualifiedType(ClassType, ParamType); 1422207619Srdivacky} 1423207619Srdivacky 1424223017Sdimbool CXXMethodDecl::isMoveAssignmentOperator() const { 1425223017Sdim // C++0x [class.copy]p19: 1426223017Sdim // A user-declared move assignment operator X::operator= is a non-static 1427223017Sdim // non-template member function of class X with exactly one parameter of type 1428223017Sdim // X&&, const X&&, volatile X&&, or const volatile X&&. 1429223017Sdim if (getOverloadedOperator() != OO_Equal || isStatic() || 1430223017Sdim getPrimaryTemplate() || getDescribedFunctionTemplate()) 1431223017Sdim return false; 1432223017Sdim 1433223017Sdim QualType ParamType = getParamDecl(0)->getType(); 1434223017Sdim if (!isa<RValueReferenceType>(ParamType)) 1435223017Sdim return false; 1436223017Sdim ParamType = ParamType->getPointeeType(); 1437223017Sdim 1438223017Sdim ASTContext &Context = getASTContext(); 1439223017Sdim QualType ClassType 1440223017Sdim = Context.getCanonicalType(Context.getTypeDeclType(getParent())); 1441223017Sdim return Context.hasSameUnqualifiedType(ClassType, ParamType); 1442223017Sdim} 1443223017Sdim 1444193326Sedvoid CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) { 1445200583Srdivacky assert(MD->isCanonicalDecl() && "Method is not canonical!"); 1446203955Srdivacky assert(!MD->getParent()->isDependentContext() && 1447203955Srdivacky "Can't add an overridden method to a class template!"); 1448234353Sdim assert(MD->isVirtual() && "Method is not virtual!"); 1449203955Srdivacky 1450204643Srdivacky getASTContext().addOverriddenMethod(this, MD); 1451193326Sed} 1452193326Sed 1453193326SedCXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const { 1454234353Sdim if (isa<CXXConstructorDecl>(this)) return 0; 1455204643Srdivacky return getASTContext().overridden_methods_begin(this); 1456193326Sed} 1457193326Sed 1458193326SedCXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const { 1459234353Sdim if (isa<CXXConstructorDecl>(this)) return 0; 1460204643Srdivacky return getASTContext().overridden_methods_end(this); 1461193326Sed} 1462193326Sed 1463210299Sedunsigned CXXMethodDecl::size_overridden_methods() const { 1464234353Sdim if (isa<CXXConstructorDecl>(this)) return 0; 1465210299Sed return getASTContext().overridden_methods_size(this); 1466210299Sed} 1467210299Sed 1468193326SedQualType CXXMethodDecl::getThisType(ASTContext &C) const { 1469193326Sed // C++ 9.3.2p1: The type of this in a member function of a class X is X*. 1470193326Sed // If the member function is declared const, the type of this is const X*, 1471193326Sed // if the member function is declared volatile, the type of this is 1472193326Sed // volatile X*, and if the member function is declared const volatile, 1473193326Sed // the type of this is const volatile X*. 1474193326Sed 1475193326Sed assert(isInstance() && "No 'this' for static methods!"); 1476194179Sed 1477204962Srdivacky QualType ClassTy = C.getTypeDeclType(getParent()); 1478198092Srdivacky ClassTy = C.getQualifiedType(ClassTy, 1479198092Srdivacky Qualifiers::fromCVRMask(getTypeQualifiers())); 1480198092Srdivacky return C.getPointerType(ClassTy); 1481193326Sed} 1482193326Sed 1483200583Srdivackybool CXXMethodDecl::hasInlineBody() const { 1484202379Srdivacky // If this function is a template instantiation, look at the template from 1485202379Srdivacky // which it was instantiated. 1486202379Srdivacky const FunctionDecl *CheckFn = getTemplateInstantiationPattern(); 1487202379Srdivacky if (!CheckFn) 1488202379Srdivacky CheckFn = this; 1489202379Srdivacky 1490200583Srdivacky const FunctionDecl *fn; 1491210299Sed return CheckFn->hasBody(fn) && !fn->isOutOfLine(); 1492200583Srdivacky} 1493200583Srdivacky 1494234353Sdimbool CXXMethodDecl::isLambdaStaticInvoker() const { 1495234353Sdim return getParent()->isLambda() && 1496234353Sdim getIdentifier() && getIdentifier()->getName() == "__invoke"; 1497234353Sdim} 1498234353Sdim 1499234353Sdim 1500218893SdimCXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1501218893Sdim TypeSourceInfo *TInfo, bool IsVirtual, 1502218893Sdim SourceLocation L, Expr *Init, 1503218893Sdim SourceLocation R, 1504218893Sdim SourceLocation EllipsisLoc) 1505218893Sdim : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init), 1506234353Sdim LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual), 1507234353Sdim IsWritten(false), SourceOrderOrNumArrayIndices(0) 1508200583Srdivacky{ 1509193326Sed} 1510193326Sed 1511218893SdimCXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1512218893Sdim FieldDecl *Member, 1513218893Sdim SourceLocation MemberLoc, 1514218893Sdim SourceLocation L, Expr *Init, 1515218893Sdim SourceLocation R) 1516218893Sdim : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init), 1517234353Sdim LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false), 1518208600Srdivacky IsWritten(false), SourceOrderOrNumArrayIndices(0) 1519208600Srdivacky{ 1520208600Srdivacky} 1521208600Srdivacky 1522218893SdimCXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1523218893Sdim IndirectFieldDecl *Member, 1524218893Sdim SourceLocation MemberLoc, 1525218893Sdim SourceLocation L, Expr *Init, 1526218893Sdim SourceLocation R) 1527218893Sdim : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init), 1528234353Sdim LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false), 1529218893Sdim IsWritten(false), SourceOrderOrNumArrayIndices(0) 1530218893Sdim{ 1531218893Sdim} 1532218893Sdim 1533218893SdimCXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1534234353Sdim TypeSourceInfo *TInfo, 1535234353Sdim SourceLocation L, Expr *Init, 1536221345Sdim SourceLocation R) 1537234353Sdim : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init), 1538234353Sdim LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false), 1539221345Sdim IsWritten(false), SourceOrderOrNumArrayIndices(0) 1540221345Sdim{ 1541221345Sdim} 1542221345Sdim 1543221345SdimCXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1544218893Sdim FieldDecl *Member, 1545218893Sdim SourceLocation MemberLoc, 1546218893Sdim SourceLocation L, Expr *Init, 1547218893Sdim SourceLocation R, 1548218893Sdim VarDecl **Indices, 1549218893Sdim unsigned NumIndices) 1550218893Sdim : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init), 1551218893Sdim LParenLoc(L), RParenLoc(R), IsVirtual(false), 1552208600Srdivacky IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices) 1553200583Srdivacky{ 1554208600Srdivacky VarDecl **MyIndices = reinterpret_cast<VarDecl **> (this + 1); 1555208600Srdivacky memcpy(MyIndices, Indices, NumIndices * sizeof(VarDecl *)); 1556193326Sed} 1557193326Sed 1558218893SdimCXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context, 1559218893Sdim FieldDecl *Member, 1560218893Sdim SourceLocation MemberLoc, 1561218893Sdim SourceLocation L, Expr *Init, 1562218893Sdim SourceLocation R, 1563218893Sdim VarDecl **Indices, 1564218893Sdim unsigned NumIndices) { 1565218893Sdim void *Mem = Context.Allocate(sizeof(CXXCtorInitializer) + 1566208600Srdivacky sizeof(VarDecl *) * NumIndices, 1567218893Sdim llvm::alignOf<CXXCtorInitializer>()); 1568218893Sdim return new (Mem) CXXCtorInitializer(Context, Member, MemberLoc, L, Init, R, 1569218893Sdim Indices, NumIndices); 1570208600Srdivacky} 1571208600Srdivacky 1572218893SdimTypeLoc CXXCtorInitializer::getBaseClassLoc() const { 1573200583Srdivacky if (isBaseInitializer()) 1574218893Sdim return Initializee.get<TypeSourceInfo*>()->getTypeLoc(); 1575200583Srdivacky else 1576200583Srdivacky return TypeLoc(); 1577200583Srdivacky} 1578200583Srdivacky 1579218893Sdimconst Type *CXXCtorInitializer::getBaseClass() const { 1580200583Srdivacky if (isBaseInitializer()) 1581218893Sdim return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr(); 1582200583Srdivacky else 1583200583Srdivacky return 0; 1584200583Srdivacky} 1585200583Srdivacky 1586218893SdimSourceLocation CXXCtorInitializer::getSourceLocation() const { 1587234353Sdim if (isAnyMemberInitializer()) 1588200583Srdivacky return getMemberLocation(); 1589223017Sdim 1590223017Sdim if (isInClassMemberInitializer()) 1591223017Sdim return getAnyMember()->getLocation(); 1592200583Srdivacky 1593234353Sdim if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>()) 1594234353Sdim return TSInfo->getTypeLoc().getLocalSourceRange().getBegin(); 1595234353Sdim 1596234353Sdim return SourceLocation(); 1597200583Srdivacky} 1598200583Srdivacky 1599218893SdimSourceRange CXXCtorInitializer::getSourceRange() const { 1600223017Sdim if (isInClassMemberInitializer()) { 1601223017Sdim FieldDecl *D = getAnyMember(); 1602223017Sdim if (Expr *I = D->getInClassInitializer()) 1603223017Sdim return I->getSourceRange(); 1604223017Sdim return SourceRange(); 1605223017Sdim } 1606223017Sdim 1607200583Srdivacky return SourceRange(getSourceLocation(), getRParenLoc()); 1608200583Srdivacky} 1609200583Srdivacky 1610234353Sdimvoid CXXConstructorDecl::anchor() { } 1611234353Sdim 1612193326SedCXXConstructorDecl * 1613234353SdimCXXConstructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1614234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXConstructorDecl)); 1615234353Sdim return new (Mem) CXXConstructorDecl(0, SourceLocation(),DeclarationNameInfo(), 1616234353Sdim QualType(), 0, false, false, false,false); 1617208600Srdivacky} 1618208600Srdivacky 1619208600SrdivackyCXXConstructorDecl * 1620193326SedCXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 1621221345Sdim SourceLocation StartLoc, 1622212904Sdim const DeclarationNameInfo &NameInfo, 1623200583Srdivacky QualType T, TypeSourceInfo *TInfo, 1624226633Sdim bool isExplicit, bool isInline, 1625226633Sdim bool isImplicitlyDeclared, bool isConstexpr) { 1626212904Sdim assert(NameInfo.getName().getNameKind() 1627212904Sdim == DeclarationName::CXXConstructorName && 1628193326Sed "Name must refer to a constructor"); 1629221345Sdim return new (C) CXXConstructorDecl(RD, StartLoc, NameInfo, T, TInfo, 1630226633Sdim isExplicit, isInline, isImplicitlyDeclared, 1631226633Sdim isConstexpr); 1632193326Sed} 1633193326Sed 1634234353SdimCXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const { 1635234353Sdim assert(isDelegatingConstructor() && "Not a delegating constructor!"); 1636234353Sdim Expr *E = (*init_begin())->getInit()->IgnoreImplicit(); 1637234353Sdim if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E)) 1638234353Sdim return Construct->getConstructor(); 1639234353Sdim 1640234353Sdim return 0; 1641234353Sdim} 1642234353Sdim 1643193326Sedbool CXXConstructorDecl::isDefaultConstructor() const { 1644193326Sed // C++ [class.ctor]p5: 1645193326Sed // A default constructor for a class X is a constructor of class 1646193326Sed // X that can be called without an argument. 1647193326Sed return (getNumParams() == 0) || 1648198092Srdivacky (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg()); 1649193326Sed} 1650193326Sed 1651198092Srdivackybool 1652201361SrdivackyCXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const { 1653218893Sdim return isCopyOrMoveConstructor(TypeQuals) && 1654218893Sdim getParamDecl(0)->getType()->isLValueReferenceType(); 1655218893Sdim} 1656218893Sdim 1657218893Sdimbool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const { 1658218893Sdim return isCopyOrMoveConstructor(TypeQuals) && 1659218893Sdim getParamDecl(0)->getType()->isRValueReferenceType(); 1660218893Sdim} 1661218893Sdim 1662218893Sdim/// \brief Determine whether this is a copy or move constructor. 1663218893Sdimbool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const { 1664193326Sed // C++ [class.copy]p2: 1665193326Sed // A non-template constructor for class X is a copy constructor 1666193326Sed // if its first parameter is of type X&, const X&, volatile X& or 1667193326Sed // const volatile X&, and either there are no other parameters 1668193326Sed // or else all other parameters have default arguments (8.3.6). 1669218893Sdim // C++0x [class.copy]p3: 1670218893Sdim // A non-template constructor for class X is a move constructor if its 1671218893Sdim // first parameter is of type X&&, const X&&, volatile X&&, or 1672218893Sdim // const volatile X&&, and either there are no other parameters or else 1673218893Sdim // all other parameters have default arguments. 1674193326Sed if ((getNumParams() < 1) || 1675198092Srdivacky (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 1676198092Srdivacky (getPrimaryTemplate() != 0) || 1677198092Srdivacky (getDescribedFunctionTemplate() != 0)) 1678193326Sed return false; 1679218893Sdim 1680193326Sed const ParmVarDecl *Param = getParamDecl(0); 1681218893Sdim 1682218893Sdim // Do we have a reference type? 1683218893Sdim const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>(); 1684193326Sed if (!ParamRefType) 1685193326Sed return false; 1686218893Sdim 1687193326Sed // Is it a reference to our class type? 1688201361Srdivacky ASTContext &Context = getASTContext(); 1689201361Srdivacky 1690198092Srdivacky CanQualType PointeeType 1691193326Sed = Context.getCanonicalType(ParamRefType->getPointeeType()); 1692198092Srdivacky CanQualType ClassTy 1693198092Srdivacky = Context.getCanonicalType(Context.getTagDeclType(getParent())); 1694193326Sed if (PointeeType.getUnqualifiedType() != ClassTy) 1695193326Sed return false; 1696218893Sdim 1697198092Srdivacky // FIXME: other qualifiers? 1698218893Sdim 1699218893Sdim // We have a copy or move constructor. 1700193326Sed TypeQuals = PointeeType.getCVRQualifiers(); 1701218893Sdim return true; 1702193326Sed} 1703193326Sed 1704198092Srdivackybool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const { 1705193326Sed // C++ [class.conv.ctor]p1: 1706193326Sed // A constructor declared without the function-specifier explicit 1707193326Sed // that can be called with a single parameter specifies a 1708193326Sed // conversion from the type of its first parameter to the type of 1709193326Sed // its class. Such a constructor is called a converting 1710193326Sed // constructor. 1711198092Srdivacky if (isExplicit() && !AllowExplicit) 1712193326Sed return false; 1713193326Sed 1714198092Srdivacky return (getNumParams() == 0 && 1715198092Srdivacky getType()->getAs<FunctionProtoType>()->isVariadic()) || 1716193326Sed (getNumParams() == 1) || 1717239462Sdim (getNumParams() > 1 && 1718239462Sdim (getParamDecl(1)->hasDefaultArg() || 1719239462Sdim getParamDecl(1)->isParameterPack())); 1720193326Sed} 1721193326Sed 1722218893Sdimbool CXXConstructorDecl::isSpecializationCopyingObject() const { 1723199482Srdivacky if ((getNumParams() < 1) || 1724199482Srdivacky (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 1725199482Srdivacky (getPrimaryTemplate() == 0) || 1726199482Srdivacky (getDescribedFunctionTemplate() != 0)) 1727199482Srdivacky return false; 1728199482Srdivacky 1729199482Srdivacky const ParmVarDecl *Param = getParamDecl(0); 1730199482Srdivacky 1731199482Srdivacky ASTContext &Context = getASTContext(); 1732199482Srdivacky CanQualType ParamType = Context.getCanonicalType(Param->getType()); 1733199482Srdivacky 1734199482Srdivacky // Is it the same as our our class type? 1735199482Srdivacky CanQualType ClassTy 1736199482Srdivacky = Context.getCanonicalType(Context.getTagDeclType(getParent())); 1737199482Srdivacky if (ParamType.getUnqualifiedType() != ClassTy) 1738199482Srdivacky return false; 1739199482Srdivacky 1740199482Srdivacky return true; 1741199482Srdivacky} 1742199482Srdivacky 1743218893Sdimconst CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const { 1744218893Sdim // Hack: we store the inherited constructor in the overridden method table 1745234353Sdim method_iterator It = getASTContext().overridden_methods_begin(this); 1746234353Sdim if (It == getASTContext().overridden_methods_end(this)) 1747218893Sdim return 0; 1748218893Sdim 1749218893Sdim return cast<CXXConstructorDecl>(*It); 1750218893Sdim} 1751218893Sdim 1752218893Sdimvoid 1753218893SdimCXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl *BaseCtor){ 1754218893Sdim // Hack: we store the inherited constructor in the overridden method table 1755234353Sdim assert(getASTContext().overridden_methods_size(this) == 0 && 1756234353Sdim "Base ctor already set."); 1757234353Sdim getASTContext().addOverriddenMethod(this, BaseCtor); 1758218893Sdim} 1759218893Sdim 1760234353Sdimvoid CXXDestructorDecl::anchor() { } 1761234353Sdim 1762193326SedCXXDestructorDecl * 1763234353SdimCXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1764234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXDestructorDecl)); 1765234353Sdim return new (Mem) CXXDestructorDecl(0, SourceLocation(), DeclarationNameInfo(), 1766218893Sdim QualType(), 0, false, false); 1767208600Srdivacky} 1768208600Srdivacky 1769208600SrdivackyCXXDestructorDecl * 1770193326SedCXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 1771221345Sdim SourceLocation StartLoc, 1772212904Sdim const DeclarationNameInfo &NameInfo, 1773218893Sdim QualType T, TypeSourceInfo *TInfo, 1774226633Sdim bool isInline, bool isImplicitlyDeclared) { 1775212904Sdim assert(NameInfo.getName().getNameKind() 1776212904Sdim == DeclarationName::CXXDestructorName && 1777193326Sed "Name must refer to a destructor"); 1778221345Sdim return new (C) CXXDestructorDecl(RD, StartLoc, NameInfo, T, TInfo, isInline, 1779212904Sdim isImplicitlyDeclared); 1780193326Sed} 1781193326Sed 1782234353Sdimvoid CXXConversionDecl::anchor() { } 1783234353Sdim 1784193326SedCXXConversionDecl * 1785234353SdimCXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1786234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXConversionDecl)); 1787234353Sdim return new (Mem) CXXConversionDecl(0, SourceLocation(), DeclarationNameInfo(), 1788234353Sdim QualType(), 0, false, false, false, 1789234353Sdim SourceLocation()); 1790208600Srdivacky} 1791208600Srdivacky 1792208600SrdivackyCXXConversionDecl * 1793193326SedCXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD, 1794221345Sdim SourceLocation StartLoc, 1795212904Sdim const DeclarationNameInfo &NameInfo, 1796200583Srdivacky QualType T, TypeSourceInfo *TInfo, 1797221345Sdim bool isInline, bool isExplicit, 1798226633Sdim bool isConstexpr, SourceLocation EndLocation) { 1799212904Sdim assert(NameInfo.getName().getNameKind() 1800212904Sdim == DeclarationName::CXXConversionFunctionName && 1801193326Sed "Name must refer to a conversion function"); 1802221345Sdim return new (C) CXXConversionDecl(RD, StartLoc, NameInfo, T, TInfo, 1803226633Sdim isInline, isExplicit, isConstexpr, 1804226633Sdim EndLocation); 1805193326Sed} 1806193326Sed 1807234353Sdimbool CXXConversionDecl::isLambdaToBlockPointerConversion() const { 1808234353Sdim return isImplicit() && getParent()->isLambda() && 1809234353Sdim getConversionType()->isBlockPointerType(); 1810234353Sdim} 1811234353Sdim 1812234353Sdimvoid LinkageSpecDecl::anchor() { } 1813234353Sdim 1814193326SedLinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C, 1815198092Srdivacky DeclContext *DC, 1816221345Sdim SourceLocation ExternLoc, 1817221345Sdim SourceLocation LangLoc, 1818221345Sdim LanguageIDs Lang, 1819251662Sdim bool HasBraces) { 1820251662Sdim return new (C) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces); 1821193326Sed} 1822193326Sed 1823234353SdimLinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1824234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LinkageSpecDecl)); 1825234353Sdim return new (Mem) LinkageSpecDecl(0, SourceLocation(), SourceLocation(), 1826251662Sdim lang_c, false); 1827234353Sdim} 1828234353Sdim 1829234353Sdimvoid UsingDirectiveDecl::anchor() { } 1830234353Sdim 1831193326SedUsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC, 1832193326Sed SourceLocation L, 1833193326Sed SourceLocation NamespaceLoc, 1834219077Sdim NestedNameSpecifierLoc QualifierLoc, 1835193326Sed SourceLocation IdentLoc, 1836199990Srdivacky NamedDecl *Used, 1837193326Sed DeclContext *CommonAncestor) { 1838199990Srdivacky if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used)) 1839199990Srdivacky Used = NS->getOriginalNamespace(); 1840219077Sdim return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc, 1841219077Sdim IdentLoc, Used, CommonAncestor); 1842193326Sed} 1843193326Sed 1844234353SdimUsingDirectiveDecl * 1845234353SdimUsingDirectiveDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1846234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingDirectiveDecl)); 1847234353Sdim return new (Mem) UsingDirectiveDecl(0, SourceLocation(), SourceLocation(), 1848234353Sdim NestedNameSpecifierLoc(), 1849234353Sdim SourceLocation(), 0, 0); 1850234353Sdim} 1851234353Sdim 1852199990SrdivackyNamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() { 1853199990Srdivacky if (NamespaceAliasDecl *NA = 1854199990Srdivacky dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace)) 1855199990Srdivacky return NA->getNamespace(); 1856199990Srdivacky return cast_or_null<NamespaceDecl>(NominatedNamespace); 1857199990Srdivacky} 1858199990Srdivacky 1859234353Sdimvoid NamespaceDecl::anchor() { } 1860234353Sdim 1861234353SdimNamespaceDecl::NamespaceDecl(DeclContext *DC, bool Inline, 1862234353Sdim SourceLocation StartLoc, 1863234353Sdim SourceLocation IdLoc, IdentifierInfo *Id, 1864234353Sdim NamespaceDecl *PrevDecl) 1865234353Sdim : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace), 1866234353Sdim LocStart(StartLoc), RBraceLoc(), AnonOrFirstNamespaceAndInline(0, Inline) 1867234353Sdim{ 1868234353Sdim setPreviousDeclaration(PrevDecl); 1869234353Sdim 1870234353Sdim if (PrevDecl) 1871234353Sdim AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace()); 1872234353Sdim} 1873234353Sdim 1874234353SdimNamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC, 1875234353Sdim bool Inline, SourceLocation StartLoc, 1876234353Sdim SourceLocation IdLoc, IdentifierInfo *Id, 1877234353Sdim NamespaceDecl *PrevDecl) { 1878234353Sdim return new (C) NamespaceDecl(DC, Inline, StartLoc, IdLoc, Id, PrevDecl); 1879234353Sdim} 1880234353Sdim 1881234353SdimNamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1882234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NamespaceDecl)); 1883234353Sdim return new (Mem) NamespaceDecl(0, false, SourceLocation(), SourceLocation(), 1884234353Sdim 0, 0); 1885234353Sdim} 1886234353Sdim 1887234353Sdimvoid NamespaceAliasDecl::anchor() { } 1888234353Sdim 1889198092SrdivackyNamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC, 1890212904Sdim SourceLocation UsingLoc, 1891198092Srdivacky SourceLocation AliasLoc, 1892198092Srdivacky IdentifierInfo *Alias, 1893219077Sdim NestedNameSpecifierLoc QualifierLoc, 1894198092Srdivacky SourceLocation IdentLoc, 1895193326Sed NamedDecl *Namespace) { 1896199990Srdivacky if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace)) 1897199990Srdivacky Namespace = NS->getOriginalNamespace(); 1898219077Sdim return new (C) NamespaceAliasDecl(DC, UsingLoc, AliasLoc, Alias, 1899219077Sdim QualifierLoc, IdentLoc, Namespace); 1900193326Sed} 1901193326Sed 1902234353SdimNamespaceAliasDecl * 1903234353SdimNamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1904234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NamespaceAliasDecl)); 1905234353Sdim return new (Mem) NamespaceAliasDecl(0, SourceLocation(), SourceLocation(), 0, 1906234353Sdim NestedNameSpecifierLoc(), 1907234353Sdim SourceLocation(), 0); 1908234353Sdim} 1909234353Sdim 1910234353Sdimvoid UsingShadowDecl::anchor() { } 1911234353Sdim 1912234353SdimUsingShadowDecl * 1913234353SdimUsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1914234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingShadowDecl)); 1915234353Sdim return new (Mem) UsingShadowDecl(0, SourceLocation(), 0, 0); 1916234353Sdim} 1917234353Sdim 1918218893SdimUsingDecl *UsingShadowDecl::getUsingDecl() const { 1919218893Sdim const UsingShadowDecl *Shadow = this; 1920218893Sdim while (const UsingShadowDecl *NextShadow = 1921218893Sdim dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow)) 1922218893Sdim Shadow = NextShadow; 1923218893Sdim return cast<UsingDecl>(Shadow->UsingOrNextShadow); 1924218893Sdim} 1925218893Sdim 1926234353Sdimvoid UsingDecl::anchor() { } 1927234353Sdim 1928218893Sdimvoid UsingDecl::addShadowDecl(UsingShadowDecl *S) { 1929218893Sdim assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() && 1930218893Sdim "declaration already in set"); 1931218893Sdim assert(S->getUsingDecl() == this); 1932218893Sdim 1933234353Sdim if (FirstUsingShadow.getPointer()) 1934234353Sdim S->UsingOrNextShadow = FirstUsingShadow.getPointer(); 1935234353Sdim FirstUsingShadow.setPointer(S); 1936218893Sdim} 1937218893Sdim 1938218893Sdimvoid UsingDecl::removeShadowDecl(UsingShadowDecl *S) { 1939218893Sdim assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() && 1940218893Sdim "declaration not in set"); 1941218893Sdim assert(S->getUsingDecl() == this); 1942218893Sdim 1943218893Sdim // Remove S from the shadow decl chain. This is O(n) but hopefully rare. 1944218893Sdim 1945234353Sdim if (FirstUsingShadow.getPointer() == S) { 1946234353Sdim FirstUsingShadow.setPointer( 1947234353Sdim dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow)); 1948218893Sdim S->UsingOrNextShadow = this; 1949218893Sdim return; 1950218893Sdim } 1951218893Sdim 1952234353Sdim UsingShadowDecl *Prev = FirstUsingShadow.getPointer(); 1953218893Sdim while (Prev->UsingOrNextShadow != S) 1954218893Sdim Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow); 1955218893Sdim Prev->UsingOrNextShadow = S->UsingOrNextShadow; 1956218893Sdim S->UsingOrNextShadow = this; 1957218893Sdim} 1958218893Sdim 1959219077SdimUsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL, 1960219077Sdim NestedNameSpecifierLoc QualifierLoc, 1961212904Sdim const DeclarationNameInfo &NameInfo, 1962212904Sdim bool IsTypeNameArg) { 1963219077Sdim return new (C) UsingDecl(DC, UL, QualifierLoc, NameInfo, IsTypeNameArg); 1964194613Sed} 1965194613Sed 1966234353SdimUsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1967234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingDecl)); 1968234353Sdim return new (Mem) UsingDecl(0, SourceLocation(), NestedNameSpecifierLoc(), 1969234353Sdim DeclarationNameInfo(), false); 1970234353Sdim} 1971234353Sdim 1972234353Sdimvoid UnresolvedUsingValueDecl::anchor() { } 1973234353Sdim 1974199482SrdivackyUnresolvedUsingValueDecl * 1975199482SrdivackyUnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC, 1976199482Srdivacky SourceLocation UsingLoc, 1977219077Sdim NestedNameSpecifierLoc QualifierLoc, 1978212904Sdim const DeclarationNameInfo &NameInfo) { 1979199482Srdivacky return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc, 1980219077Sdim QualifierLoc, NameInfo); 1981198092Srdivacky} 1982198092Srdivacky 1983234353SdimUnresolvedUsingValueDecl * 1984234353SdimUnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1985234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UnresolvedUsingValueDecl)); 1986234353Sdim return new (Mem) UnresolvedUsingValueDecl(0, QualType(), SourceLocation(), 1987234353Sdim NestedNameSpecifierLoc(), 1988234353Sdim DeclarationNameInfo()); 1989234353Sdim} 1990234353Sdim 1991234353Sdimvoid UnresolvedUsingTypenameDecl::anchor() { } 1992234353Sdim 1993199482SrdivackyUnresolvedUsingTypenameDecl * 1994199482SrdivackyUnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC, 1995199482Srdivacky SourceLocation UsingLoc, 1996199482Srdivacky SourceLocation TypenameLoc, 1997219077Sdim NestedNameSpecifierLoc QualifierLoc, 1998199482Srdivacky SourceLocation TargetNameLoc, 1999199482Srdivacky DeclarationName TargetName) { 2000199482Srdivacky return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc, 2001219077Sdim QualifierLoc, TargetNameLoc, 2002199482Srdivacky TargetName.getAsIdentifierInfo()); 2003199482Srdivacky} 2004199482Srdivacky 2005234353SdimUnresolvedUsingTypenameDecl * 2006234353SdimUnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2007234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, 2008234353Sdim sizeof(UnresolvedUsingTypenameDecl)); 2009234353Sdim return new (Mem) UnresolvedUsingTypenameDecl(0, SourceLocation(), 2010234353Sdim SourceLocation(), 2011234353Sdim NestedNameSpecifierLoc(), 2012234353Sdim SourceLocation(), 2013234353Sdim 0); 2014234353Sdim} 2015234353Sdim 2016234353Sdimvoid StaticAssertDecl::anchor() { } 2017234353Sdim 2018193326SedStaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC, 2019221345Sdim SourceLocation StaticAssertLoc, 2020221345Sdim Expr *AssertExpr, 2021221345Sdim StringLiteral *Message, 2022239462Sdim SourceLocation RParenLoc, 2023239462Sdim bool Failed) { 2024221345Sdim return new (C) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message, 2025239462Sdim RParenLoc, Failed); 2026193326Sed} 2027193326Sed 2028234353SdimStaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C, 2029234353Sdim unsigned ID) { 2030234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(StaticAssertDecl)); 2031239462Sdim return new (Mem) StaticAssertDecl(0, SourceLocation(), 0, 0, 2032239462Sdim SourceLocation(), false); 2033234353Sdim} 2034234353Sdim 2035193326Sedstatic const char *getAccessName(AccessSpecifier AS) { 2036193326Sed switch (AS) { 2037193326Sed case AS_none: 2038226633Sdim llvm_unreachable("Invalid access specifier!"); 2039193326Sed case AS_public: 2040193326Sed return "public"; 2041193326Sed case AS_private: 2042193326Sed return "private"; 2043193326Sed case AS_protected: 2044193326Sed return "protected"; 2045193326Sed } 2046234353Sdim llvm_unreachable("Invalid access specifier!"); 2047193326Sed} 2048193326Sed 2049193326Sedconst DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, 2050193326Sed AccessSpecifier AS) { 2051193326Sed return DB << getAccessName(AS); 2052193326Sed} 2053234353Sdim 2054234353Sdimconst PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB, 2055234353Sdim AccessSpecifier AS) { 2056234353Sdim return DB << getAccessName(AS); 2057234353Sdim} 2058