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