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