DeclCXX.cpp revision 205219
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/Expr.h" 18#include "clang/AST/TypeLoc.h" 19#include "clang/Basic/IdentifierTable.h" 20#include "llvm/ADT/STLExtras.h" 21#include "llvm/ADT/SmallPtrSet.h" 22using namespace clang; 23 24//===----------------------------------------------------------------------===// 25// Decl Allocation/Deallocation Method Implementations 26//===----------------------------------------------------------------------===// 27 28CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D) 29 : UserDeclaredConstructor(false), UserDeclaredCopyConstructor(false), 30 UserDeclaredCopyAssignment(false), UserDeclaredDestructor(false), 31 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false), 32 Abstract(false), HasTrivialConstructor(true), 33 HasTrivialCopyConstructor(true), HasTrivialCopyAssignment(true), 34 HasTrivialDestructor(true), ComputedVisibleConversions(false), 35 Bases(0), NumBases(0), VBases(0), NumVBases(0), 36 Definition(D), FirstFriend(0) { 37} 38 39CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, DeclContext *DC, 40 SourceLocation L, IdentifierInfo *Id, 41 CXXRecordDecl *PrevDecl, 42 SourceLocation TKL) 43 : RecordDecl(K, TK, DC, L, Id, PrevDecl, TKL), 44 DefinitionData(PrevDecl ? PrevDecl->DefinitionData : 0), 45 TemplateOrInstantiation() { } 46 47CXXRecordDecl *CXXRecordDecl::Create(ASTContext &C, TagKind TK, DeclContext *DC, 48 SourceLocation L, IdentifierInfo *Id, 49 SourceLocation TKL, 50 CXXRecordDecl* PrevDecl, 51 bool DelayTypeCreation) { 52 CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TK, DC, L, Id, 53 PrevDecl, TKL); 54 55 // FIXME: DelayTypeCreation seems like such a hack 56 if (!DelayTypeCreation) 57 C.getTypeDeclType(R, PrevDecl); 58 return R; 59} 60 61CXXRecordDecl::~CXXRecordDecl() { 62} 63 64void CXXRecordDecl::Destroy(ASTContext &C) { 65 if (data().Definition == this) { 66 C.Deallocate(data().Bases); 67 C.Deallocate(data().VBases); 68 C.Deallocate(&data()); 69 } 70 this->RecordDecl::Destroy(C); 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) 84 C.Deallocate(data().Bases); 85 86 int vbaseCount = 0; 87 llvm::SmallVector<const CXXBaseSpecifier*, 8> UniqueVbases; 88 bool hasDirectVirtualBase = false; 89 90 data().Bases = new(C) CXXBaseSpecifier [NumBases]; 91 data().NumBases = NumBases; 92 for (unsigned i = 0; i < NumBases; ++i) { 93 data().Bases[i] = *Bases[i]; 94 // Keep track of inherited vbases for this base class. 95 const CXXBaseSpecifier *Base = Bases[i]; 96 QualType BaseType = Base->getType(); 97 // Skip dependent types; we can't do any checking on them now. 98 if (BaseType->isDependentType()) 99 continue; 100 CXXRecordDecl *BaseClassDecl 101 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl()); 102 if (Base->isVirtual()) 103 hasDirectVirtualBase = true; 104 for (CXXRecordDecl::base_class_iterator VBase = 105 BaseClassDecl->vbases_begin(), 106 E = BaseClassDecl->vbases_end(); VBase != E; ++VBase) { 107 // Add this vbase to the array of vbases for current class if it is 108 // not already in the list. 109 // FIXME. Note that we do a linear search as number of such classes are 110 // very few. 111 int i; 112 for (i = 0; i < vbaseCount; ++i) 113 if (UniqueVbases[i]->getType() == VBase->getType()) 114 break; 115 if (i == vbaseCount) { 116 UniqueVbases.push_back(VBase); 117 ++vbaseCount; 118 } 119 } 120 } 121 if (hasDirectVirtualBase) { 122 // Iterate one more time through the direct bases and add the virtual 123 // base to the list of vritual bases for current class. 124 for (unsigned i = 0; i < NumBases; ++i) { 125 const CXXBaseSpecifier *VBase = Bases[i]; 126 if (!VBase->isVirtual()) 127 continue; 128 int j; 129 for (j = 0; j < vbaseCount; ++j) 130 if (UniqueVbases[j]->getType() == VBase->getType()) 131 break; 132 if (j == vbaseCount) { 133 UniqueVbases.push_back(VBase); 134 ++vbaseCount; 135 } 136 } 137 } 138 if (vbaseCount > 0) { 139 // build AST for inhireted, direct or indirect, virtual bases. 140 data().VBases = new (C) CXXBaseSpecifier [vbaseCount]; 141 data().NumVBases = vbaseCount; 142 for (int i = 0; i < vbaseCount; i++) { 143 QualType QT = UniqueVbases[i]->getType(); 144 // Skip dependent types; we can't do any checking on them now. 145 if (QT->isDependentType()) 146 continue; 147 CXXRecordDecl *VBaseClassDecl 148 = cast<CXXRecordDecl>(QT->getAs<RecordType>()->getDecl()); 149 data().VBases[i] = 150 CXXBaseSpecifier(VBaseClassDecl->getSourceRange(), true, 151 VBaseClassDecl->getTagKind() == RecordDecl::TK_class, 152 UniqueVbases[i]->getAccessSpecifier(), QT); 153 } 154 } 155} 156 157/// Callback function for CXXRecordDecl::forallBases that acknowledges 158/// that it saw a base class. 159static bool SawBase(const CXXRecordDecl *, void *) { 160 return true; 161} 162 163bool CXXRecordDecl::hasAnyDependentBases() const { 164 if (!isDependentContext()) 165 return false; 166 167 return !forallBases(SawBase, 0); 168} 169 170bool CXXRecordDecl::hasConstCopyConstructor(ASTContext &Context) const { 171 return getCopyConstructor(Context, Qualifiers::Const) != 0; 172} 173 174CXXConstructorDecl *CXXRecordDecl::getCopyConstructor(ASTContext &Context, 175 unsigned TypeQuals) const{ 176 QualType ClassType 177 = Context.getTypeDeclType(const_cast<CXXRecordDecl*>(this)); 178 DeclarationName ConstructorName 179 = Context.DeclarationNames.getCXXConstructorName( 180 Context.getCanonicalType(ClassType)); 181 unsigned FoundTQs; 182 DeclContext::lookup_const_iterator Con, ConEnd; 183 for (llvm::tie(Con, ConEnd) = this->lookup(ConstructorName); 184 Con != ConEnd; ++Con) { 185 // C++ [class.copy]p2: 186 // A non-template constructor for class X is a copy constructor if [...] 187 if (isa<FunctionTemplateDecl>(*Con)) 188 continue; 189 190 if (cast<CXXConstructorDecl>(*Con)->isCopyConstructor(FoundTQs)) { 191 if (((TypeQuals & Qualifiers::Const) == (FoundTQs & Qualifiers::Const)) || 192 (!(TypeQuals & Qualifiers::Const) && (FoundTQs & Qualifiers::Const))) 193 return cast<CXXConstructorDecl>(*Con); 194 195 } 196 } 197 return 0; 198} 199 200bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context, 201 const CXXMethodDecl *& MD) const { 202 QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType( 203 const_cast<CXXRecordDecl*>(this))); 204 DeclarationName OpName =Context.DeclarationNames.getCXXOperatorName(OO_Equal); 205 206 DeclContext::lookup_const_iterator Op, OpEnd; 207 for (llvm::tie(Op, OpEnd) = this->lookup(OpName); 208 Op != OpEnd; ++Op) { 209 // C++ [class.copy]p9: 210 // A user-declared copy assignment operator is a non-static non-template 211 // member function of class X with exactly one parameter of type X, X&, 212 // const X&, volatile X& or const volatile X&. 213 const CXXMethodDecl* Method = dyn_cast<CXXMethodDecl>(*Op); 214 if (!Method) 215 continue; 216 217 if (Method->isStatic()) 218 continue; 219 if (Method->getPrimaryTemplate()) 220 continue; 221 const FunctionProtoType *FnType = 222 Method->getType()->getAs<FunctionProtoType>(); 223 assert(FnType && "Overloaded operator has no prototype."); 224 // Don't assert on this; an invalid decl might have been left in the AST. 225 if (FnType->getNumArgs() != 1 || FnType->isVariadic()) 226 continue; 227 bool AcceptsConst = true; 228 QualType ArgType = FnType->getArgType(0); 229 if (const LValueReferenceType *Ref = ArgType->getAs<LValueReferenceType>()) { 230 ArgType = Ref->getPointeeType(); 231 // Is it a non-const lvalue reference? 232 if (!ArgType.isConstQualified()) 233 AcceptsConst = false; 234 } 235 if (!Context.hasSameUnqualifiedType(ArgType, ClassType)) 236 continue; 237 MD = Method; 238 // We have a single argument of type cv X or cv X&, i.e. we've found the 239 // copy assignment operator. Return whether it accepts const arguments. 240 return AcceptsConst; 241 } 242 assert(isInvalidDecl() && 243 "No copy assignment operator declared in valid code."); 244 return false; 245} 246 247void 248CXXRecordDecl::addedConstructor(ASTContext &Context, 249 CXXConstructorDecl *ConDecl) { 250 assert(!ConDecl->isImplicit() && "addedConstructor - not for implicit decl"); 251 // Note that we have a user-declared constructor. 252 data().UserDeclaredConstructor = true; 253 254 // C++ [dcl.init.aggr]p1: 255 // An aggregate is an array or a class (clause 9) with no 256 // user-declared constructors (12.1) [...]. 257 data().Aggregate = false; 258 259 // C++ [class]p4: 260 // A POD-struct is an aggregate class [...] 261 data().PlainOldData = false; 262 263 // C++ [class.ctor]p5: 264 // A constructor is trivial if it is an implicitly-declared default 265 // constructor. 266 // FIXME: C++0x: don't do this for "= default" default constructors. 267 data().HasTrivialConstructor = false; 268 269 // Note when we have a user-declared copy constructor, which will 270 // suppress the implicit declaration of a copy constructor. 271 if (ConDecl->isCopyConstructor()) { 272 data().UserDeclaredCopyConstructor = true; 273 274 // C++ [class.copy]p6: 275 // A copy constructor is trivial if it is implicitly declared. 276 // FIXME: C++0x: don't do this for "= default" copy constructors. 277 data().HasTrivialCopyConstructor = false; 278 } 279} 280 281void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context, 282 CXXMethodDecl *OpDecl) { 283 // We're interested specifically in copy assignment operators. 284 const FunctionProtoType *FnType = OpDecl->getType()->getAs<FunctionProtoType>(); 285 assert(FnType && "Overloaded operator has no proto function type."); 286 assert(FnType->getNumArgs() == 1 && !FnType->isVariadic()); 287 288 // Copy assignment operators must be non-templates. 289 if (OpDecl->getPrimaryTemplate() || OpDecl->getDescribedFunctionTemplate()) 290 return; 291 292 QualType ArgType = FnType->getArgType(0); 293 if (const LValueReferenceType *Ref = ArgType->getAs<LValueReferenceType>()) 294 ArgType = Ref->getPointeeType(); 295 296 ArgType = ArgType.getUnqualifiedType(); 297 QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType( 298 const_cast<CXXRecordDecl*>(this))); 299 300 if (!Context.hasSameUnqualifiedType(ClassType, ArgType)) 301 return; 302 303 // This is a copy assignment operator. 304 // Note on the decl that it is a copy assignment operator. 305 OpDecl->setCopyAssignment(true); 306 307 // Suppress the implicit declaration of a copy constructor. 308 data().UserDeclaredCopyAssignment = true; 309 310 // C++ [class.copy]p11: 311 // A copy assignment operator is trivial if it is implicitly declared. 312 // FIXME: C++0x: don't do this for "= default" copy operators. 313 data().HasTrivialCopyAssignment = false; 314 315 // C++ [class]p4: 316 // A POD-struct is an aggregate class that [...] has no user-defined copy 317 // assignment operator [...]. 318 data().PlainOldData = false; 319} 320 321static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) { 322 QualType T; 323 if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv)) 324 T = ConvTemp->getTemplatedDecl()->getResultType(); 325 else 326 T = cast<CXXConversionDecl>(Conv)->getConversionType(); 327 return Context.getCanonicalType(T); 328} 329 330/// Collect the visible conversions of a base class. 331/// 332/// \param Base a base class of the class we're considering 333/// \param InVirtual whether this base class is a virtual base (or a base 334/// of a virtual base) 335/// \param Access the access along the inheritance path to this base 336/// \param ParentHiddenTypes the conversions provided by the inheritors 337/// of this base 338/// \param Output the set to which to add conversions from non-virtual bases 339/// \param VOutput the set to which to add conversions from virtual bases 340/// \param HiddenVBaseCs the set of conversions which were hidden in a 341/// virtual base along some inheritance path 342static void CollectVisibleConversions(ASTContext &Context, 343 CXXRecordDecl *Record, 344 bool InVirtual, 345 AccessSpecifier Access, 346 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes, 347 UnresolvedSetImpl &Output, 348 UnresolvedSetImpl &VOutput, 349 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) { 350 // The set of types which have conversions in this class or its 351 // subclasses. As an optimization, we don't copy the derived set 352 // unless it might change. 353 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes; 354 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer; 355 356 // Collect the direct conversions and figure out which conversions 357 // will be hidden in the subclasses. 358 UnresolvedSetImpl &Cs = *Record->getConversionFunctions(); 359 if (!Cs.empty()) { 360 HiddenTypesBuffer = ParentHiddenTypes; 361 HiddenTypes = &HiddenTypesBuffer; 362 363 for (UnresolvedSetIterator I = Cs.begin(), E = Cs.end(); I != E; ++I) { 364 bool Hidden = 365 !HiddenTypesBuffer.insert(GetConversionType(Context, I.getDecl())); 366 367 // If this conversion is hidden and we're in a virtual base, 368 // remember that it's hidden along some inheritance path. 369 if (Hidden && InVirtual) 370 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())); 371 372 // If this conversion isn't hidden, add it to the appropriate output. 373 else if (!Hidden) { 374 AccessSpecifier IAccess 375 = CXXRecordDecl::MergeAccess(Access, I.getAccess()); 376 377 if (InVirtual) 378 VOutput.addDecl(I.getDecl(), IAccess); 379 else 380 Output.addDecl(I.getDecl(), IAccess); 381 } 382 } 383 } 384 385 // Collect information recursively from any base classes. 386 for (CXXRecordDecl::base_class_iterator 387 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) { 388 const RecordType *RT = I->getType()->getAs<RecordType>(); 389 if (!RT) continue; 390 391 AccessSpecifier BaseAccess 392 = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier()); 393 bool BaseInVirtual = InVirtual || I->isVirtual(); 394 395 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl()); 396 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess, 397 *HiddenTypes, Output, VOutput, HiddenVBaseCs); 398 } 399} 400 401/// Collect the visible conversions of a class. 402/// 403/// This would be extremely straightforward if it weren't for virtual 404/// bases. It might be worth special-casing that, really. 405static void CollectVisibleConversions(ASTContext &Context, 406 CXXRecordDecl *Record, 407 UnresolvedSetImpl &Output) { 408 // The collection of all conversions in virtual bases that we've 409 // found. These will be added to the output as long as they don't 410 // appear in the hidden-conversions set. 411 UnresolvedSet<8> VBaseCs; 412 413 // The set of conversions in virtual bases that we've determined to 414 // be hidden. 415 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs; 416 417 // The set of types hidden by classes derived from this one. 418 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes; 419 420 // Go ahead and collect the direct conversions and add them to the 421 // hidden-types set. 422 UnresolvedSetImpl &Cs = *Record->getConversionFunctions(); 423 Output.append(Cs.begin(), Cs.end()); 424 for (UnresolvedSetIterator I = Cs.begin(), E = Cs.end(); I != E; ++I) 425 HiddenTypes.insert(GetConversionType(Context, I.getDecl())); 426 427 // Recursively collect conversions from base classes. 428 for (CXXRecordDecl::base_class_iterator 429 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) { 430 const RecordType *RT = I->getType()->getAs<RecordType>(); 431 if (!RT) continue; 432 433 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()), 434 I->isVirtual(), I->getAccessSpecifier(), 435 HiddenTypes, Output, VBaseCs, HiddenVBaseCs); 436 } 437 438 // Add any unhidden conversions provided by virtual bases. 439 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end(); 440 I != E; ++I) { 441 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()))) 442 Output.addDecl(I.getDecl(), I.getAccess()); 443 } 444} 445 446/// getVisibleConversionFunctions - get all conversion functions visible 447/// in current class; including conversion function templates. 448const UnresolvedSetImpl *CXXRecordDecl::getVisibleConversionFunctions() { 449 // If root class, all conversions are visible. 450 if (bases_begin() == bases_end()) 451 return &data().Conversions; 452 // If visible conversion list is already evaluated, return it. 453 if (data().ComputedVisibleConversions) 454 return &data().VisibleConversions; 455 CollectVisibleConversions(getASTContext(), this, data().VisibleConversions); 456 data().ComputedVisibleConversions = true; 457 return &data().VisibleConversions; 458} 459 460void CXXRecordDecl::addConversionFunction(CXXConversionDecl *ConvDecl) { 461 assert(!ConvDecl->getDescribedFunctionTemplate() && 462 "Conversion function templates should cast to FunctionTemplateDecl."); 463 assert(ConvDecl->getDeclContext() == this && 464 "conversion function does not belong to this record"); 465 466 // We intentionally don't use the decl's access here because it 467 // hasn't been set yet. That's really just a misdesign in Sema. 468 data().Conversions.addDecl(ConvDecl); 469} 470 471void CXXRecordDecl::addConversionFunction(FunctionTemplateDecl *ConvDecl) { 472 assert(isa<CXXConversionDecl>(ConvDecl->getTemplatedDecl()) && 473 "Function template is not a conversion function template"); 474 assert(ConvDecl->getDeclContext() == this && 475 "conversion function does not belong to this record"); 476 data().Conversions.addDecl(ConvDecl); 477} 478 479 480void CXXRecordDecl::setMethodAsVirtual(FunctionDecl *Method) { 481 Method->setVirtualAsWritten(true); 482 setAggregate(false); 483 setPOD(false); 484 setEmpty(false); 485 setPolymorphic(true); 486 setHasTrivialConstructor(false); 487 setHasTrivialCopyConstructor(false); 488 setHasTrivialCopyAssignment(false); 489} 490 491CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const { 492 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 493 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom()); 494 495 return 0; 496} 497 498MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const { 499 return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>(); 500} 501 502void 503CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD, 504 TemplateSpecializationKind TSK) { 505 assert(TemplateOrInstantiation.isNull() && 506 "Previous template or instantiation?"); 507 assert(!isa<ClassTemplateSpecializationDecl>(this)); 508 TemplateOrInstantiation 509 = new (getASTContext()) MemberSpecializationInfo(RD, TSK); 510} 511 512TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{ 513 if (const ClassTemplateSpecializationDecl *Spec 514 = dyn_cast<ClassTemplateSpecializationDecl>(this)) 515 return Spec->getSpecializationKind(); 516 517 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) 518 return MSInfo->getTemplateSpecializationKind(); 519 520 return TSK_Undeclared; 521} 522 523void 524CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) { 525 if (ClassTemplateSpecializationDecl *Spec 526 = dyn_cast<ClassTemplateSpecializationDecl>(this)) { 527 Spec->setSpecializationKind(TSK); 528 return; 529 } 530 531 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) { 532 MSInfo->setTemplateSpecializationKind(TSK); 533 return; 534 } 535 536 assert(false && "Not a class template or member class specialization"); 537} 538 539CXXConstructorDecl * 540CXXRecordDecl::getDefaultConstructor(ASTContext &Context) { 541 QualType ClassType = Context.getTypeDeclType(this); 542 DeclarationName ConstructorName 543 = Context.DeclarationNames.getCXXConstructorName( 544 Context.getCanonicalType(ClassType.getUnqualifiedType())); 545 546 DeclContext::lookup_const_iterator Con, ConEnd; 547 for (llvm::tie(Con, ConEnd) = lookup(ConstructorName); 548 Con != ConEnd; ++Con) { 549 // FIXME: In C++0x, a constructor template can be a default constructor. 550 if (isa<FunctionTemplateDecl>(*Con)) 551 continue; 552 553 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con); 554 if (Constructor->isDefaultConstructor()) 555 return Constructor; 556 } 557 return 0; 558} 559 560CXXDestructorDecl *CXXRecordDecl::getDestructor(ASTContext &Context) const { 561 QualType ClassType = Context.getTypeDeclType(this); 562 563 DeclarationName Name 564 = Context.DeclarationNames.getCXXDestructorName( 565 Context.getCanonicalType(ClassType)); 566 567 DeclContext::lookup_const_iterator I, E; 568 llvm::tie(I, E) = lookup(Name); 569 assert(I != E && "Did not find a destructor!"); 570 571 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(*I); 572 assert(++I == E && "Found more than one destructor!"); 573 574 return Dtor; 575} 576 577CXXMethodDecl * 578CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD, 579 SourceLocation L, DeclarationName N, 580 QualType T, TypeSourceInfo *TInfo, 581 bool isStatic, bool isInline) { 582 return new (C) CXXMethodDecl(CXXMethod, RD, L, N, T, TInfo, 583 isStatic, isInline); 584} 585 586bool CXXMethodDecl::isUsualDeallocationFunction() const { 587 if (getOverloadedOperator() != OO_Delete && 588 getOverloadedOperator() != OO_Array_Delete) 589 return false; 590 591 // C++ [basic.stc.dynamic.deallocation]p2: 592 // A template instance is never a usual deallocation function, 593 // regardless of its signature. 594 if (getPrimaryTemplate()) 595 return false; 596 597 // C++ [basic.stc.dynamic.deallocation]p2: 598 // If a class T has a member deallocation function named operator delete 599 // with exactly one parameter, then that function is a usual (non-placement) 600 // deallocation function. [...] 601 if (getNumParams() == 1) 602 return true; 603 604 // C++ [basic.stc.dynamic.deallocation]p2: 605 // [...] If class T does not declare such an operator delete but does 606 // declare a member deallocation function named operator delete with 607 // exactly two parameters, the second of which has type std::size_t (18.1), 608 // then this function is a usual deallocation function. 609 ASTContext &Context = getASTContext(); 610 if (getNumParams() != 2 || 611 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(), 612 Context.getSizeType())) 613 return false; 614 615 // This function is a usual deallocation function if there are no 616 // single-parameter deallocation functions of the same kind. 617 for (DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName()); 618 R.first != R.second; ++R.first) { 619 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*R.first)) 620 if (FD->getNumParams() == 1) 621 return false; 622 } 623 624 return true; 625} 626 627void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) { 628 assert(MD->isCanonicalDecl() && "Method is not canonical!"); 629 assert(!MD->getParent()->isDependentContext() && 630 "Can't add an overridden method to a class template!"); 631 632 getASTContext().addOverriddenMethod(this, MD); 633} 634 635CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const { 636 return getASTContext().overridden_methods_begin(this); 637} 638 639CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const { 640 return getASTContext().overridden_methods_end(this); 641} 642 643QualType CXXMethodDecl::getThisType(ASTContext &C) const { 644 // C++ 9.3.2p1: The type of this in a member function of a class X is X*. 645 // If the member function is declared const, the type of this is const X*, 646 // if the member function is declared volatile, the type of this is 647 // volatile X*, and if the member function is declared const volatile, 648 // the type of this is const volatile X*. 649 650 assert(isInstance() && "No 'this' for static methods!"); 651 652 QualType ClassTy = C.getTypeDeclType(getParent()); 653 654 // Aesthetically we prefer not to synthesize a type as the 655 // InjectedClassNameType of a template pattern: injected class names 656 // are printed without template arguments, which might 657 // surprise/confuse/distract our poor users if they didn't 658 // explicitly write one. 659 if (isa<InjectedClassNameType>(ClassTy)) 660 ClassTy = cast<InjectedClassNameType>(ClassTy)->getUnderlyingType(); 661 662 ClassTy = C.getQualifiedType(ClassTy, 663 Qualifiers::fromCVRMask(getTypeQualifiers())); 664 return C.getPointerType(ClassTy); 665} 666 667bool CXXMethodDecl::hasInlineBody() const { 668 // If this function is a template instantiation, look at the template from 669 // which it was instantiated. 670 const FunctionDecl *CheckFn = getTemplateInstantiationPattern(); 671 if (!CheckFn) 672 CheckFn = this; 673 674 const FunctionDecl *fn; 675 return CheckFn->getBody(fn) && !fn->isOutOfLine(); 676} 677 678CXXBaseOrMemberInitializer:: 679CXXBaseOrMemberInitializer(ASTContext &Context, 680 TypeSourceInfo *TInfo, 681 SourceLocation L, Expr *Init, SourceLocation R) 682 : BaseOrMember(TInfo), Init(Init), AnonUnionMember(0), 683 LParenLoc(L), RParenLoc(R) 684{ 685} 686 687CXXBaseOrMemberInitializer:: 688CXXBaseOrMemberInitializer(ASTContext &Context, 689 FieldDecl *Member, SourceLocation MemberLoc, 690 SourceLocation L, Expr *Init, SourceLocation R) 691 : BaseOrMember(Member), MemberLocation(MemberLoc), Init(Init), 692 AnonUnionMember(0), LParenLoc(L), RParenLoc(R) 693{ 694} 695 696void CXXBaseOrMemberInitializer::Destroy(ASTContext &Context) { 697 if (Init) 698 Init->Destroy(Context); 699 this->~CXXBaseOrMemberInitializer(); 700} 701 702TypeLoc CXXBaseOrMemberInitializer::getBaseClassLoc() const { 703 if (isBaseInitializer()) 704 return BaseOrMember.get<TypeSourceInfo*>()->getTypeLoc(); 705 else 706 return TypeLoc(); 707} 708 709Type *CXXBaseOrMemberInitializer::getBaseClass() { 710 if (isBaseInitializer()) 711 return BaseOrMember.get<TypeSourceInfo*>()->getType().getTypePtr(); 712 else 713 return 0; 714} 715 716const Type *CXXBaseOrMemberInitializer::getBaseClass() const { 717 if (isBaseInitializer()) 718 return BaseOrMember.get<TypeSourceInfo*>()->getType().getTypePtr(); 719 else 720 return 0; 721} 722 723SourceLocation CXXBaseOrMemberInitializer::getSourceLocation() const { 724 if (isMemberInitializer()) 725 return getMemberLocation(); 726 727 return getBaseClassLoc().getSourceRange().getBegin(); 728} 729 730SourceRange CXXBaseOrMemberInitializer::getSourceRange() const { 731 return SourceRange(getSourceLocation(), getRParenLoc()); 732} 733 734CXXConstructorDecl * 735CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 736 SourceLocation L, DeclarationName N, 737 QualType T, TypeSourceInfo *TInfo, 738 bool isExplicit, 739 bool isInline, bool isImplicitlyDeclared) { 740 assert(N.getNameKind() == DeclarationName::CXXConstructorName && 741 "Name must refer to a constructor"); 742 return new (C) CXXConstructorDecl(RD, L, N, T, TInfo, isExplicit, isInline, 743 isImplicitlyDeclared); 744} 745 746bool CXXConstructorDecl::isDefaultConstructor() const { 747 // C++ [class.ctor]p5: 748 // A default constructor for a class X is a constructor of class 749 // X that can be called without an argument. 750 return (getNumParams() == 0) || 751 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg()); 752} 753 754bool 755CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const { 756 // C++ [class.copy]p2: 757 // A non-template constructor for class X is a copy constructor 758 // if its first parameter is of type X&, const X&, volatile X& or 759 // const volatile X&, and either there are no other parameters 760 // or else all other parameters have default arguments (8.3.6). 761 if ((getNumParams() < 1) || 762 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 763 (getPrimaryTemplate() != 0) || 764 (getDescribedFunctionTemplate() != 0)) 765 return false; 766 767 const ParmVarDecl *Param = getParamDecl(0); 768 769 // Do we have a reference type? Rvalue references don't count. 770 const LValueReferenceType *ParamRefType = 771 Param->getType()->getAs<LValueReferenceType>(); 772 if (!ParamRefType) 773 return false; 774 775 // Is it a reference to our class type? 776 ASTContext &Context = getASTContext(); 777 778 CanQualType PointeeType 779 = Context.getCanonicalType(ParamRefType->getPointeeType()); 780 CanQualType ClassTy 781 = Context.getCanonicalType(Context.getTagDeclType(getParent())); 782 if (PointeeType.getUnqualifiedType() != ClassTy) 783 return false; 784 785 // FIXME: other qualifiers? 786 787 // We have a copy constructor. 788 TypeQuals = PointeeType.getCVRQualifiers(); 789 return true; 790} 791 792bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const { 793 // C++ [class.conv.ctor]p1: 794 // A constructor declared without the function-specifier explicit 795 // that can be called with a single parameter specifies a 796 // conversion from the type of its first parameter to the type of 797 // its class. Such a constructor is called a converting 798 // constructor. 799 if (isExplicit() && !AllowExplicit) 800 return false; 801 802 return (getNumParams() == 0 && 803 getType()->getAs<FunctionProtoType>()->isVariadic()) || 804 (getNumParams() == 1) || 805 (getNumParams() > 1 && getParamDecl(1)->hasDefaultArg()); 806} 807 808bool CXXConstructorDecl::isCopyConstructorLikeSpecialization() const { 809 if ((getNumParams() < 1) || 810 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || 811 (getPrimaryTemplate() == 0) || 812 (getDescribedFunctionTemplate() != 0)) 813 return false; 814 815 const ParmVarDecl *Param = getParamDecl(0); 816 817 ASTContext &Context = getASTContext(); 818 CanQualType ParamType = Context.getCanonicalType(Param->getType()); 819 820 // Strip off the lvalue reference, if any. 821 if (CanQual<LValueReferenceType> ParamRefType 822 = ParamType->getAs<LValueReferenceType>()) 823 ParamType = ParamRefType->getPointeeType(); 824 825 826 // Is it the same as our our class type? 827 CanQualType ClassTy 828 = Context.getCanonicalType(Context.getTagDeclType(getParent())); 829 if (ParamType.getUnqualifiedType() != ClassTy) 830 return false; 831 832 return true; 833} 834 835CXXDestructorDecl * 836CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD, 837 SourceLocation L, DeclarationName N, 838 QualType T, bool isInline, 839 bool isImplicitlyDeclared) { 840 assert(N.getNameKind() == DeclarationName::CXXDestructorName && 841 "Name must refer to a destructor"); 842 return new (C) CXXDestructorDecl(RD, L, N, T, isInline, 843 isImplicitlyDeclared); 844} 845 846void 847CXXConstructorDecl::Destroy(ASTContext& C) { 848 C.Deallocate(BaseOrMemberInitializers); 849 CXXMethodDecl::Destroy(C); 850} 851 852CXXConversionDecl * 853CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD, 854 SourceLocation L, DeclarationName N, 855 QualType T, TypeSourceInfo *TInfo, 856 bool isInline, bool isExplicit) { 857 assert(N.getNameKind() == DeclarationName::CXXConversionFunctionName && 858 "Name must refer to a conversion function"); 859 return new (C) CXXConversionDecl(RD, L, N, T, TInfo, isInline, isExplicit); 860} 861 862LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C, 863 DeclContext *DC, 864 SourceLocation L, 865 LanguageIDs Lang, bool Braces) { 866 return new (C) LinkageSpecDecl(DC, L, Lang, Braces); 867} 868 869UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC, 870 SourceLocation L, 871 SourceLocation NamespaceLoc, 872 SourceRange QualifierRange, 873 NestedNameSpecifier *Qualifier, 874 SourceLocation IdentLoc, 875 NamedDecl *Used, 876 DeclContext *CommonAncestor) { 877 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used)) 878 Used = NS->getOriginalNamespace(); 879 return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierRange, 880 Qualifier, IdentLoc, Used, CommonAncestor); 881} 882 883NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() { 884 if (NamespaceAliasDecl *NA = 885 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace)) 886 return NA->getNamespace(); 887 return cast_or_null<NamespaceDecl>(NominatedNamespace); 888} 889 890NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC, 891 SourceLocation L, 892 SourceLocation AliasLoc, 893 IdentifierInfo *Alias, 894 SourceRange QualifierRange, 895 NestedNameSpecifier *Qualifier, 896 SourceLocation IdentLoc, 897 NamedDecl *Namespace) { 898 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace)) 899 Namespace = NS->getOriginalNamespace(); 900 return new (C) NamespaceAliasDecl(DC, L, AliasLoc, Alias, QualifierRange, 901 Qualifier, IdentLoc, Namespace); 902} 903 904UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, 905 SourceLocation L, SourceRange NNR, SourceLocation UL, 906 NestedNameSpecifier* TargetNNS, DeclarationName Name, 907 bool IsTypeNameArg) { 908 return new (C) UsingDecl(DC, L, NNR, UL, TargetNNS, Name, IsTypeNameArg); 909} 910 911UnresolvedUsingValueDecl * 912UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC, 913 SourceLocation UsingLoc, 914 SourceRange TargetNNR, 915 NestedNameSpecifier *TargetNNS, 916 SourceLocation TargetNameLoc, 917 DeclarationName TargetName) { 918 return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc, 919 TargetNNR, TargetNNS, 920 TargetNameLoc, TargetName); 921} 922 923UnresolvedUsingTypenameDecl * 924UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC, 925 SourceLocation UsingLoc, 926 SourceLocation TypenameLoc, 927 SourceRange TargetNNR, 928 NestedNameSpecifier *TargetNNS, 929 SourceLocation TargetNameLoc, 930 DeclarationName TargetName) { 931 return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc, 932 TargetNNR, TargetNNS, 933 TargetNameLoc, 934 TargetName.getAsIdentifierInfo()); 935} 936 937StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC, 938 SourceLocation L, Expr *AssertExpr, 939 StringLiteral *Message) { 940 return new (C) StaticAssertDecl(DC, L, AssertExpr, Message); 941} 942 943void StaticAssertDecl::Destroy(ASTContext& C) { 944 AssertExpr->Destroy(C); 945 Message->Destroy(C); 946 Decl::Destroy(C); 947} 948 949StaticAssertDecl::~StaticAssertDecl() { 950} 951 952static const char *getAccessName(AccessSpecifier AS) { 953 switch (AS) { 954 default: 955 case AS_none: 956 assert("Invalid access specifier!"); 957 return 0; 958 case AS_public: 959 return "public"; 960 case AS_private: 961 return "private"; 962 case AS_protected: 963 return "protected"; 964 } 965} 966 967const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB, 968 AccessSpecifier AS) { 969 return DB << getAccessName(AS); 970} 971 972 973