DeclCXX.cpp revision 327952
1//===- DeclCXX.cpp - C++ Declaration AST Node Implementation --------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the C++ related Decl classes. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/DeclCXX.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/ASTLambda.h" 17#include "clang/AST/ASTMutationListener.h" 18#include "clang/AST/ASTUnresolvedSet.h" 19#include "clang/AST/CXXInheritance.h" 20#include "clang/AST/DeclBase.h" 21#include "clang/AST/DeclTemplate.h" 22#include "clang/AST/DeclarationName.h" 23#include "clang/AST/Expr.h" 24#include "clang/AST/ExprCXX.h" 25#include "clang/AST/LambdaCapture.h" 26#include "clang/AST/NestedNameSpecifier.h" 27#include "clang/AST/ODRHash.h" 28#include "clang/AST/Type.h" 29#include "clang/AST/TypeLoc.h" 30#include "clang/AST/UnresolvedSet.h" 31#include "clang/Basic/Diagnostic.h" 32#include "clang/Basic/IdentifierTable.h" 33#include "clang/Basic/LLVM.h" 34#include "clang/Basic/LangOptions.h" 35#include "clang/Basic/OperatorKinds.h" 36#include "clang/Basic/PartialDiagnostic.h" 37#include "clang/Basic/SourceLocation.h" 38#include "clang/Basic/Specifiers.h" 39#include "llvm/ADT/None.h" 40#include "llvm/ADT/SmallPtrSet.h" 41#include "llvm/ADT/SmallVector.h" 42#include "llvm/ADT/iterator_range.h" 43#include "llvm/Support/Casting.h" 44#include "llvm/Support/ErrorHandling.h" 45#include "llvm/Support/raw_ostream.h" 46#include <algorithm> 47#include <cassert> 48#include <cstddef> 49#include <cstdint> 50 51using namespace clang; 52 53//===----------------------------------------------------------------------===// 54// Decl Allocation/Deallocation Method Implementations 55//===----------------------------------------------------------------------===// 56 57void AccessSpecDecl::anchor() {} 58 59AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 60 return new (C, ID) AccessSpecDecl(EmptyShell()); 61} 62 63void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const { 64 ExternalASTSource *Source = C.getExternalSource(); 65 assert(Impl.Decls.isLazy() && "getFromExternalSource for non-lazy set"); 66 assert(Source && "getFromExternalSource with no external source"); 67 68 for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); ++I) 69 I.setDecl(cast<NamedDecl>(Source->GetExternalDecl( 70 reinterpret_cast<uintptr_t>(I.getDecl()) >> 2))); 71 Impl.Decls.setLazy(false); 72} 73 74CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D) 75 : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0), 76 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false), 77 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true), 78 HasPrivateFields(false), HasProtectedFields(false), 79 HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false), 80 HasOnlyCMembers(true), HasInClassInitializer(false), 81 HasUninitializedReferenceMember(false), HasUninitializedFields(false), 82 HasInheritedConstructor(false), HasInheritedAssignment(false), 83 NeedOverloadResolutionForCopyConstructor(false), 84 NeedOverloadResolutionForMoveConstructor(false), 85 NeedOverloadResolutionForMoveAssignment(false), 86 NeedOverloadResolutionForDestructor(false), 87 DefaultedCopyConstructorIsDeleted(false), 88 DefaultedMoveConstructorIsDeleted(false), 89 DefaultedMoveAssignmentIsDeleted(false), 90 DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All), 91 DeclaredNonTrivialSpecialMembers(0), HasIrrelevantDestructor(true), 92 HasConstexprNonCopyMoveConstructor(false), 93 HasDefaultedDefaultConstructor(false), 94 CanPassInRegisters(true), 95 DefaultedDefaultConstructorIsConstexpr(true), 96 HasConstexprDefaultConstructor(false), 97 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false), 98 UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0), 99 ImplicitCopyConstructorCanHaveConstParamForVBase(true), 100 ImplicitCopyConstructorCanHaveConstParamForNonVBase(true), 101 ImplicitCopyAssignmentHasConstParam(true), 102 HasDeclaredCopyConstructorWithConstParam(false), 103 HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false), 104 IsParsingBaseSpecifiers(false), HasODRHash(false), Definition(D) {} 105 106CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const { 107 return Bases.get(Definition->getASTContext().getExternalSource()); 108} 109 110CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const { 111 return VBases.get(Definition->getASTContext().getExternalSource()); 112} 113 114CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, 115 DeclContext *DC, SourceLocation StartLoc, 116 SourceLocation IdLoc, IdentifierInfo *Id, 117 CXXRecordDecl *PrevDecl) 118 : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl), 119 DefinitionData(PrevDecl ? PrevDecl->DefinitionData 120 : nullptr) {} 121 122CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK, 123 DeclContext *DC, SourceLocation StartLoc, 124 SourceLocation IdLoc, IdentifierInfo *Id, 125 CXXRecordDecl *PrevDecl, 126 bool DelayTypeCreation) { 127 CXXRecordDecl *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, 128 IdLoc, Id, PrevDecl); 129 R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 130 131 // FIXME: DelayTypeCreation seems like such a hack 132 if (!DelayTypeCreation) 133 C.getTypeDeclType(R, PrevDecl); 134 return R; 135} 136 137CXXRecordDecl * 138CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC, 139 TypeSourceInfo *Info, SourceLocation Loc, 140 bool Dependent, bool IsGeneric, 141 LambdaCaptureDefault CaptureDefault) { 142 CXXRecordDecl *R = 143 new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc, 144 nullptr, nullptr); 145 R->IsBeingDefined = true; 146 R->DefinitionData = 147 new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric, 148 CaptureDefault); 149 R->MayHaveOutOfDateDef = false; 150 R->setImplicit(true); 151 C.getTypeDeclType(R, /*PrevDecl=*/nullptr); 152 return R; 153} 154 155CXXRecordDecl * 156CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { 157 CXXRecordDecl *R = new (C, ID) CXXRecordDecl( 158 CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(), 159 nullptr, nullptr); 160 R->MayHaveOutOfDateDef = false; 161 return R; 162} 163 164void 165CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases, 166 unsigned NumBases) { 167 ASTContext &C = getASTContext(); 168 169 if (!data().Bases.isOffset() && data().NumBases > 0) 170 C.Deallocate(data().getBases()); 171 172 if (NumBases) { 173 if (!C.getLangOpts().CPlusPlus17) { 174 // C++ [dcl.init.aggr]p1: 175 // An aggregate is [...] a class with [...] no base classes [...]. 176 data().Aggregate = false; 177 } 178 179 // C++ [class]p4: 180 // A POD-struct is an aggregate class... 181 data().PlainOldData = false; 182 } 183 184 // The set of seen virtual base types. 185 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes; 186 187 // The virtual bases of this class. 188 SmallVector<const CXXBaseSpecifier *, 8> VBases; 189 190 data().Bases = new(C) CXXBaseSpecifier [NumBases]; 191 data().NumBases = NumBases; 192 for (unsigned i = 0; i < NumBases; ++i) { 193 data().getBases()[i] = *Bases[i]; 194 // Keep track of inherited vbases for this base class. 195 const CXXBaseSpecifier *Base = Bases[i]; 196 QualType BaseType = Base->getType(); 197 // Skip dependent types; we can't do any checking on them now. 198 if (BaseType->isDependentType()) 199 continue; 200 CXXRecordDecl *BaseClassDecl 201 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 202 203 if (!BaseClassDecl->isEmpty()) { 204 if (!data().Empty) { 205 // C++0x [class]p7: 206 // A standard-layout class is a class that: 207 // [...] 208 // -- either has no non-static data members in the most derived 209 // class and at most one base class with non-static data members, 210 // or has no base classes with non-static data members, and 211 // If this is the second non-empty base, then neither of these two 212 // clauses can be true. 213 data().IsStandardLayout = false; 214 } 215 216 // C++14 [meta.unary.prop]p4: 217 // T is a class type [...] with [...] no base class B for which 218 // is_empty<B>::value is false. 219 data().Empty = false; 220 data().HasNoNonEmptyBases = false; 221 } 222 223 // C++1z [dcl.init.agg]p1: 224 // An aggregate is a class with [...] no private or protected base classes 225 if (Base->getAccessSpecifier() != AS_public) 226 data().Aggregate = false; 227 228 // C++ [class.virtual]p1: 229 // A class that declares or inherits a virtual function is called a 230 // polymorphic class. 231 if (BaseClassDecl->isPolymorphic()) 232 data().Polymorphic = true; 233 234 // C++0x [class]p7: 235 // A standard-layout class is a class that: [...] 236 // -- has no non-standard-layout base classes 237 if (!BaseClassDecl->isStandardLayout()) 238 data().IsStandardLayout = false; 239 240 // Record if this base is the first non-literal field or base. 241 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C)) 242 data().HasNonLiteralTypeFieldsOrBases = true; 243 244 // Now go through all virtual bases of this base and add them. 245 for (const auto &VBase : BaseClassDecl->vbases()) { 246 // Add this base if it's not already in the list. 247 if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) { 248 VBases.push_back(&VBase); 249 250 // C++11 [class.copy]p8: 251 // The implicitly-declared copy constructor for a class X will have 252 // the form 'X::X(const X&)' if each [...] virtual base class B of X 253 // has a copy constructor whose first parameter is of type 254 // 'const B&' or 'const volatile B&' [...] 255 if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl()) 256 if (!VBaseDecl->hasCopyConstructorWithConstParam()) 257 data().ImplicitCopyConstructorCanHaveConstParamForVBase = false; 258 259 // C++1z [dcl.init.agg]p1: 260 // An aggregate is a class with [...] no virtual base classes 261 data().Aggregate = false; 262 } 263 } 264 265 if (Base->isVirtual()) { 266 // Add this base if it's not already in the list. 267 if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second) 268 VBases.push_back(Base); 269 270 // C++14 [meta.unary.prop] is_empty: 271 // T is a class type, but not a union type, with ... no virtual base 272 // classes 273 data().Empty = false; 274 275 // C++1z [dcl.init.agg]p1: 276 // An aggregate is a class with [...] no virtual base classes 277 data().Aggregate = false; 278 279 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25: 280 // A [default constructor, copy/move constructor, or copy/move assignment 281 // operator for a class X] is trivial [...] if: 282 // -- class X has [...] no virtual base classes 283 data().HasTrivialSpecialMembers &= SMF_Destructor; 284 285 // C++0x [class]p7: 286 // A standard-layout class is a class that: [...] 287 // -- has [...] no virtual base classes 288 data().IsStandardLayout = false; 289 290 // C++11 [dcl.constexpr]p4: 291 // In the definition of a constexpr constructor [...] 292 // -- the class shall not have any virtual base classes 293 data().DefaultedDefaultConstructorIsConstexpr = false; 294 295 // C++1z [class.copy]p8: 296 // The implicitly-declared copy constructor for a class X will have 297 // the form 'X::X(const X&)' if each potentially constructed subobject 298 // has a copy constructor whose first parameter is of type 299 // 'const B&' or 'const volatile B&' [...] 300 if (!BaseClassDecl->hasCopyConstructorWithConstParam()) 301 data().ImplicitCopyConstructorCanHaveConstParamForVBase = false; 302 } else { 303 // C++ [class.ctor]p5: 304 // A default constructor is trivial [...] if: 305 // -- all the direct base classes of its class have trivial default 306 // constructors. 307 if (!BaseClassDecl->hasTrivialDefaultConstructor()) 308 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 309 310 // C++0x [class.copy]p13: 311 // A copy/move constructor for class X is trivial if [...] 312 // [...] 313 // -- the constructor selected to copy/move each direct base class 314 // subobject is trivial, and 315 if (!BaseClassDecl->hasTrivialCopyConstructor()) 316 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor; 317 // If the base class doesn't have a simple move constructor, we'll eagerly 318 // declare it and perform overload resolution to determine which function 319 // it actually calls. If it does have a simple move constructor, this 320 // check is correct. 321 if (!BaseClassDecl->hasTrivialMoveConstructor()) 322 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor; 323 324 // C++0x [class.copy]p27: 325 // A copy/move assignment operator for class X is trivial if [...] 326 // [...] 327 // -- the assignment operator selected to copy/move each direct base 328 // class subobject is trivial, and 329 if (!BaseClassDecl->hasTrivialCopyAssignment()) 330 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment; 331 // If the base class doesn't have a simple move assignment, we'll eagerly 332 // declare it and perform overload resolution to determine which function 333 // it actually calls. If it does have a simple move assignment, this 334 // check is correct. 335 if (!BaseClassDecl->hasTrivialMoveAssignment()) 336 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment; 337 338 // C++11 [class.ctor]p6: 339 // If that user-written default constructor would satisfy the 340 // requirements of a constexpr constructor, the implicitly-defined 341 // default constructor is constexpr. 342 if (!BaseClassDecl->hasConstexprDefaultConstructor()) 343 data().DefaultedDefaultConstructorIsConstexpr = false; 344 345 // C++1z [class.copy]p8: 346 // The implicitly-declared copy constructor for a class X will have 347 // the form 'X::X(const X&)' if each potentially constructed subobject 348 // has a copy constructor whose first parameter is of type 349 // 'const B&' or 'const volatile B&' [...] 350 if (!BaseClassDecl->hasCopyConstructorWithConstParam()) 351 data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false; 352 } 353 354 // C++ [class.ctor]p3: 355 // A destructor is trivial if all the direct base classes of its class 356 // have trivial destructors. 357 if (!BaseClassDecl->hasTrivialDestructor()) 358 data().HasTrivialSpecialMembers &= ~SMF_Destructor; 359 360 if (!BaseClassDecl->hasIrrelevantDestructor()) 361 data().HasIrrelevantDestructor = false; 362 363 // C++11 [class.copy]p18: 364 // The implicitly-declared copy assignment oeprator for a class X will 365 // have the form 'X& X::operator=(const X&)' if each direct base class B 366 // of X has a copy assignment operator whose parameter is of type 'const 367 // B&', 'const volatile B&', or 'B' [...] 368 if (!BaseClassDecl->hasCopyAssignmentWithConstParam()) 369 data().ImplicitCopyAssignmentHasConstParam = false; 370 371 // A class has an Objective-C object member if... or any of its bases 372 // has an Objective-C object member. 373 if (BaseClassDecl->hasObjectMember()) 374 setHasObjectMember(true); 375 376 if (BaseClassDecl->hasVolatileMember()) 377 setHasVolatileMember(true); 378 379 // Keep track of the presence of mutable fields. 380 if (BaseClassDecl->hasMutableFields()) { 381 data().HasMutableFields = true; 382 data().NeedOverloadResolutionForCopyConstructor = true; 383 } 384 385 if (BaseClassDecl->hasUninitializedReferenceMember()) 386 data().HasUninitializedReferenceMember = true; 387 388 if (!BaseClassDecl->allowConstDefaultInit()) 389 data().HasUninitializedFields = true; 390 391 addedClassSubobject(BaseClassDecl); 392 } 393 394 if (VBases.empty()) { 395 data().IsParsingBaseSpecifiers = false; 396 return; 397 } 398 399 // Create base specifier for any direct or indirect virtual bases. 400 data().VBases = new (C) CXXBaseSpecifier[VBases.size()]; 401 data().NumVBases = VBases.size(); 402 for (int I = 0, E = VBases.size(); I != E; ++I) { 403 QualType Type = VBases[I]->getType(); 404 if (!Type->isDependentType()) 405 addedClassSubobject(Type->getAsCXXRecordDecl()); 406 data().getVBases()[I] = *VBases[I]; 407 } 408 409 data().IsParsingBaseSpecifiers = false; 410} 411 412unsigned CXXRecordDecl::getODRHash() const { 413 assert(hasDefinition() && "ODRHash only for records with definitions"); 414 415 // Previously calculated hash is stored in DefinitionData. 416 if (DefinitionData->HasODRHash) 417 return DefinitionData->ODRHash; 418 419 // Only calculate hash on first call of getODRHash per record. 420 ODRHash Hash; 421 Hash.AddCXXRecordDecl(getDefinition()); 422 DefinitionData->HasODRHash = true; 423 DefinitionData->ODRHash = Hash.CalculateHash(); 424 425 return DefinitionData->ODRHash; 426} 427 428void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) { 429 // C++11 [class.copy]p11: 430 // A defaulted copy/move constructor for a class X is defined as 431 // deleted if X has: 432 // -- a direct or virtual base class B that cannot be copied/moved [...] 433 // -- a non-static data member of class type M (or array thereof) 434 // that cannot be copied or moved [...] 435 if (!Subobj->hasSimpleCopyConstructor()) 436 data().NeedOverloadResolutionForCopyConstructor = true; 437 if (!Subobj->hasSimpleMoveConstructor()) 438 data().NeedOverloadResolutionForMoveConstructor = true; 439 440 // C++11 [class.copy]p23: 441 // A defaulted copy/move assignment operator for a class X is defined as 442 // deleted if X has: 443 // -- a direct or virtual base class B that cannot be copied/moved [...] 444 // -- a non-static data member of class type M (or array thereof) 445 // that cannot be copied or moved [...] 446 if (!Subobj->hasSimpleMoveAssignment()) 447 data().NeedOverloadResolutionForMoveAssignment = true; 448 449 // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5: 450 // A defaulted [ctor or dtor] for a class X is defined as 451 // deleted if X has: 452 // -- any direct or virtual base class [...] has a type with a destructor 453 // that is deleted or inaccessible from the defaulted [ctor or dtor]. 454 // -- any non-static data member has a type with a destructor 455 // that is deleted or inaccessible from the defaulted [ctor or dtor]. 456 if (!Subobj->hasSimpleDestructor()) { 457 data().NeedOverloadResolutionForCopyConstructor = true; 458 data().NeedOverloadResolutionForMoveConstructor = true; 459 data().NeedOverloadResolutionForDestructor = true; 460 } 461} 462 463bool CXXRecordDecl::hasAnyDependentBases() const { 464 if (!isDependentContext()) 465 return false; 466 467 return !forallBases([](const CXXRecordDecl *) { return true; }); 468} 469 470bool CXXRecordDecl::isTriviallyCopyable() const { 471 // C++0x [class]p5: 472 // A trivially copyable class is a class that: 473 // -- has no non-trivial copy constructors, 474 if (hasNonTrivialCopyConstructor()) return false; 475 // -- has no non-trivial move constructors, 476 if (hasNonTrivialMoveConstructor()) return false; 477 // -- has no non-trivial copy assignment operators, 478 if (hasNonTrivialCopyAssignment()) return false; 479 // -- has no non-trivial move assignment operators, and 480 if (hasNonTrivialMoveAssignment()) return false; 481 // -- has a trivial destructor. 482 if (!hasTrivialDestructor()) return false; 483 484 return true; 485} 486 487void CXXRecordDecl::markedVirtualFunctionPure() { 488 // C++ [class.abstract]p2: 489 // A class is abstract if it has at least one pure virtual function. 490 data().Abstract = true; 491} 492 493void CXXRecordDecl::addedMember(Decl *D) { 494 if (!D->isImplicit() && 495 !isa<FieldDecl>(D) && 496 !isa<IndirectFieldDecl>(D) && 497 (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class || 498 cast<TagDecl>(D)->getTagKind() == TTK_Interface)) 499 data().HasOnlyCMembers = false; 500 501 // Ignore friends and invalid declarations. 502 if (D->getFriendObjectKind() || D->isInvalidDecl()) 503 return; 504 505 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D); 506 if (FunTmpl) 507 D = FunTmpl->getTemplatedDecl(); 508 509 // FIXME: Pass NamedDecl* to addedMember? 510 Decl *DUnderlying = D; 511 if (auto *ND = dyn_cast<NamedDecl>(DUnderlying)) { 512 DUnderlying = ND->getUnderlyingDecl(); 513 if (FunctionTemplateDecl *UnderlyingFunTmpl = 514 dyn_cast<FunctionTemplateDecl>(DUnderlying)) 515 DUnderlying = UnderlyingFunTmpl->getTemplatedDecl(); 516 } 517 518 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 519 if (Method->isVirtual()) { 520 // C++ [dcl.init.aggr]p1: 521 // An aggregate is an array or a class with [...] no virtual functions. 522 data().Aggregate = false; 523 524 // C++ [class]p4: 525 // A POD-struct is an aggregate class... 526 data().PlainOldData = false; 527 528 // C++14 [meta.unary.prop]p4: 529 // T is a class type [...] with [...] no virtual member functions... 530 data().Empty = false; 531 532 // C++ [class.virtual]p1: 533 // A class that declares or inherits a virtual function is called a 534 // polymorphic class. 535 data().Polymorphic = true; 536 537 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25: 538 // A [default constructor, copy/move constructor, or copy/move 539 // assignment operator for a class X] is trivial [...] if: 540 // -- class X has no virtual functions [...] 541 data().HasTrivialSpecialMembers &= SMF_Destructor; 542 543 // C++0x [class]p7: 544 // A standard-layout class is a class that: [...] 545 // -- has no virtual functions 546 data().IsStandardLayout = false; 547 } 548 } 549 550 // Notify the listener if an implicit member was added after the definition 551 // was completed. 552 if (!isBeingDefined() && D->isImplicit()) 553 if (ASTMutationListener *L = getASTMutationListener()) 554 L->AddedCXXImplicitMember(data().Definition, D); 555 556 // The kind of special member this declaration is, if any. 557 unsigned SMKind = 0; 558 559 // Handle constructors. 560 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 561 if (!Constructor->isImplicit()) { 562 // Note that we have a user-declared constructor. 563 data().UserDeclaredConstructor = true; 564 565 // C++ [class]p4: 566 // A POD-struct is an aggregate class [...] 567 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the 568 // type is technically an aggregate in C++0x since it wouldn't be in 03. 569 data().PlainOldData = false; 570 } 571 572 if (Constructor->isDefaultConstructor()) { 573 SMKind |= SMF_DefaultConstructor; 574 575 if (Constructor->isUserProvided()) 576 data().UserProvidedDefaultConstructor = true; 577 if (Constructor->isConstexpr()) 578 data().HasConstexprDefaultConstructor = true; 579 if (Constructor->isDefaulted()) 580 data().HasDefaultedDefaultConstructor = true; 581 } 582 583 if (!FunTmpl) { 584 unsigned Quals; 585 if (Constructor->isCopyConstructor(Quals)) { 586 SMKind |= SMF_CopyConstructor; 587 588 if (Quals & Qualifiers::Const) 589 data().HasDeclaredCopyConstructorWithConstParam = true; 590 } else if (Constructor->isMoveConstructor()) 591 SMKind |= SMF_MoveConstructor; 592 } 593 594 // C++11 [dcl.init.aggr]p1: DR1518 595 // An aggregate is an array or a class with no user-provided, explicit, or 596 // inherited constructors 597 if (Constructor->isUserProvided() || Constructor->isExplicit()) 598 data().Aggregate = false; 599 } 600 601 // Handle constructors, including those inherited from base classes. 602 if (CXXConstructorDecl *Constructor = 603 dyn_cast<CXXConstructorDecl>(DUnderlying)) { 604 // Record if we see any constexpr constructors which are neither copy 605 // nor move constructors. 606 // C++1z [basic.types]p10: 607 // [...] has at least one constexpr constructor or constructor template 608 // (possibly inherited from a base class) that is not a copy or move 609 // constructor [...] 610 if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor()) 611 data().HasConstexprNonCopyMoveConstructor = true; 612 } 613 614 // Handle destructors. 615 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) { 616 SMKind |= SMF_Destructor; 617 618 if (DD->isUserProvided()) 619 data().HasIrrelevantDestructor = false; 620 // If the destructor is explicitly defaulted and not trivial or not public 621 // or if the destructor is deleted, we clear HasIrrelevantDestructor in 622 // finishedDefaultedOrDeletedMember. 623 624 // C++11 [class.dtor]p5: 625 // A destructor is trivial if [...] the destructor is not virtual. 626 if (DD->isVirtual()) 627 data().HasTrivialSpecialMembers &= ~SMF_Destructor; 628 } 629 630 // Handle member functions. 631 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 632 if (Method->isCopyAssignmentOperator()) { 633 SMKind |= SMF_CopyAssignment; 634 635 const ReferenceType *ParamTy = 636 Method->getParamDecl(0)->getType()->getAs<ReferenceType>(); 637 if (!ParamTy || ParamTy->getPointeeType().isConstQualified()) 638 data().HasDeclaredCopyAssignmentWithConstParam = true; 639 } 640 641 if (Method->isMoveAssignmentOperator()) 642 SMKind |= SMF_MoveAssignment; 643 644 // Keep the list of conversion functions up-to-date. 645 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) { 646 // FIXME: We use the 'unsafe' accessor for the access specifier here, 647 // because Sema may not have set it yet. That's really just a misdesign 648 // in Sema. However, LLDB *will* have set the access specifier correctly, 649 // and adds declarations after the class is technically completed, 650 // so completeDefinition()'s overriding of the access specifiers doesn't 651 // work. 652 AccessSpecifier AS = Conversion->getAccessUnsafe(); 653 654 if (Conversion->getPrimaryTemplate()) { 655 // We don't record specializations. 656 } else { 657 ASTContext &Ctx = getASTContext(); 658 ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx); 659 NamedDecl *Primary = 660 FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion); 661 if (Primary->getPreviousDecl()) 662 Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()), 663 Primary, AS); 664 else 665 Conversions.addDecl(Ctx, Primary, AS); 666 } 667 } 668 669 if (SMKind) { 670 // If this is the first declaration of a special member, we no longer have 671 // an implicit trivial special member. 672 data().HasTrivialSpecialMembers &= 673 data().DeclaredSpecialMembers | ~SMKind; 674 675 if (!Method->isImplicit() && !Method->isUserProvided()) { 676 // This method is user-declared but not user-provided. We can't work out 677 // whether it's trivial yet (not until we get to the end of the class). 678 // We'll handle this method in finishedDefaultedOrDeletedMember. 679 } else if (Method->isTrivial()) 680 data().HasTrivialSpecialMembers |= SMKind; 681 else 682 data().DeclaredNonTrivialSpecialMembers |= SMKind; 683 684 // Note when we have declared a declared special member, and suppress the 685 // implicit declaration of this special member. 686 data().DeclaredSpecialMembers |= SMKind; 687 688 if (!Method->isImplicit()) { 689 data().UserDeclaredSpecialMembers |= SMKind; 690 691 // C++03 [class]p4: 692 // A POD-struct is an aggregate class that has [...] no user-defined 693 // copy assignment operator and no user-defined destructor. 694 // 695 // Since the POD bit is meant to be C++03 POD-ness, and in C++03, 696 // aggregates could not have any constructors, clear it even for an 697 // explicitly defaulted or deleted constructor. 698 // type is technically an aggregate in C++0x since it wouldn't be in 03. 699 // 700 // Also, a user-declared move assignment operator makes a class non-POD. 701 // This is an extension in C++03. 702 data().PlainOldData = false; 703 } 704 } 705 706 return; 707 } 708 709 // Handle non-static data members. 710 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) { 711 // C++ [class.bit]p2: 712 // A declaration for a bit-field that omits the identifier declares an 713 // unnamed bit-field. Unnamed bit-fields are not members and cannot be 714 // initialized. 715 if (Field->isUnnamedBitfield()) 716 return; 717 718 // C++ [dcl.init.aggr]p1: 719 // An aggregate is an array or a class (clause 9) with [...] no 720 // private or protected non-static data members (clause 11). 721 // 722 // A POD must be an aggregate. 723 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) { 724 data().Aggregate = false; 725 data().PlainOldData = false; 726 } 727 728 // C++0x [class]p7: 729 // A standard-layout class is a class that: 730 // [...] 731 // -- has the same access control for all non-static data members, 732 switch (D->getAccess()) { 733 case AS_private: data().HasPrivateFields = true; break; 734 case AS_protected: data().HasProtectedFields = true; break; 735 case AS_public: data().HasPublicFields = true; break; 736 case AS_none: llvm_unreachable("Invalid access specifier"); 737 }; 738 if ((data().HasPrivateFields + data().HasProtectedFields + 739 data().HasPublicFields) > 1) 740 data().IsStandardLayout = false; 741 742 // Keep track of the presence of mutable fields. 743 if (Field->isMutable()) { 744 data().HasMutableFields = true; 745 data().NeedOverloadResolutionForCopyConstructor = true; 746 } 747 748 // C++11 [class.union]p8, DR1460: 749 // If X is a union, a non-static data member of X that is not an anonymous 750 // union is a variant member of X. 751 if (isUnion() && !Field->isAnonymousStructOrUnion()) 752 data().HasVariantMembers = true; 753 754 // C++0x [class]p9: 755 // A POD struct is a class that is both a trivial class and a 756 // standard-layout class, and has no non-static data members of type 757 // non-POD struct, non-POD union (or array of such types). 758 // 759 // Automatic Reference Counting: the presence of a member of Objective-C pointer type 760 // that does not explicitly have no lifetime makes the class a non-POD. 761 ASTContext &Context = getASTContext(); 762 QualType T = Context.getBaseElementType(Field->getType()); 763 if (T->isObjCRetainableType() || T.isObjCGCStrong()) { 764 if (T.hasNonTrivialObjCLifetime()) { 765 // Objective-C Automatic Reference Counting: 766 // If a class has a non-static data member of Objective-C pointer 767 // type (or array thereof), it is a non-POD type and its 768 // default constructor (if any), copy constructor, move constructor, 769 // copy assignment operator, move assignment operator, and destructor are 770 // non-trivial. 771 setHasObjectMember(true); 772 struct DefinitionData &Data = data(); 773 Data.PlainOldData = false; 774 Data.HasTrivialSpecialMembers = 0; 775 Data.HasIrrelevantDestructor = false; 776 } else if (!Context.getLangOpts().ObjCAutoRefCount) { 777 setHasObjectMember(true); 778 } 779 } else if (!T.isCXX98PODType(Context)) 780 data().PlainOldData = false; 781 782 if (T->isReferenceType()) { 783 if (!Field->hasInClassInitializer()) 784 data().HasUninitializedReferenceMember = true; 785 786 // C++0x [class]p7: 787 // A standard-layout class is a class that: 788 // -- has no non-static data members of type [...] reference, 789 data().IsStandardLayout = false; 790 791 // C++1z [class.copy.ctor]p10: 792 // A defaulted copy constructor for a class X is defined as deleted if X has: 793 // -- a non-static data member of rvalue reference type 794 if (T->isRValueReferenceType()) 795 data().DefaultedCopyConstructorIsDeleted = true; 796 } 797 798 if (!Field->hasInClassInitializer() && !Field->isMutable()) { 799 if (CXXRecordDecl *FieldType = T->getAsCXXRecordDecl()) { 800 if (FieldType->hasDefinition() && !FieldType->allowConstDefaultInit()) 801 data().HasUninitializedFields = true; 802 } else { 803 data().HasUninitializedFields = true; 804 } 805 } 806 807 // Record if this field is the first non-literal or volatile field or base. 808 if (!T->isLiteralType(Context) || T.isVolatileQualified()) 809 data().HasNonLiteralTypeFieldsOrBases = true; 810 811 if (Field->hasInClassInitializer() || 812 (Field->isAnonymousStructOrUnion() && 813 Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) { 814 data().HasInClassInitializer = true; 815 816 // C++11 [class]p5: 817 // A default constructor is trivial if [...] no non-static data member 818 // of its class has a brace-or-equal-initializer. 819 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 820 821 // C++11 [dcl.init.aggr]p1: 822 // An aggregate is a [...] class with [...] no 823 // brace-or-equal-initializers for non-static data members. 824 // 825 // This rule was removed in C++14. 826 if (!getASTContext().getLangOpts().CPlusPlus14) 827 data().Aggregate = false; 828 829 // C++11 [class]p10: 830 // A POD struct is [...] a trivial class. 831 data().PlainOldData = false; 832 } 833 834 // C++11 [class.copy]p23: 835 // A defaulted copy/move assignment operator for a class X is defined 836 // as deleted if X has: 837 // -- a non-static data member of reference type 838 if (T->isReferenceType()) 839 data().DefaultedMoveAssignmentIsDeleted = true; 840 841 if (const RecordType *RecordTy = T->getAs<RecordType>()) { 842 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl()); 843 if (FieldRec->getDefinition()) { 844 addedClassSubobject(FieldRec); 845 846 // We may need to perform overload resolution to determine whether a 847 // field can be moved if it's const or volatile qualified. 848 if (T.getCVRQualifiers() & (Qualifiers::Const | Qualifiers::Volatile)) { 849 // We need to care about 'const' for the copy constructor because an 850 // implicit copy constructor might be declared with a non-const 851 // parameter. 852 data().NeedOverloadResolutionForCopyConstructor = true; 853 data().NeedOverloadResolutionForMoveConstructor = true; 854 data().NeedOverloadResolutionForMoveAssignment = true; 855 } 856 857 // C++11 [class.ctor]p5, C++11 [class.copy]p11: 858 // A defaulted [special member] for a class X is defined as 859 // deleted if: 860 // -- X is a union-like class that has a variant member with a 861 // non-trivial [corresponding special member] 862 if (isUnion()) { 863 if (FieldRec->hasNonTrivialCopyConstructor()) 864 data().DefaultedCopyConstructorIsDeleted = true; 865 if (FieldRec->hasNonTrivialMoveConstructor()) 866 data().DefaultedMoveConstructorIsDeleted = true; 867 if (FieldRec->hasNonTrivialMoveAssignment()) 868 data().DefaultedMoveAssignmentIsDeleted = true; 869 if (FieldRec->hasNonTrivialDestructor()) 870 data().DefaultedDestructorIsDeleted = true; 871 } 872 873 // For an anonymous union member, our overload resolution will perform 874 // overload resolution for its members. 875 if (Field->isAnonymousStructOrUnion()) { 876 data().NeedOverloadResolutionForCopyConstructor |= 877 FieldRec->data().NeedOverloadResolutionForCopyConstructor; 878 data().NeedOverloadResolutionForMoveConstructor |= 879 FieldRec->data().NeedOverloadResolutionForMoveConstructor; 880 data().NeedOverloadResolutionForMoveAssignment |= 881 FieldRec->data().NeedOverloadResolutionForMoveAssignment; 882 data().NeedOverloadResolutionForDestructor |= 883 FieldRec->data().NeedOverloadResolutionForDestructor; 884 } 885 886 // C++0x [class.ctor]p5: 887 // A default constructor is trivial [...] if: 888 // -- for all the non-static data members of its class that are of 889 // class type (or array thereof), each such class has a trivial 890 // default constructor. 891 if (!FieldRec->hasTrivialDefaultConstructor()) 892 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor; 893 894 // C++0x [class.copy]p13: 895 // A copy/move constructor for class X is trivial if [...] 896 // [...] 897 // -- for each non-static data member of X that is of class type (or 898 // an array thereof), the constructor selected to copy/move that 899 // member is trivial; 900 if (!FieldRec->hasTrivialCopyConstructor()) 901 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor; 902 // If the field doesn't have a simple move constructor, we'll eagerly 903 // declare the move constructor for this class and we'll decide whether 904 // it's trivial then. 905 if (!FieldRec->hasTrivialMoveConstructor()) 906 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor; 907 908 // C++0x [class.copy]p27: 909 // A copy/move assignment operator for class X is trivial if [...] 910 // [...] 911 // -- for each non-static data member of X that is of class type (or 912 // an array thereof), the assignment operator selected to 913 // copy/move that member is trivial; 914 if (!FieldRec->hasTrivialCopyAssignment()) 915 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment; 916 // If the field doesn't have a simple move assignment, we'll eagerly 917 // declare the move assignment for this class and we'll decide whether 918 // it's trivial then. 919 if (!FieldRec->hasTrivialMoveAssignment()) 920 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment; 921 922 if (!FieldRec->hasTrivialDestructor()) 923 data().HasTrivialSpecialMembers &= ~SMF_Destructor; 924 if (!FieldRec->hasIrrelevantDestructor()) 925 data().HasIrrelevantDestructor = false; 926 if (FieldRec->hasObjectMember()) 927 setHasObjectMember(true); 928 if (FieldRec->hasVolatileMember()) 929 setHasVolatileMember(true); 930 931 // C++0x [class]p7: 932 // A standard-layout class is a class that: 933 // -- has no non-static data members of type non-standard-layout 934 // class (or array of such types) [...] 935 if (!FieldRec->isStandardLayout()) 936 data().IsStandardLayout = false; 937 938 // C++0x [class]p7: 939 // A standard-layout class is a class that: 940 // [...] 941 // -- has no base classes of the same type as the first non-static 942 // data member. 943 // We don't want to expend bits in the state of the record decl 944 // tracking whether this is the first non-static data member so we 945 // cheat a bit and use some of the existing state: the empty bit. 946 // Virtual bases and virtual methods make a class non-empty, but they 947 // also make it non-standard-layout so we needn't check here. 948 // A non-empty base class may leave the class standard-layout, but not 949 // if we have arrived here, and have at least one non-static data 950 // member. If IsStandardLayout remains true, then the first non-static 951 // data member must come through here with Empty still true, and Empty 952 // will subsequently be set to false below. 953 if (data().IsStandardLayout && data().Empty) { 954 for (const auto &BI : bases()) { 955 if (Context.hasSameUnqualifiedType(BI.getType(), T)) { 956 data().IsStandardLayout = false; 957 break; 958 } 959 } 960 } 961 962 // Keep track of the presence of mutable fields. 963 if (FieldRec->hasMutableFields()) { 964 data().HasMutableFields = true; 965 data().NeedOverloadResolutionForCopyConstructor = true; 966 } 967 968 // C++11 [class.copy]p13: 969 // If the implicitly-defined constructor would satisfy the 970 // requirements of a constexpr constructor, the implicitly-defined 971 // constructor is constexpr. 972 // C++11 [dcl.constexpr]p4: 973 // -- every constructor involved in initializing non-static data 974 // members [...] shall be a constexpr constructor 975 if (!Field->hasInClassInitializer() && 976 !FieldRec->hasConstexprDefaultConstructor() && !isUnion()) 977 // The standard requires any in-class initializer to be a constant 978 // expression. We consider this to be a defect. 979 data().DefaultedDefaultConstructorIsConstexpr = false; 980 981 // C++11 [class.copy]p8: 982 // The implicitly-declared copy constructor for a class X will have 983 // the form 'X::X(const X&)' if each potentially constructed subobject 984 // of a class type M (or array thereof) has a copy constructor whose 985 // first parameter is of type 'const M&' or 'const volatile M&'. 986 if (!FieldRec->hasCopyConstructorWithConstParam()) 987 data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false; 988 989 // C++11 [class.copy]p18: 990 // The implicitly-declared copy assignment oeprator for a class X will 991 // have the form 'X& X::operator=(const X&)' if [...] for all the 992 // non-static data members of X that are of a class type M (or array 993 // thereof), each such class type has a copy assignment operator whose 994 // parameter is of type 'const M&', 'const volatile M&' or 'M'. 995 if (!FieldRec->hasCopyAssignmentWithConstParam()) 996 data().ImplicitCopyAssignmentHasConstParam = false; 997 998 if (FieldRec->hasUninitializedReferenceMember() && 999 !Field->hasInClassInitializer()) 1000 data().HasUninitializedReferenceMember = true; 1001 1002 // C++11 [class.union]p8, DR1460: 1003 // a non-static data member of an anonymous union that is a member of 1004 // X is also a variant member of X. 1005 if (FieldRec->hasVariantMembers() && 1006 Field->isAnonymousStructOrUnion()) 1007 data().HasVariantMembers = true; 1008 } 1009 } else { 1010 // Base element type of field is a non-class type. 1011 if (!T->isLiteralType(Context) || 1012 (!Field->hasInClassInitializer() && !isUnion())) 1013 data().DefaultedDefaultConstructorIsConstexpr = false; 1014 1015 // C++11 [class.copy]p23: 1016 // A defaulted copy/move assignment operator for a class X is defined 1017 // as deleted if X has: 1018 // -- a non-static data member of const non-class type (or array 1019 // thereof) 1020 if (T.isConstQualified()) 1021 data().DefaultedMoveAssignmentIsDeleted = true; 1022 } 1023 1024 // C++0x [class]p7: 1025 // A standard-layout class is a class that: 1026 // [...] 1027 // -- either has no non-static data members in the most derived 1028 // class and at most one base class with non-static data members, 1029 // or has no base classes with non-static data members, and 1030 // At this point we know that we have a non-static data member, so the last 1031 // clause holds. 1032 if (!data().HasNoNonEmptyBases) 1033 data().IsStandardLayout = false; 1034 1035 // C++14 [meta.unary.prop]p4: 1036 // T is a class type [...] with [...] no non-static data members other 1037 // than bit-fields of length 0... 1038 if (data().Empty) { 1039 if (!Field->isBitField() || 1040 (!Field->getBitWidth()->isTypeDependent() && 1041 !Field->getBitWidth()->isValueDependent() && 1042 Field->getBitWidthValue(Context) != 0)) 1043 data().Empty = false; 1044 } 1045 } 1046 1047 // Handle using declarations of conversion functions. 1048 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) { 1049 if (Shadow->getDeclName().getNameKind() 1050 == DeclarationName::CXXConversionFunctionName) { 1051 ASTContext &Ctx = getASTContext(); 1052 data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess()); 1053 } 1054 } 1055 1056 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 1057 if (Using->getDeclName().getNameKind() == 1058 DeclarationName::CXXConstructorName) { 1059 data().HasInheritedConstructor = true; 1060 // C++1z [dcl.init.aggr]p1: 1061 // An aggregate is [...] a class [...] with no inherited constructors 1062 data().Aggregate = false; 1063 } 1064 1065 if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal) 1066 data().HasInheritedAssignment = true; 1067 } 1068} 1069 1070void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) { 1071 assert(!D->isImplicit() && !D->isUserProvided()); 1072 1073 // The kind of special member this declaration is, if any. 1074 unsigned SMKind = 0; 1075 1076 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 1077 if (Constructor->isDefaultConstructor()) { 1078 SMKind |= SMF_DefaultConstructor; 1079 if (Constructor->isConstexpr()) 1080 data().HasConstexprDefaultConstructor = true; 1081 } 1082 if (Constructor->isCopyConstructor()) 1083 SMKind |= SMF_CopyConstructor; 1084 else if (Constructor->isMoveConstructor()) 1085 SMKind |= SMF_MoveConstructor; 1086 else if (Constructor->isConstexpr()) 1087 // We may now know that the constructor is constexpr. 1088 data().HasConstexprNonCopyMoveConstructor = true; 1089 } else if (isa<CXXDestructorDecl>(D)) { 1090 SMKind |= SMF_Destructor; 1091 if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted()) 1092 data().HasIrrelevantDestructor = false; 1093 } else if (D->isCopyAssignmentOperator()) 1094 SMKind |= SMF_CopyAssignment; 1095 else if (D->isMoveAssignmentOperator()) 1096 SMKind |= SMF_MoveAssignment; 1097 1098 // Update which trivial / non-trivial special members we have. 1099 // addedMember will have skipped this step for this member. 1100 if (D->isTrivial()) 1101 data().HasTrivialSpecialMembers |= SMKind; 1102 else 1103 data().DeclaredNonTrivialSpecialMembers |= SMKind; 1104} 1105 1106bool CXXRecordDecl::isCLike() const { 1107 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface || 1108 !TemplateOrInstantiation.isNull()) 1109 return false; 1110 if (!hasDefinition()) 1111 return true; 1112 1113 return isPOD() && data().HasOnlyCMembers; 1114} 1115 1116bool CXXRecordDecl::isGenericLambda() const { 1117 if (!isLambda()) return false; 1118 return getLambdaData().IsGenericLambda; 1119} 1120 1121CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const { 1122 if (!isLambda()) return nullptr; 1123 DeclarationName Name = 1124 getASTContext().DeclarationNames.getCXXOperatorName(OO_Call); 1125 DeclContext::lookup_result Calls = lookup(Name); 1126 1127 assert(!Calls.empty() && "Missing lambda call operator!"); 1128 assert(Calls.size() == 1 && "More than one lambda call operator!"); 1129 1130 NamedDecl *CallOp = Calls.front(); 1131 if (FunctionTemplateDecl *CallOpTmpl = 1132 dyn_cast<FunctionTemplateDecl>(CallOp)) 1133 return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl()); 1134 1135 return cast<CXXMethodDecl>(CallOp); 1136} 1137 1138CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const { 1139 if (!isLambda()) return nullptr; 1140 DeclarationName Name = 1141 &getASTContext().Idents.get(getLambdaStaticInvokerName()); 1142 DeclContext::lookup_result Invoker = lookup(Name); 1143 if (Invoker.empty()) return nullptr; 1144 assert(Invoker.size() == 1 && "More than one static invoker operator!"); 1145 NamedDecl *InvokerFun = Invoker.front(); 1146 if (FunctionTemplateDecl *InvokerTemplate = 1147 dyn_cast<FunctionTemplateDecl>(InvokerFun)) 1148 return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl()); 1149 1150 return cast<CXXMethodDecl>(InvokerFun); 1151} 1152 1153void CXXRecordDecl::getCaptureFields( 1154 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures, 1155 FieldDecl *&ThisCapture) const { 1156 Captures.clear(); 1157 ThisCapture = nullptr; 1158 1159 LambdaDefinitionData &Lambda = getLambdaData(); 1160 RecordDecl::field_iterator Field = field_begin(); 1161 for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures; 1162 C != CEnd; ++C, ++Field) { 1163 if (C->capturesThis()) 1164 ThisCapture = *Field; 1165 else if (C->capturesVariable()) 1166 Captures[C->getCapturedVar()] = *Field; 1167 } 1168 assert(Field == field_end()); 1169} 1170 1171TemplateParameterList * 1172CXXRecordDecl::getGenericLambdaTemplateParameterList() const { 1173 if (!isLambda()) return nullptr; 1174 CXXMethodDecl *CallOp = getLambdaCallOperator(); 1175 if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate()) 1176 return Tmpl->getTemplateParameters(); 1177 return nullptr; 1178} 1179 1180Decl *CXXRecordDecl::getLambdaContextDecl() const { 1181 assert(isLambda() && "Not a lambda closure type!"); 1182 ExternalASTSource *Source = getParentASTContext().getExternalSource(); 1183 return getLambdaData().ContextDecl.get(Source); 1184} 1185 1186static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) { 1187 QualType T = 1188 cast<CXXConversionDecl>(Conv->getUnderlyingDecl()->getAsFunction()) 1189 ->getConversionType(); 1190 return Context.getCanonicalType(T); 1191} 1192 1193/// Collect the visible conversions of a base class. 1194/// 1195/// \param Record a base class of the class we're considering 1196/// \param InVirtual whether this base class is a virtual base (or a base 1197/// of a virtual base) 1198/// \param Access the access along the inheritance path to this base 1199/// \param ParentHiddenTypes the conversions provided by the inheritors 1200/// of this base 1201/// \param Output the set to which to add conversions from non-virtual bases 1202/// \param VOutput the set to which to add conversions from virtual bases 1203/// \param HiddenVBaseCs the set of conversions which were hidden in a 1204/// virtual base along some inheritance path 1205static void CollectVisibleConversions(ASTContext &Context, 1206 CXXRecordDecl *Record, 1207 bool InVirtual, 1208 AccessSpecifier Access, 1209 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes, 1210 ASTUnresolvedSet &Output, 1211 UnresolvedSetImpl &VOutput, 1212 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) { 1213 // The set of types which have conversions in this class or its 1214 // subclasses. As an optimization, we don't copy the derived set 1215 // unless it might change. 1216 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes; 1217 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer; 1218 1219 // Collect the direct conversions and figure out which conversions 1220 // will be hidden in the subclasses. 1221 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin(); 1222 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end(); 1223 if (ConvI != ConvE) { 1224 HiddenTypesBuffer = ParentHiddenTypes; 1225 HiddenTypes = &HiddenTypesBuffer; 1226 1227 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) { 1228 CanQualType ConvType(GetConversionType(Context, I.getDecl())); 1229 bool Hidden = ParentHiddenTypes.count(ConvType); 1230 if (!Hidden) 1231 HiddenTypesBuffer.insert(ConvType); 1232 1233 // If this conversion is hidden and we're in a virtual base, 1234 // remember that it's hidden along some inheritance path. 1235 if (Hidden && InVirtual) 1236 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())); 1237 1238 // If this conversion isn't hidden, add it to the appropriate output. 1239 else if (!Hidden) { 1240 AccessSpecifier IAccess 1241 = CXXRecordDecl::MergeAccess(Access, I.getAccess()); 1242 1243 if (InVirtual) 1244 VOutput.addDecl(I.getDecl(), IAccess); 1245 else 1246 Output.addDecl(Context, I.getDecl(), IAccess); 1247 } 1248 } 1249 } 1250 1251 // Collect information recursively from any base classes. 1252 for (const auto &I : Record->bases()) { 1253 const RecordType *RT = I.getType()->getAs<RecordType>(); 1254 if (!RT) continue; 1255 1256 AccessSpecifier BaseAccess 1257 = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier()); 1258 bool BaseInVirtual = InVirtual || I.isVirtual(); 1259 1260 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl()); 1261 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess, 1262 *HiddenTypes, Output, VOutput, HiddenVBaseCs); 1263 } 1264} 1265 1266/// Collect the visible conversions of a class. 1267/// 1268/// This would be extremely straightforward if it weren't for virtual 1269/// bases. It might be worth special-casing that, really. 1270static void CollectVisibleConversions(ASTContext &Context, 1271 CXXRecordDecl *Record, 1272 ASTUnresolvedSet &Output) { 1273 // The collection of all conversions in virtual bases that we've 1274 // found. These will be added to the output as long as they don't 1275 // appear in the hidden-conversions set. 1276 UnresolvedSet<8> VBaseCs; 1277 1278 // The set of conversions in virtual bases that we've determined to 1279 // be hidden. 1280 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs; 1281 1282 // The set of types hidden by classes derived from this one. 1283 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes; 1284 1285 // Go ahead and collect the direct conversions and add them to the 1286 // hidden-types set. 1287 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin(); 1288 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end(); 1289 Output.append(Context, ConvI, ConvE); 1290 for (; ConvI != ConvE; ++ConvI) 1291 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl())); 1292 1293 // Recursively collect conversions from base classes. 1294 for (const auto &I : Record->bases()) { 1295 const RecordType *RT = I.getType()->getAs<RecordType>(); 1296 if (!RT) continue; 1297 1298 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()), 1299 I.isVirtual(), I.getAccessSpecifier(), 1300 HiddenTypes, Output, VBaseCs, HiddenVBaseCs); 1301 } 1302 1303 // Add any unhidden conversions provided by virtual bases. 1304 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end(); 1305 I != E; ++I) { 1306 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()))) 1307 Output.addDecl(Context, I.getDecl(), I.getAccess()); 1308 } 1309} 1310 1311/// getVisibleConversionFunctions - get all conversion functions visible 1312/// in current class; including conversion function templates. 1313llvm::iterator_range<CXXRecordDecl::conversion_iterator> 1314CXXRecordDecl::getVisibleConversionFunctions() { 1315 ASTContext &Ctx = getASTContext(); 1316 1317 ASTUnresolvedSet *Set; 1318 if (bases_begin() == bases_end()) { 1319 // If root class, all conversions are visible. 1320 Set = &data().Conversions.get(Ctx); 1321 } else { 1322 Set = &data().VisibleConversions.get(Ctx); 1323 // If visible conversion list is not evaluated, evaluate it. 1324 if (!data().ComputedVisibleConversions) { 1325 CollectVisibleConversions(Ctx, this, *Set); 1326 data().ComputedVisibleConversions = true; 1327 } 1328 } 1329 return llvm::make_range(Set->begin(), Set->end()); 1330} 1331 1332void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) { 1333 // This operation is O(N) but extremely rare. Sema only uses it to 1334 // remove UsingShadowDecls in a class that were followed by a direct 1335 // declaration, e.g.: 1336 // class A : B { 1337 // using B::operator int; 1338 // operator int(); 1339 // }; 1340 // This is uncommon by itself and even more uncommon in conjunction 1341 // with sufficiently large numbers of directly-declared conversions 1342 // that asymptotic behavior matters. 1343 1344 ASTUnresolvedSet &Convs = data().Conversions.get(getASTContext()); 1345 for (unsigned I = 0, E = Convs.size(); I != E; ++I) { 1346 if (Convs[I].getDecl() == ConvDecl) { 1347 Convs.erase(I); 1348 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end() 1349 && "conversion was found multiple times in unresolved set"); 1350 return; 1351 } 1352 } 1353 1354 llvm_unreachable("conversion not found in set!"); 1355} 1356 1357CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const { 1358 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 1359 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom()); 1360 1361 return nullptr; 1362} 1363 1364MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const { 1365 return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>(); 1366} 1367 1368void 1369CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD, 1370 TemplateSpecializationKind TSK) { 1371 assert(TemplateOrInstantiation.isNull() && 1372 "Previous template or instantiation?"); 1373 assert(!isa<ClassTemplatePartialSpecializationDecl>(this)); 1374 TemplateOrInstantiation 1375 = new (getASTContext()) MemberSpecializationInfo(RD, TSK); 1376} 1377 1378ClassTemplateDecl *CXXRecordDecl::getDescribedClassTemplate() const { 1379 return TemplateOrInstantiation.dyn_cast<ClassTemplateDecl *>(); 1380} 1381 1382void CXXRecordDecl::setDescribedClassTemplate(ClassTemplateDecl *Template) { 1383 TemplateOrInstantiation = Template; 1384} 1385 1386TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{ 1387 if (const ClassTemplateSpecializationDecl *Spec 1388 = dyn_cast<ClassTemplateSpecializationDecl>(this)) 1389 return Spec->getSpecializationKind(); 1390 1391 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 1392 return MSInfo->getTemplateSpecializationKind(); 1393 1394 return TSK_Undeclared; 1395} 1396 1397void 1398CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) { 1399 if (ClassTemplateSpecializationDecl *Spec 1400 = dyn_cast<ClassTemplateSpecializationDecl>(this)) { 1401 Spec->setSpecializationKind(TSK); 1402 return; 1403 } 1404 1405 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) { 1406 MSInfo->setTemplateSpecializationKind(TSK); 1407 return; 1408 } 1409 1410 llvm_unreachable("Not a class template or member class specialization"); 1411} 1412 1413const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const { 1414 auto GetDefinitionOrSelf = 1415 [](const CXXRecordDecl *D) -> const CXXRecordDecl * { 1416 if (auto *Def = D->getDefinition()) 1417 return Def; 1418 return D; 1419 }; 1420 1421 // If it's a class template specialization, find the template or partial 1422 // specialization from which it was instantiated. 1423 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) { 1424 auto From = TD->getInstantiatedFrom(); 1425 if (auto *CTD = From.dyn_cast<ClassTemplateDecl *>()) { 1426 while (auto *NewCTD = CTD->getInstantiatedFromMemberTemplate()) { 1427 if (NewCTD->isMemberSpecialization()) 1428 break; 1429 CTD = NewCTD; 1430 } 1431 return GetDefinitionOrSelf(CTD->getTemplatedDecl()); 1432 } 1433 if (auto *CTPSD = 1434 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) { 1435 while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) { 1436 if (NewCTPSD->isMemberSpecialization()) 1437 break; 1438 CTPSD = NewCTPSD; 1439 } 1440 return GetDefinitionOrSelf(CTPSD); 1441 } 1442 } 1443 1444 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) { 1445 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) { 1446 const CXXRecordDecl *RD = this; 1447 while (auto *NewRD = RD->getInstantiatedFromMemberClass()) 1448 RD = NewRD; 1449 return GetDefinitionOrSelf(RD); 1450 } 1451 } 1452 1453 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) && 1454 "couldn't find pattern for class template instantiation"); 1455 return nullptr; 1456} 1457 1458CXXDestructorDecl *CXXRecordDecl::getDestructor() const { 1459 ASTContext &Context = getASTContext(); 1460 QualType ClassType = Context.getTypeDeclType(this); 1461 1462 DeclarationName Name 1463 = Context.DeclarationNames.getCXXDestructorName( 1464 Context.getCanonicalType(ClassType)); 1465 1466 DeclContext::lookup_result R = lookup(Name); 1467 1468 return R.empty() ? nullptr : dyn_cast<CXXDestructorDecl>(R.front()); 1469} 1470 1471bool CXXRecordDecl::isAnyDestructorNoReturn() const { 1472 // Destructor is noreturn. 1473 if (const CXXDestructorDecl *Destructor = getDestructor()) 1474 if (Destructor->isNoReturn()) 1475 return true; 1476 1477 // Check base classes destructor for noreturn. 1478 for (const auto &Base : bases()) 1479 if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) 1480 if (RD->isAnyDestructorNoReturn()) 1481 return true; 1482 1483 // Check fields for noreturn. 1484 for (const auto *Field : fields()) 1485 if (const CXXRecordDecl *RD = 1486 Field->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) 1487 if (RD->isAnyDestructorNoReturn()) 1488 return true; 1489 1490 // All destructors are not noreturn. 1491 return false; 1492} 1493 1494static bool isDeclContextInNamespace(const DeclContext *DC) { 1495 while (!DC->isTranslationUnit()) { 1496 if (DC->isNamespace()) 1497 return true; 1498 DC = DC->getParent(); 1499 } 1500 return false; 1501} 1502 1503bool CXXRecordDecl::isInterfaceLike() const { 1504 assert(hasDefinition() && "checking for interface-like without a definition"); 1505 // All __interfaces are inheritently interface-like. 1506 if (isInterface()) 1507 return true; 1508 1509 // Interface-like types cannot have a user declared constructor, destructor, 1510 // friends, VBases, conversion functions, or fields. Additionally, lambdas 1511 // cannot be interface types. 1512 if (isLambda() || hasUserDeclaredConstructor() || 1513 hasUserDeclaredDestructor() || !field_empty() || hasFriends() || 1514 getNumVBases() > 0 || conversion_end() - conversion_begin() > 0) 1515 return false; 1516 1517 // No interface-like type can have a method with a definition. 1518 for (const auto *const Method : methods()) 1519 if (Method->isDefined() && !Method->isImplicit()) 1520 return false; 1521 1522 // Check "Special" types. 1523 const auto *Uuid = getAttr<UuidAttr>(); 1524 // MS SDK declares IUnknown/IDispatch both in the root of a TU, or in an 1525 // extern C++ block directly in the TU. These are only valid if in one 1526 // of these two situations. 1527 if (Uuid && isStruct() && !getDeclContext()->isExternCContext() && 1528 !isDeclContextInNamespace(getDeclContext()) && 1529 ((getName() == "IUnknown" && 1530 Uuid->getGuid() == "00000000-0000-0000-C000-000000000046") || 1531 (getName() == "IDispatch" && 1532 Uuid->getGuid() == "00020400-0000-0000-C000-000000000046"))) { 1533 if (getNumBases() > 0) 1534 return false; 1535 return true; 1536 } 1537 1538 // FIXME: Any access specifiers is supposed to make this no longer interface 1539 // like. 1540 1541 // If this isn't a 'special' type, it must have a single interface-like base. 1542 if (getNumBases() != 1) 1543 return false; 1544 1545 const auto BaseSpec = *bases_begin(); 1546 if (BaseSpec.isVirtual() || BaseSpec.getAccessSpecifier() != AS_public) 1547 return false; 1548 const auto *Base = BaseSpec.getType()->getAsCXXRecordDecl(); 1549 if (Base->isInterface() || !Base->isInterfaceLike()) 1550 return false; 1551 return true; 1552} 1553 1554void CXXRecordDecl::completeDefinition() { 1555 completeDefinition(nullptr); 1556} 1557 1558void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) { 1559 RecordDecl::completeDefinition(); 1560 1561 // If the class may be abstract (but hasn't been marked as such), check for 1562 // any pure final overriders. 1563 if (mayBeAbstract()) { 1564 CXXFinalOverriderMap MyFinalOverriders; 1565 if (!FinalOverriders) { 1566 getFinalOverriders(MyFinalOverriders); 1567 FinalOverriders = &MyFinalOverriders; 1568 } 1569 1570 bool Done = false; 1571 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(), 1572 MEnd = FinalOverriders->end(); 1573 M != MEnd && !Done; ++M) { 1574 for (OverridingMethods::iterator SO = M->second.begin(), 1575 SOEnd = M->second.end(); 1576 SO != SOEnd && !Done; ++SO) { 1577 assert(SO->second.size() > 0 && 1578 "All virtual functions have overridding virtual functions"); 1579 1580 // C++ [class.abstract]p4: 1581 // A class is abstract if it contains or inherits at least one 1582 // pure virtual function for which the final overrider is pure 1583 // virtual. 1584 if (SO->second.front().Method->isPure()) { 1585 data().Abstract = true; 1586 Done = true; 1587 break; 1588 } 1589 } 1590 } 1591 } 1592 1593 // Set access bits correctly on the directly-declared conversions. 1594 for (conversion_iterator I = conversion_begin(), E = conversion_end(); 1595 I != E; ++I) 1596 I.setAccess((*I)->getAccess()); 1597} 1598 1599bool CXXRecordDecl::mayBeAbstract() const { 1600 if (data().Abstract || isInvalidDecl() || !data().Polymorphic || 1601 isDependentContext()) 1602 return false; 1603 1604 for (const auto &B : bases()) { 1605 CXXRecordDecl *BaseDecl 1606 = cast<CXXRecordDecl>(B.getType()->getAs<RecordType>()->getDecl()); 1607 if (BaseDecl->isAbstract()) 1608 return true; 1609 } 1610 1611 return false; 1612} 1613 1614void CXXDeductionGuideDecl::anchor() {} 1615 1616CXXDeductionGuideDecl *CXXDeductionGuideDecl::Create( 1617 ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit, 1618 const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, 1619 SourceLocation EndLocation) { 1620 return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, IsExplicit, 1621 NameInfo, T, TInfo, EndLocation); 1622} 1623 1624CXXDeductionGuideDecl *CXXDeductionGuideDecl::CreateDeserialized(ASTContext &C, 1625 unsigned ID) { 1626 return new (C, ID) CXXDeductionGuideDecl(C, nullptr, SourceLocation(), false, 1627 DeclarationNameInfo(), QualType(), 1628 nullptr, SourceLocation()); 1629} 1630 1631void CXXMethodDecl::anchor() {} 1632 1633bool CXXMethodDecl::isStatic() const { 1634 const CXXMethodDecl *MD = getCanonicalDecl(); 1635 1636 if (MD->getStorageClass() == SC_Static) 1637 return true; 1638 1639 OverloadedOperatorKind OOK = getDeclName().getCXXOverloadedOperator(); 1640 return isStaticOverloadedOperator(OOK); 1641} 1642 1643static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD, 1644 const CXXMethodDecl *BaseMD) { 1645 for (const CXXMethodDecl *MD : DerivedMD->overridden_methods()) { 1646 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl()) 1647 return true; 1648 if (recursivelyOverrides(MD, BaseMD)) 1649 return true; 1650 } 1651 return false; 1652} 1653 1654CXXMethodDecl * 1655CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD, 1656 bool MayBeBase) { 1657 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl()) 1658 return this; 1659 1660 // Lookup doesn't work for destructors, so handle them separately. 1661 if (isa<CXXDestructorDecl>(this)) { 1662 CXXMethodDecl *MD = RD->getDestructor(); 1663 if (MD) { 1664 if (recursivelyOverrides(MD, this)) 1665 return MD; 1666 if (MayBeBase && recursivelyOverrides(this, MD)) 1667 return MD; 1668 } 1669 return nullptr; 1670 } 1671 1672 for (auto *ND : RD->lookup(getDeclName())) { 1673 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND); 1674 if (!MD) 1675 continue; 1676 if (recursivelyOverrides(MD, this)) 1677 return MD; 1678 if (MayBeBase && recursivelyOverrides(this, MD)) 1679 return MD; 1680 } 1681 1682 for (const auto &I : RD->bases()) { 1683 const RecordType *RT = I.getType()->getAs<RecordType>(); 1684 if (!RT) 1685 continue; 1686 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl()); 1687 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base); 1688 if (T) 1689 return T; 1690 } 1691 1692 return nullptr; 1693} 1694 1695CXXMethodDecl * 1696CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD, 1697 SourceLocation StartLoc, 1698 const DeclarationNameInfo &NameInfo, 1699 QualType T, TypeSourceInfo *TInfo, 1700 StorageClass SC, bool isInline, 1701 bool isConstexpr, SourceLocation EndLocation) { 1702 return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo, 1703 T, TInfo, SC, isInline, isConstexpr, 1704 EndLocation); 1705} 1706 1707CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1708 return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(), 1709 DeclarationNameInfo(), QualType(), nullptr, 1710 SC_None, false, false, SourceLocation()); 1711} 1712 1713CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base, 1714 bool IsAppleKext) { 1715 assert(isVirtual() && "this method is expected to be virtual"); 1716 1717 // When building with -fapple-kext, all calls must go through the vtable since 1718 // the kernel linker can do runtime patching of vtables. 1719 if (IsAppleKext) 1720 return nullptr; 1721 1722 // If the member function is marked 'final', we know that it can't be 1723 // overridden and can therefore devirtualize it unless it's pure virtual. 1724 if (hasAttr<FinalAttr>()) 1725 return isPure() ? nullptr : this; 1726 1727 // If Base is unknown, we cannot devirtualize. 1728 if (!Base) 1729 return nullptr; 1730 1731 // If the base expression (after skipping derived-to-base conversions) is a 1732 // class prvalue, then we can devirtualize. 1733 Base = Base->getBestDynamicClassTypeExpr(); 1734 if (Base->isRValue() && Base->getType()->isRecordType()) 1735 return this; 1736 1737 // If we don't even know what we would call, we can't devirtualize. 1738 const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType(); 1739 if (!BestDynamicDecl) 1740 return nullptr; 1741 1742 // There may be a method corresponding to MD in a derived class. 1743 CXXMethodDecl *DevirtualizedMethod = 1744 getCorrespondingMethodInClass(BestDynamicDecl); 1745 1746 // If that method is pure virtual, we can't devirtualize. If this code is 1747 // reached, the result would be UB, not a direct call to the derived class 1748 // function, and we can't assume the derived class function is defined. 1749 if (DevirtualizedMethod->isPure()) 1750 return nullptr; 1751 1752 // If that method is marked final, we can devirtualize it. 1753 if (DevirtualizedMethod->hasAttr<FinalAttr>()) 1754 return DevirtualizedMethod; 1755 1756 // Similarly, if the class itself is marked 'final' it can't be overridden 1757 // and we can therefore devirtualize the member function call. 1758 if (BestDynamicDecl->hasAttr<FinalAttr>()) 1759 return DevirtualizedMethod; 1760 1761 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 1762 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 1763 if (VD->getType()->isRecordType()) 1764 // This is a record decl. We know the type and can devirtualize it. 1765 return DevirtualizedMethod; 1766 1767 return nullptr; 1768 } 1769 1770 // We can devirtualize calls on an object accessed by a class member access 1771 // expression, since by C++11 [basic.life]p6 we know that it can't refer to 1772 // a derived class object constructed in the same location. 1773 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Base)) 1774 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ME->getMemberDecl())) 1775 return VD->getType()->isRecordType() ? DevirtualizedMethod : nullptr; 1776 1777 // Likewise for calls on an object accessed by a (non-reference) pointer to 1778 // member access. 1779 if (auto *BO = dyn_cast<BinaryOperator>(Base)) { 1780 if (BO->isPtrMemOp()) { 1781 auto *MPT = BO->getRHS()->getType()->castAs<MemberPointerType>(); 1782 if (MPT->getPointeeType()->isRecordType()) 1783 return DevirtualizedMethod; 1784 } 1785 } 1786 1787 // We can't devirtualize the call. 1788 return nullptr; 1789} 1790 1791bool CXXMethodDecl::isUsualDeallocationFunction() const { 1792 if (getOverloadedOperator() != OO_Delete && 1793 getOverloadedOperator() != OO_Array_Delete) 1794 return false; 1795 1796 // C++ [basic.stc.dynamic.deallocation]p2: 1797 // A template instance is never a usual deallocation function, 1798 // regardless of its signature. 1799 if (getPrimaryTemplate()) 1800 return false; 1801 1802 // C++ [basic.stc.dynamic.deallocation]p2: 1803 // If a class T has a member deallocation function named operator delete 1804 // with exactly one parameter, then that function is a usual (non-placement) 1805 // deallocation function. [...] 1806 if (getNumParams() == 1) 1807 return true; 1808 unsigned UsualParams = 1; 1809 1810 // C++ P0722: 1811 // A destroying operator delete is a usual deallocation function if 1812 // removing the std::destroying_delete_t parameter and changing the 1813 // first parameter type from T* to void* results in the signature of 1814 // a usual deallocation function. 1815 if (isDestroyingOperatorDelete()) 1816 ++UsualParams; 1817 1818 // C++ <=14 [basic.stc.dynamic.deallocation]p2: 1819 // [...] If class T does not declare such an operator delete but does 1820 // declare a member deallocation function named operator delete with 1821 // exactly two parameters, the second of which has type std::size_t (18.1), 1822 // then this function is a usual deallocation function. 1823 // 1824 // C++17 says a usual deallocation function is one with the signature 1825 // (void* [, size_t] [, std::align_val_t] [, ...]) 1826 // and all such functions are usual deallocation functions. It's not clear 1827 // that allowing varargs functions was intentional. 1828 ASTContext &Context = getASTContext(); 1829 if (UsualParams < getNumParams() && 1830 Context.hasSameUnqualifiedType(getParamDecl(UsualParams)->getType(), 1831 Context.getSizeType())) 1832 ++UsualParams; 1833 1834 if (UsualParams < getNumParams() && 1835 getParamDecl(UsualParams)->getType()->isAlignValT()) 1836 ++UsualParams; 1837 1838 if (UsualParams != getNumParams()) 1839 return false; 1840 1841 // In C++17 onwards, all potential usual deallocation functions are actual 1842 // usual deallocation functions. 1843 if (Context.getLangOpts().AlignedAllocation) 1844 return true; 1845 1846 // This function is a usual deallocation function if there are no 1847 // single-parameter deallocation functions of the same kind. 1848 DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName()); 1849 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 1850 I != E; ++I) { 1851 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) 1852 if (FD->getNumParams() == 1) 1853 return false; 1854 } 1855 1856 return true; 1857} 1858 1859bool CXXMethodDecl::isCopyAssignmentOperator() const { 1860 // C++0x [class.copy]p17: 1861 // A user-declared copy assignment operator X::operator= is a non-static 1862 // non-template member function of class X with exactly one parameter of 1863 // type X, X&, const X&, volatile X& or const volatile X&. 1864 if (/*operator=*/getOverloadedOperator() != OO_Equal || 1865 /*non-static*/ isStatic() || 1866 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() || 1867 getNumParams() != 1) 1868 return false; 1869 1870 QualType ParamType = getParamDecl(0)->getType(); 1871 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>()) 1872 ParamType = Ref->getPointeeType(); 1873 1874 ASTContext &Context = getASTContext(); 1875 QualType ClassType 1876 = Context.getCanonicalType(Context.getTypeDeclType(getParent())); 1877 return Context.hasSameUnqualifiedType(ClassType, ParamType); 1878} 1879 1880bool CXXMethodDecl::isMoveAssignmentOperator() const { 1881 // C++0x [class.copy]p19: 1882 // A user-declared move assignment operator X::operator= is a non-static 1883 // non-template member function of class X with exactly one parameter of type 1884 // X&&, const X&&, volatile X&&, or const volatile X&&. 1885 if (getOverloadedOperator() != OO_Equal || isStatic() || 1886 getPrimaryTemplate() || getDescribedFunctionTemplate() || 1887 getNumParams() != 1) 1888 return false; 1889 1890 QualType ParamType = getParamDecl(0)->getType(); 1891 if (!isa<RValueReferenceType>(ParamType)) 1892 return false; 1893 ParamType = ParamType->getPointeeType(); 1894 1895 ASTContext &Context = getASTContext(); 1896 QualType ClassType 1897 = Context.getCanonicalType(Context.getTypeDeclType(getParent())); 1898 return Context.hasSameUnqualifiedType(ClassType, ParamType); 1899} 1900 1901void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) { 1902 assert(MD->isCanonicalDecl() && "Method is not canonical!"); 1903 assert(!MD->getParent()->isDependentContext() && 1904 "Can't add an overridden method to a class template!"); 1905 assert(MD->isVirtual() && "Method is not virtual!"); 1906 1907 getASTContext().addOverriddenMethod(this, MD); 1908} 1909 1910CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const { 1911 if (isa<CXXConstructorDecl>(this)) return nullptr; 1912 return getASTContext().overridden_methods_begin(this); 1913} 1914 1915CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const { 1916 if (isa<CXXConstructorDecl>(this)) return nullptr; 1917 return getASTContext().overridden_methods_end(this); 1918} 1919 1920unsigned CXXMethodDecl::size_overridden_methods() const { 1921 if (isa<CXXConstructorDecl>(this)) return 0; 1922 return getASTContext().overridden_methods_size(this); 1923} 1924 1925CXXMethodDecl::overridden_method_range 1926CXXMethodDecl::overridden_methods() const { 1927 if (isa<CXXConstructorDecl>(this)) 1928 return overridden_method_range(nullptr, nullptr); 1929 return getASTContext().overridden_methods(this); 1930} 1931 1932QualType CXXMethodDecl::getThisType(ASTContext &C) const { 1933 // C++ 9.3.2p1: The type of this in a member function of a class X is X*. 1934 // If the member function is declared const, the type of this is const X*, 1935 // if the member function is declared volatile, the type of this is 1936 // volatile X*, and if the member function is declared const volatile, 1937 // the type of this is const volatile X*. 1938 1939 assert(isInstance() && "No 'this' for static methods!"); 1940 1941 QualType ClassTy = C.getTypeDeclType(getParent()); 1942 ClassTy = C.getQualifiedType(ClassTy, 1943 Qualifiers::fromCVRUMask(getTypeQualifiers())); 1944 return C.getPointerType(ClassTy); 1945} 1946 1947bool CXXMethodDecl::hasInlineBody() const { 1948 // If this function is a template instantiation, look at the template from 1949 // which it was instantiated. 1950 const FunctionDecl *CheckFn = getTemplateInstantiationPattern(); 1951 if (!CheckFn) 1952 CheckFn = this; 1953 1954 const FunctionDecl *fn; 1955 return CheckFn->isDefined(fn) && !fn->isOutOfLine() && 1956 (fn->doesThisDeclarationHaveABody() || fn->willHaveBody()); 1957} 1958 1959bool CXXMethodDecl::isLambdaStaticInvoker() const { 1960 const CXXRecordDecl *P = getParent(); 1961 if (P->isLambda()) { 1962 if (const CXXMethodDecl *StaticInvoker = P->getLambdaStaticInvoker()) { 1963 if (StaticInvoker == this) return true; 1964 if (P->isGenericLambda() && this->isFunctionTemplateSpecialization()) 1965 return StaticInvoker == this->getPrimaryTemplate()->getTemplatedDecl(); 1966 } 1967 } 1968 return false; 1969} 1970 1971CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1972 TypeSourceInfo *TInfo, bool IsVirtual, 1973 SourceLocation L, Expr *Init, 1974 SourceLocation R, 1975 SourceLocation EllipsisLoc) 1976 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init), 1977 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual), 1978 IsWritten(false), SourceOrder(0) {} 1979 1980CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1981 FieldDecl *Member, 1982 SourceLocation MemberLoc, 1983 SourceLocation L, Expr *Init, 1984 SourceLocation R) 1985 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init), 1986 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false), 1987 IsWritten(false), SourceOrder(0) {} 1988 1989CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1990 IndirectFieldDecl *Member, 1991 SourceLocation MemberLoc, 1992 SourceLocation L, Expr *Init, 1993 SourceLocation R) 1994 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init), 1995 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false), 1996 IsWritten(false), SourceOrder(0) {} 1997 1998CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context, 1999 TypeSourceInfo *TInfo, 2000 SourceLocation L, Expr *Init, 2001 SourceLocation R) 2002 : Initializee(TInfo), Init(Init), LParenLoc(L), RParenLoc(R), 2003 IsDelegating(true), IsVirtual(false), IsWritten(false), SourceOrder(0) {} 2004 2005TypeLoc CXXCtorInitializer::getBaseClassLoc() const { 2006 if (isBaseInitializer()) 2007 return Initializee.get<TypeSourceInfo*>()->getTypeLoc(); 2008 else 2009 return TypeLoc(); 2010} 2011 2012const Type *CXXCtorInitializer::getBaseClass() const { 2013 if (isBaseInitializer()) 2014 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr(); 2015 else 2016 return nullptr; 2017} 2018 2019SourceLocation CXXCtorInitializer::getSourceLocation() const { 2020 if (isInClassMemberInitializer()) 2021 return getAnyMember()->getLocation(); 2022 2023 if (isAnyMemberInitializer()) 2024 return getMemberLocation(); 2025 2026 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>()) 2027 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin(); 2028 2029 return SourceLocation(); 2030} 2031 2032SourceRange CXXCtorInitializer::getSourceRange() const { 2033 if (isInClassMemberInitializer()) { 2034 FieldDecl *D = getAnyMember(); 2035 if (Expr *I = D->getInClassInitializer()) 2036 return I->getSourceRange(); 2037 return SourceRange(); 2038 } 2039 2040 return SourceRange(getSourceLocation(), getRParenLoc()); 2041} 2042 2043void CXXConstructorDecl::anchor() {} 2044 2045CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C, 2046 unsigned ID, 2047 bool Inherited) { 2048 unsigned Extra = additionalSizeToAlloc<InheritedConstructor>(Inherited); 2049 auto *Result = new (C, ID, Extra) CXXConstructorDecl( 2050 C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr, 2051 false, false, false, false, InheritedConstructor()); 2052 Result->IsInheritingConstructor = Inherited; 2053 return Result; 2054} 2055 2056CXXConstructorDecl * 2057CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 2058 SourceLocation StartLoc, 2059 const DeclarationNameInfo &NameInfo, 2060 QualType T, TypeSourceInfo *TInfo, 2061 bool isExplicit, bool isInline, 2062 bool isImplicitlyDeclared, bool isConstexpr, 2063 InheritedConstructor Inherited) { 2064 assert(NameInfo.getName().getNameKind() 2065 == DeclarationName::CXXConstructorName && 2066 "Name must refer to a constructor"); 2067 unsigned Extra = 2068 additionalSizeToAlloc<InheritedConstructor>(Inherited ? 1 : 0); 2069 return new (C, RD, Extra) CXXConstructorDecl( 2070 C, RD, StartLoc, NameInfo, T, TInfo, isExplicit, isInline, 2071 isImplicitlyDeclared, isConstexpr, Inherited); 2072} 2073 2074CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const { 2075 return CtorInitializers.get(getASTContext().getExternalSource()); 2076} 2077 2078CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const { 2079 assert(isDelegatingConstructor() && "Not a delegating constructor!"); 2080 Expr *E = (*init_begin())->getInit()->IgnoreImplicit(); 2081 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E)) 2082 return Construct->getConstructor(); 2083 2084 return nullptr; 2085} 2086 2087bool CXXConstructorDecl::isDefaultConstructor() const { 2088 // C++ [class.ctor]p5: 2089 // A default constructor for a class X is a constructor of class 2090 // X that can be called without an argument. 2091 return (getNumParams() == 0) || 2092 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg()); 2093} 2094 2095bool 2096CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const { 2097 return isCopyOrMoveConstructor(TypeQuals) && 2098 getParamDecl(0)->getType()->isLValueReferenceType(); 2099} 2100 2101bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const { 2102 return isCopyOrMoveConstructor(TypeQuals) && 2103 getParamDecl(0)->getType()->isRValueReferenceType(); 2104} 2105 2106/// \brief Determine whether this is a copy or move constructor. 2107bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const { 2108 // C++ [class.copy]p2: 2109 // A non-template constructor for class X is a copy constructor 2110 // if its first parameter is of type X&, const X&, volatile X& or 2111 // const volatile X&, and either there are no other parameters 2112 // or else all other parameters have default arguments (8.3.6). 2113 // C++0x [class.copy]p3: 2114 // A non-template constructor for class X is a move constructor if its 2115 // first parameter is of type X&&, const X&&, volatile X&&, or 2116 // const volatile X&&, and either there are no other parameters or else 2117 // all other parameters have default arguments. 2118 if ((getNumParams() < 1) || 2119 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 2120 (getPrimaryTemplate() != nullptr) || 2121 (getDescribedFunctionTemplate() != nullptr)) 2122 return false; 2123 2124 const ParmVarDecl *Param = getParamDecl(0); 2125 2126 // Do we have a reference type? 2127 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>(); 2128 if (!ParamRefType) 2129 return false; 2130 2131 // Is it a reference to our class type? 2132 ASTContext &Context = getASTContext(); 2133 2134 CanQualType PointeeType 2135 = Context.getCanonicalType(ParamRefType->getPointeeType()); 2136 CanQualType ClassTy 2137 = Context.getCanonicalType(Context.getTagDeclType(getParent())); 2138 if (PointeeType.getUnqualifiedType() != ClassTy) 2139 return false; 2140 2141 // FIXME: other qualifiers? 2142 2143 // We have a copy or move constructor. 2144 TypeQuals = PointeeType.getCVRQualifiers(); 2145 return true; 2146} 2147 2148bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const { 2149 // C++ [class.conv.ctor]p1: 2150 // A constructor declared without the function-specifier explicit 2151 // that can be called with a single parameter specifies a 2152 // conversion from the type of its first parameter to the type of 2153 // its class. Such a constructor is called a converting 2154 // constructor. 2155 if (isExplicit() && !AllowExplicit) 2156 return false; 2157 2158 return (getNumParams() == 0 && 2159 getType()->getAs<FunctionProtoType>()->isVariadic()) || 2160 (getNumParams() == 1) || 2161 (getNumParams() > 1 && 2162 (getParamDecl(1)->hasDefaultArg() || 2163 getParamDecl(1)->isParameterPack())); 2164} 2165 2166bool CXXConstructorDecl::isSpecializationCopyingObject() const { 2167 if ((getNumParams() < 1) || 2168 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 2169 (getDescribedFunctionTemplate() != nullptr)) 2170 return false; 2171 2172 const ParmVarDecl *Param = getParamDecl(0); 2173 2174 ASTContext &Context = getASTContext(); 2175 CanQualType ParamType = Context.getCanonicalType(Param->getType()); 2176 2177 // Is it the same as our our class type? 2178 CanQualType ClassTy 2179 = Context.getCanonicalType(Context.getTagDeclType(getParent())); 2180 if (ParamType.getUnqualifiedType() != ClassTy) 2181 return false; 2182 2183 return true; 2184} 2185 2186void CXXDestructorDecl::anchor() {} 2187 2188CXXDestructorDecl * 2189CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2190 return new (C, ID) 2191 CXXDestructorDecl(C, nullptr, SourceLocation(), DeclarationNameInfo(), 2192 QualType(), nullptr, false, false); 2193} 2194 2195CXXDestructorDecl * 2196CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 2197 SourceLocation StartLoc, 2198 const DeclarationNameInfo &NameInfo, 2199 QualType T, TypeSourceInfo *TInfo, 2200 bool isInline, bool isImplicitlyDeclared) { 2201 assert(NameInfo.getName().getNameKind() 2202 == DeclarationName::CXXDestructorName && 2203 "Name must refer to a destructor"); 2204 return new (C, RD) CXXDestructorDecl(C, RD, StartLoc, NameInfo, T, TInfo, 2205 isInline, isImplicitlyDeclared); 2206} 2207 2208void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) { 2209 auto *First = cast<CXXDestructorDecl>(getFirstDecl()); 2210 if (OD && !First->OperatorDelete) { 2211 First->OperatorDelete = OD; 2212 First->OperatorDeleteThisArg = ThisArg; 2213 if (auto *L = getASTMutationListener()) 2214 L->ResolvedOperatorDelete(First, OD, ThisArg); 2215 } 2216} 2217 2218void CXXConversionDecl::anchor() {} 2219 2220CXXConversionDecl * 2221CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2222 return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(), 2223 DeclarationNameInfo(), QualType(), 2224 nullptr, false, false, false, 2225 SourceLocation()); 2226} 2227 2228CXXConversionDecl * 2229CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD, 2230 SourceLocation StartLoc, 2231 const DeclarationNameInfo &NameInfo, 2232 QualType T, TypeSourceInfo *TInfo, 2233 bool isInline, bool isExplicit, 2234 bool isConstexpr, SourceLocation EndLocation) { 2235 assert(NameInfo.getName().getNameKind() 2236 == DeclarationName::CXXConversionFunctionName && 2237 "Name must refer to a conversion function"); 2238 return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo, 2239 isInline, isExplicit, isConstexpr, 2240 EndLocation); 2241} 2242 2243bool CXXConversionDecl::isLambdaToBlockPointerConversion() const { 2244 return isImplicit() && getParent()->isLambda() && 2245 getConversionType()->isBlockPointerType(); 2246} 2247 2248void LinkageSpecDecl::anchor() {} 2249 2250LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C, 2251 DeclContext *DC, 2252 SourceLocation ExternLoc, 2253 SourceLocation LangLoc, 2254 LanguageIDs Lang, 2255 bool HasBraces) { 2256 return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces); 2257} 2258 2259LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C, 2260 unsigned ID) { 2261 return new (C, ID) LinkageSpecDecl(nullptr, SourceLocation(), 2262 SourceLocation(), lang_c, false); 2263} 2264 2265void UsingDirectiveDecl::anchor() {} 2266 2267UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC, 2268 SourceLocation L, 2269 SourceLocation NamespaceLoc, 2270 NestedNameSpecifierLoc QualifierLoc, 2271 SourceLocation IdentLoc, 2272 NamedDecl *Used, 2273 DeclContext *CommonAncestor) { 2274 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used)) 2275 Used = NS->getOriginalNamespace(); 2276 return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc, 2277 IdentLoc, Used, CommonAncestor); 2278} 2279 2280UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C, 2281 unsigned ID) { 2282 return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(), 2283 SourceLocation(), 2284 NestedNameSpecifierLoc(), 2285 SourceLocation(), nullptr, nullptr); 2286} 2287 2288NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() { 2289 if (NamespaceAliasDecl *NA = 2290 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace)) 2291 return NA->getNamespace(); 2292 return cast_or_null<NamespaceDecl>(NominatedNamespace); 2293} 2294 2295NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline, 2296 SourceLocation StartLoc, SourceLocation IdLoc, 2297 IdentifierInfo *Id, NamespaceDecl *PrevDecl) 2298 : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace), 2299 redeclarable_base(C), LocStart(StartLoc), 2300 AnonOrFirstNamespaceAndInline(nullptr, Inline) { 2301 setPreviousDecl(PrevDecl); 2302 2303 if (PrevDecl) 2304 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace()); 2305} 2306 2307NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC, 2308 bool Inline, SourceLocation StartLoc, 2309 SourceLocation IdLoc, IdentifierInfo *Id, 2310 NamespaceDecl *PrevDecl) { 2311 return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id, 2312 PrevDecl); 2313} 2314 2315NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2316 return new (C, ID) NamespaceDecl(C, nullptr, false, SourceLocation(), 2317 SourceLocation(), nullptr, nullptr); 2318} 2319 2320NamespaceDecl *NamespaceDecl::getOriginalNamespace() { 2321 if (isFirstDecl()) 2322 return this; 2323 2324 return AnonOrFirstNamespaceAndInline.getPointer(); 2325} 2326 2327const NamespaceDecl *NamespaceDecl::getOriginalNamespace() const { 2328 if (isFirstDecl()) 2329 return this; 2330 2331 return AnonOrFirstNamespaceAndInline.getPointer(); 2332} 2333 2334bool NamespaceDecl::isOriginalNamespace() const { return isFirstDecl(); } 2335 2336NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() { 2337 return getNextRedeclaration(); 2338} 2339 2340NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() { 2341 return getPreviousDecl(); 2342} 2343 2344NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() { 2345 return getMostRecentDecl(); 2346} 2347 2348void NamespaceAliasDecl::anchor() {} 2349 2350NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() { 2351 return getNextRedeclaration(); 2352} 2353 2354NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() { 2355 return getPreviousDecl(); 2356} 2357 2358NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() { 2359 return getMostRecentDecl(); 2360} 2361 2362NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC, 2363 SourceLocation UsingLoc, 2364 SourceLocation AliasLoc, 2365 IdentifierInfo *Alias, 2366 NestedNameSpecifierLoc QualifierLoc, 2367 SourceLocation IdentLoc, 2368 NamedDecl *Namespace) { 2369 // FIXME: Preserve the aliased namespace as written. 2370 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace)) 2371 Namespace = NS->getOriginalNamespace(); 2372 return new (C, DC) NamespaceAliasDecl(C, DC, UsingLoc, AliasLoc, Alias, 2373 QualifierLoc, IdentLoc, Namespace); 2374} 2375 2376NamespaceAliasDecl * 2377NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2378 return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(), 2379 SourceLocation(), nullptr, 2380 NestedNameSpecifierLoc(), 2381 SourceLocation(), nullptr); 2382} 2383 2384void UsingShadowDecl::anchor() {} 2385 2386UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC, 2387 SourceLocation Loc, UsingDecl *Using, 2388 NamedDecl *Target) 2389 : NamedDecl(K, DC, Loc, Using ? Using->getDeclName() : DeclarationName()), 2390 redeclarable_base(C), Underlying(Target), 2391 UsingOrNextShadow(cast<NamedDecl>(Using)) { 2392 if (Target) 2393 IdentifierNamespace = Target->getIdentifierNamespace(); 2394 setImplicit(); 2395} 2396 2397UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, EmptyShell Empty) 2398 : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()), 2399 redeclarable_base(C) {} 2400 2401UsingShadowDecl * 2402UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2403 return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell()); 2404} 2405 2406UsingDecl *UsingShadowDecl::getUsingDecl() const { 2407 const UsingShadowDecl *Shadow = this; 2408 while (const UsingShadowDecl *NextShadow = 2409 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow)) 2410 Shadow = NextShadow; 2411 return cast<UsingDecl>(Shadow->UsingOrNextShadow); 2412} 2413 2414void ConstructorUsingShadowDecl::anchor() {} 2415 2416ConstructorUsingShadowDecl * 2417ConstructorUsingShadowDecl::Create(ASTContext &C, DeclContext *DC, 2418 SourceLocation Loc, UsingDecl *Using, 2419 NamedDecl *Target, bool IsVirtual) { 2420 return new (C, DC) ConstructorUsingShadowDecl(C, DC, Loc, Using, Target, 2421 IsVirtual); 2422} 2423 2424ConstructorUsingShadowDecl * 2425ConstructorUsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2426 return new (C, ID) ConstructorUsingShadowDecl(C, EmptyShell()); 2427} 2428 2429CXXRecordDecl *ConstructorUsingShadowDecl::getNominatedBaseClass() const { 2430 return getUsingDecl()->getQualifier()->getAsRecordDecl(); 2431} 2432 2433void UsingDecl::anchor() {} 2434 2435void UsingDecl::addShadowDecl(UsingShadowDecl *S) { 2436 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() && 2437 "declaration already in set"); 2438 assert(S->getUsingDecl() == this); 2439 2440 if (FirstUsingShadow.getPointer()) 2441 S->UsingOrNextShadow = FirstUsingShadow.getPointer(); 2442 FirstUsingShadow.setPointer(S); 2443} 2444 2445void UsingDecl::removeShadowDecl(UsingShadowDecl *S) { 2446 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() && 2447 "declaration not in set"); 2448 assert(S->getUsingDecl() == this); 2449 2450 // Remove S from the shadow decl chain. This is O(n) but hopefully rare. 2451 2452 if (FirstUsingShadow.getPointer() == S) { 2453 FirstUsingShadow.setPointer( 2454 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow)); 2455 S->UsingOrNextShadow = this; 2456 return; 2457 } 2458 2459 UsingShadowDecl *Prev = FirstUsingShadow.getPointer(); 2460 while (Prev->UsingOrNextShadow != S) 2461 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow); 2462 Prev->UsingOrNextShadow = S->UsingOrNextShadow; 2463 S->UsingOrNextShadow = this; 2464} 2465 2466UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL, 2467 NestedNameSpecifierLoc QualifierLoc, 2468 const DeclarationNameInfo &NameInfo, 2469 bool HasTypename) { 2470 return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename); 2471} 2472 2473UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2474 return new (C, ID) UsingDecl(nullptr, SourceLocation(), 2475 NestedNameSpecifierLoc(), DeclarationNameInfo(), 2476 false); 2477} 2478 2479SourceRange UsingDecl::getSourceRange() const { 2480 SourceLocation Begin = isAccessDeclaration() 2481 ? getQualifierLoc().getBeginLoc() : UsingLocation; 2482 return SourceRange(Begin, getNameInfo().getEndLoc()); 2483} 2484 2485void UsingPackDecl::anchor() {} 2486 2487UsingPackDecl *UsingPackDecl::Create(ASTContext &C, DeclContext *DC, 2488 NamedDecl *InstantiatedFrom, 2489 ArrayRef<NamedDecl *> UsingDecls) { 2490 size_t Extra = additionalSizeToAlloc<NamedDecl *>(UsingDecls.size()); 2491 return new (C, DC, Extra) UsingPackDecl(DC, InstantiatedFrom, UsingDecls); 2492} 2493 2494UsingPackDecl *UsingPackDecl::CreateDeserialized(ASTContext &C, unsigned ID, 2495 unsigned NumExpansions) { 2496 size_t Extra = additionalSizeToAlloc<NamedDecl *>(NumExpansions); 2497 auto *Result = new (C, ID, Extra) UsingPackDecl(nullptr, nullptr, None); 2498 Result->NumExpansions = NumExpansions; 2499 auto *Trail = Result->getTrailingObjects<NamedDecl *>(); 2500 for (unsigned I = 0; I != NumExpansions; ++I) 2501 new (Trail + I) NamedDecl*(nullptr); 2502 return Result; 2503} 2504 2505void UnresolvedUsingValueDecl::anchor() {} 2506 2507UnresolvedUsingValueDecl * 2508UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC, 2509 SourceLocation UsingLoc, 2510 NestedNameSpecifierLoc QualifierLoc, 2511 const DeclarationNameInfo &NameInfo, 2512 SourceLocation EllipsisLoc) { 2513 return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc, 2514 QualifierLoc, NameInfo, 2515 EllipsisLoc); 2516} 2517 2518UnresolvedUsingValueDecl * 2519UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2520 return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(), 2521 SourceLocation(), 2522 NestedNameSpecifierLoc(), 2523 DeclarationNameInfo(), 2524 SourceLocation()); 2525} 2526 2527SourceRange UnresolvedUsingValueDecl::getSourceRange() const { 2528 SourceLocation Begin = isAccessDeclaration() 2529 ? getQualifierLoc().getBeginLoc() : UsingLocation; 2530 return SourceRange(Begin, getNameInfo().getEndLoc()); 2531} 2532 2533void UnresolvedUsingTypenameDecl::anchor() {} 2534 2535UnresolvedUsingTypenameDecl * 2536UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC, 2537 SourceLocation UsingLoc, 2538 SourceLocation TypenameLoc, 2539 NestedNameSpecifierLoc QualifierLoc, 2540 SourceLocation TargetNameLoc, 2541 DeclarationName TargetName, 2542 SourceLocation EllipsisLoc) { 2543 return new (C, DC) UnresolvedUsingTypenameDecl( 2544 DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc, 2545 TargetName.getAsIdentifierInfo(), EllipsisLoc); 2546} 2547 2548UnresolvedUsingTypenameDecl * 2549UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2550 return new (C, ID) UnresolvedUsingTypenameDecl( 2551 nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(), 2552 SourceLocation(), nullptr, SourceLocation()); 2553} 2554 2555void StaticAssertDecl::anchor() {} 2556 2557StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC, 2558 SourceLocation StaticAssertLoc, 2559 Expr *AssertExpr, 2560 StringLiteral *Message, 2561 SourceLocation RParenLoc, 2562 bool Failed) { 2563 return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message, 2564 RParenLoc, Failed); 2565} 2566 2567StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C, 2568 unsigned ID) { 2569 return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr, 2570 nullptr, SourceLocation(), false); 2571} 2572 2573void BindingDecl::anchor() {} 2574 2575BindingDecl *BindingDecl::Create(ASTContext &C, DeclContext *DC, 2576 SourceLocation IdLoc, IdentifierInfo *Id) { 2577 return new (C, DC) BindingDecl(DC, IdLoc, Id); 2578} 2579 2580BindingDecl *BindingDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2581 return new (C, ID) BindingDecl(nullptr, SourceLocation(), nullptr); 2582} 2583 2584VarDecl *BindingDecl::getHoldingVar() const { 2585 Expr *B = getBinding(); 2586 if (!B) 2587 return nullptr; 2588 auto *DRE = dyn_cast<DeclRefExpr>(B->IgnoreImplicit()); 2589 if (!DRE) 2590 return nullptr; 2591 2592 auto *VD = dyn_cast<VarDecl>(DRE->getDecl()); 2593 assert(VD->isImplicit() && "holding var for binding decl not implicit"); 2594 return VD; 2595} 2596 2597void DecompositionDecl::anchor() {} 2598 2599DecompositionDecl *DecompositionDecl::Create(ASTContext &C, DeclContext *DC, 2600 SourceLocation StartLoc, 2601 SourceLocation LSquareLoc, 2602 QualType T, TypeSourceInfo *TInfo, 2603 StorageClass SC, 2604 ArrayRef<BindingDecl *> Bindings) { 2605 size_t Extra = additionalSizeToAlloc<BindingDecl *>(Bindings.size()); 2606 return new (C, DC, Extra) 2607 DecompositionDecl(C, DC, StartLoc, LSquareLoc, T, TInfo, SC, Bindings); 2608} 2609 2610DecompositionDecl *DecompositionDecl::CreateDeserialized(ASTContext &C, 2611 unsigned ID, 2612 unsigned NumBindings) { 2613 size_t Extra = additionalSizeToAlloc<BindingDecl *>(NumBindings); 2614 auto *Result = new (C, ID, Extra) 2615 DecompositionDecl(C, nullptr, SourceLocation(), SourceLocation(), 2616 QualType(), nullptr, StorageClass(), None); 2617 // Set up and clean out the bindings array. 2618 Result->NumBindings = NumBindings; 2619 auto *Trail = Result->getTrailingObjects<BindingDecl *>(); 2620 for (unsigned I = 0; I != NumBindings; ++I) 2621 new (Trail + I) BindingDecl*(nullptr); 2622 return Result; 2623} 2624 2625void DecompositionDecl::printName(llvm::raw_ostream &os) const { 2626 os << '['; 2627 bool Comma = false; 2628 for (auto *B : bindings()) { 2629 if (Comma) 2630 os << ", "; 2631 B->printName(os); 2632 Comma = true; 2633 } 2634 os << ']'; 2635} 2636 2637MSPropertyDecl *MSPropertyDecl::Create(ASTContext &C, DeclContext *DC, 2638 SourceLocation L, DeclarationName N, 2639 QualType T, TypeSourceInfo *TInfo, 2640 SourceLocation StartL, 2641 IdentifierInfo *Getter, 2642 IdentifierInfo *Setter) { 2643 return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter); 2644} 2645 2646MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C, 2647 unsigned ID) { 2648 return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(), 2649 DeclarationName(), QualType(), nullptr, 2650 SourceLocation(), nullptr, nullptr); 2651} 2652 2653static const char *getAccessName(AccessSpecifier AS) { 2654 switch (AS) { 2655 case AS_none: 2656 llvm_unreachable("Invalid access specifier!"); 2657 case AS_public: 2658 return "public"; 2659 case AS_private: 2660 return "private"; 2661 case AS_protected: 2662 return "protected"; 2663 } 2664 llvm_unreachable("Invalid access specifier!"); 2665} 2666 2667const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, 2668 AccessSpecifier AS) { 2669 return DB << getAccessName(AS); 2670} 2671 2672const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB, 2673 AccessSpecifier AS) { 2674 return DB << getAccessName(AS); 2675} 2676