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