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