contrib/llvm/tools/clang/lib/AST/DeclCXX.cpp

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