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