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