• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
anchor()31 void AccessSpecDecl::anchor() { }
32 
CreateDeserialized(ASTContext & C,unsigned ID)33 AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
34   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(AccessSpecDecl));
35   return new (Mem) AccessSpecDecl(EmptyShell());
36 }
37 
DefinitionData(CXXRecordDecl * D)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() {
66 }
67 
getBasesSlowCase() const68 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
69   return Bases.get(Definition->getASTContext().getExternalSource());
70 }
71 
getVBasesSlowCase() const72 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
73   return VBases.get(Definition->getASTContext().getExternalSource());
74 }
75 
CXXRecordDecl(Kind K,TagKind TK,DeclContext * DC,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,CXXRecordDecl * PrevDecl)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 
Create(const ASTContext & C,TagKind TK,DeclContext * DC,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,CXXRecordDecl * PrevDecl,bool DelayTypeCreation)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 
CreateLambda(const ASTContext & C,DeclContext * DC,TypeSourceInfo * Info,SourceLocation Loc,bool Dependent)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 *
CreateDeserialized(const ASTContext & C,unsigned ID)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
setBases(CXXBaseSpecifier const * const * Bases,unsigned NumBases)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 
addedClassSubobject(CXXRecordDecl * Subobj)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.
SawBase(const CXXRecordDecl *,void *)371 static bool SawBase(const CXXRecordDecl *, void *) {
372   return true;
373 }
374 
hasAnyDependentBases() const375 bool CXXRecordDecl::hasAnyDependentBases() const {
376   if (!isDependentContext())
377     return false;
378 
379   return !forallBases(SawBase, 0);
380 }
381 
isTriviallyCopyable() const382 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 
markedVirtualFunctionPure()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 
addedMember(Decl * D)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.isCXX98PODType(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 
finishedDefaultedOrDeletedMember(CXXMethodDecl * D)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 
isCLike() const923 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 
getCaptureFields(llvm::DenseMap<const VarDecl *,FieldDecl * > & Captures,FieldDecl * & ThisCapture) const933 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     else if (C->capturesVariable())
946       Captures[C->getCapturedVar()] = *Field;
947   }
948 }
949 
950 
GetConversionType(ASTContext & Context,NamedDecl * Conv)951 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
952   QualType T;
953   if (isa<UsingShadowDecl>(Conv))
954     Conv = cast<UsingShadowDecl>(Conv)->getTargetDecl();
955   if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv))
956     T = ConvTemp->getTemplatedDecl()->getResultType();
957   else
958     T = cast<CXXConversionDecl>(Conv)->getConversionType();
959   return Context.getCanonicalType(T);
960 }
961 
962 /// Collect the visible conversions of a base class.
963 ///
964 /// \param Record a base class of the class we're considering
965 /// \param InVirtual whether this base class is a virtual base (or a base
966 ///   of a virtual base)
967 /// \param Access the access along the inheritance path to this base
968 /// \param ParentHiddenTypes the conversions provided by the inheritors
969 ///   of this base
970 /// \param Output the set to which to add conversions from non-virtual bases
971 /// \param VOutput the set to which to add conversions from virtual bases
972 /// \param HiddenVBaseCs the set of conversions which were hidden in a
973 ///   virtual base along some inheritance path
CollectVisibleConversions(ASTContext & Context,CXXRecordDecl * Record,bool InVirtual,AccessSpecifier Access,const llvm::SmallPtrSet<CanQualType,8> & ParentHiddenTypes,ASTUnresolvedSet & Output,UnresolvedSetImpl & VOutput,llvm::SmallPtrSet<NamedDecl *,8> & HiddenVBaseCs)974 static void CollectVisibleConversions(ASTContext &Context,
975                                       CXXRecordDecl *Record,
976                                       bool InVirtual,
977                                       AccessSpecifier Access,
978                   const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
979                                       ASTUnresolvedSet &Output,
980                                       UnresolvedSetImpl &VOutput,
981                            llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
982   // The set of types which have conversions in this class or its
983   // subclasses.  As an optimization, we don't copy the derived set
984   // unless it might change.
985   const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
986   llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
987 
988   // Collect the direct conversions and figure out which conversions
989   // will be hidden in the subclasses.
990   CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
991   CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
992   if (ConvI != ConvE) {
993     HiddenTypesBuffer = ParentHiddenTypes;
994     HiddenTypes = &HiddenTypesBuffer;
995 
996     for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
997       CanQualType ConvType(GetConversionType(Context, I.getDecl()));
998       bool Hidden = ParentHiddenTypes.count(ConvType);
999       if (!Hidden)
1000         HiddenTypesBuffer.insert(ConvType);
1001 
1002       // If this conversion is hidden and we're in a virtual base,
1003       // remember that it's hidden along some inheritance path.
1004       if (Hidden && InVirtual)
1005         HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1006 
1007       // If this conversion isn't hidden, add it to the appropriate output.
1008       else if (!Hidden) {
1009         AccessSpecifier IAccess
1010           = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1011 
1012         if (InVirtual)
1013           VOutput.addDecl(I.getDecl(), IAccess);
1014         else
1015           Output.addDecl(Context, I.getDecl(), IAccess);
1016       }
1017     }
1018   }
1019 
1020   // Collect information recursively from any base classes.
1021   for (CXXRecordDecl::base_class_iterator
1022          I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1023     const RecordType *RT = I->getType()->getAs<RecordType>();
1024     if (!RT) continue;
1025 
1026     AccessSpecifier BaseAccess
1027       = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier());
1028     bool BaseInVirtual = InVirtual || I->isVirtual();
1029 
1030     CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1031     CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1032                               *HiddenTypes, Output, VOutput, HiddenVBaseCs);
1033   }
1034 }
1035 
1036 /// Collect the visible conversions of a class.
1037 ///
1038 /// This would be extremely straightforward if it weren't for virtual
1039 /// bases.  It might be worth special-casing that, really.
CollectVisibleConversions(ASTContext & Context,CXXRecordDecl * Record,ASTUnresolvedSet & Output)1040 static void CollectVisibleConversions(ASTContext &Context,
1041                                       CXXRecordDecl *Record,
1042                                       ASTUnresolvedSet &Output) {
1043   // The collection of all conversions in virtual bases that we've
1044   // found.  These will be added to the output as long as they don't
1045   // appear in the hidden-conversions set.
1046   UnresolvedSet<8> VBaseCs;
1047 
1048   // The set of conversions in virtual bases that we've determined to
1049   // be hidden.
1050   llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1051 
1052   // The set of types hidden by classes derived from this one.
1053   llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1054 
1055   // Go ahead and collect the direct conversions and add them to the
1056   // hidden-types set.
1057   CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1058   CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1059   Output.append(Context, ConvI, ConvE);
1060   for (; ConvI != ConvE; ++ConvI)
1061     HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
1062 
1063   // Recursively collect conversions from base classes.
1064   for (CXXRecordDecl::base_class_iterator
1065          I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1066     const RecordType *RT = I->getType()->getAs<RecordType>();
1067     if (!RT) continue;
1068 
1069     CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
1070                               I->isVirtual(), I->getAccessSpecifier(),
1071                               HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1072   }
1073 
1074   // Add any unhidden conversions provided by virtual bases.
1075   for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1076          I != E; ++I) {
1077     if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
1078       Output.addDecl(Context, I.getDecl(), I.getAccess());
1079   }
1080 }
1081 
1082 /// getVisibleConversionFunctions - get all conversion functions visible
1083 /// in current class; including conversion function templates.
1084 std::pair<CXXRecordDecl::conversion_iterator,CXXRecordDecl::conversion_iterator>
getVisibleConversionFunctions()1085 CXXRecordDecl::getVisibleConversionFunctions() {
1086   // If root class, all conversions are visible.
1087   if (bases_begin() == bases_end())
1088     return std::make_pair(data().Conversions.begin(), data().Conversions.end());
1089   // If visible conversion list is already evaluated, return it.
1090   if (!data().ComputedVisibleConversions) {
1091     CollectVisibleConversions(getASTContext(), this, data().VisibleConversions);
1092     data().ComputedVisibleConversions = true;
1093   }
1094   return std::make_pair(data().VisibleConversions.begin(),
1095                         data().VisibleConversions.end());
1096 }
1097 
removeConversion(const NamedDecl * ConvDecl)1098 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1099   // This operation is O(N) but extremely rare.  Sema only uses it to
1100   // remove UsingShadowDecls in a class that were followed by a direct
1101   // declaration, e.g.:
1102   //   class A : B {
1103   //     using B::operator int;
1104   //     operator int();
1105   //   };
1106   // This is uncommon by itself and even more uncommon in conjunction
1107   // with sufficiently large numbers of directly-declared conversions
1108   // that asymptotic behavior matters.
1109 
1110   ASTUnresolvedSet &Convs = data().Conversions;
1111   for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1112     if (Convs[I].getDecl() == ConvDecl) {
1113       Convs.erase(I);
1114       assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1115              && "conversion was found multiple times in unresolved set");
1116       return;
1117     }
1118   }
1119 
1120   llvm_unreachable("conversion not found in set!");
1121 }
1122 
getInstantiatedFromMemberClass() const1123 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1124   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1125     return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1126 
1127   return 0;
1128 }
1129 
1130 void
setInstantiationOfMemberClass(CXXRecordDecl * RD,TemplateSpecializationKind TSK)1131 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1132                                              TemplateSpecializationKind TSK) {
1133   assert(TemplateOrInstantiation.isNull() &&
1134          "Previous template or instantiation?");
1135   assert(!isa<ClassTemplateSpecializationDecl>(this));
1136   TemplateOrInstantiation
1137     = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1138 }
1139 
getTemplateSpecializationKind() const1140 TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1141   if (const ClassTemplateSpecializationDecl *Spec
1142         = dyn_cast<ClassTemplateSpecializationDecl>(this))
1143     return Spec->getSpecializationKind();
1144 
1145   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1146     return MSInfo->getTemplateSpecializationKind();
1147 
1148   return TSK_Undeclared;
1149 }
1150 
1151 void
setTemplateSpecializationKind(TemplateSpecializationKind TSK)1152 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1153   if (ClassTemplateSpecializationDecl *Spec
1154       = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1155     Spec->setSpecializationKind(TSK);
1156     return;
1157   }
1158 
1159   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1160     MSInfo->setTemplateSpecializationKind(TSK);
1161     return;
1162   }
1163 
1164   llvm_unreachable("Not a class template or member class specialization");
1165 }
1166 
getDestructor() const1167 CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1168   ASTContext &Context = getASTContext();
1169   QualType ClassType = Context.getTypeDeclType(this);
1170 
1171   DeclarationName Name
1172     = Context.DeclarationNames.getCXXDestructorName(
1173                                           Context.getCanonicalType(ClassType));
1174 
1175   DeclContext::lookup_const_result R = lookup(Name);
1176   if (R.empty())
1177     return 0;
1178 
1179   CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
1180   return Dtor;
1181 }
1182 
completeDefinition()1183 void CXXRecordDecl::completeDefinition() {
1184   completeDefinition(0);
1185 }
1186 
completeDefinition(CXXFinalOverriderMap * FinalOverriders)1187 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1188   RecordDecl::completeDefinition();
1189 
1190   if (hasObjectMember() && getASTContext().getLangOpts().ObjCAutoRefCount) {
1191     // Objective-C Automatic Reference Counting:
1192     //   If a class has a non-static data member of Objective-C pointer
1193     //   type (or array thereof), it is a non-POD type and its
1194     //   default constructor (if any), copy constructor, move constructor,
1195     //   copy assignment operator, move assignment operator, and destructor are
1196     //   non-trivial.
1197     struct DefinitionData &Data = data();
1198     Data.PlainOldData = false;
1199     Data.HasTrivialSpecialMembers = 0;
1200     Data.HasIrrelevantDestructor = false;
1201   }
1202 
1203   // If the class may be abstract (but hasn't been marked as such), check for
1204   // any pure final overriders.
1205   if (mayBeAbstract()) {
1206     CXXFinalOverriderMap MyFinalOverriders;
1207     if (!FinalOverriders) {
1208       getFinalOverriders(MyFinalOverriders);
1209       FinalOverriders = &MyFinalOverriders;
1210     }
1211 
1212     bool Done = false;
1213     for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1214                                      MEnd = FinalOverriders->end();
1215          M != MEnd && !Done; ++M) {
1216       for (OverridingMethods::iterator SO = M->second.begin(),
1217                                     SOEnd = M->second.end();
1218            SO != SOEnd && !Done; ++SO) {
1219         assert(SO->second.size() > 0 &&
1220                "All virtual functions have overridding virtual functions");
1221 
1222         // C++ [class.abstract]p4:
1223         //   A class is abstract if it contains or inherits at least one
1224         //   pure virtual function for which the final overrider is pure
1225         //   virtual.
1226         if (SO->second.front().Method->isPure()) {
1227           data().Abstract = true;
1228           Done = true;
1229           break;
1230         }
1231       }
1232     }
1233   }
1234 
1235   // Set access bits correctly on the directly-declared conversions.
1236   for (UnresolvedSetIterator I = data().Conversions.begin(),
1237                              E = data().Conversions.end();
1238        I != E; ++I)
1239     I.setAccess((*I)->getAccess());
1240 }
1241 
mayBeAbstract() const1242 bool CXXRecordDecl::mayBeAbstract() const {
1243   if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1244       isDependentContext())
1245     return false;
1246 
1247   for (CXXRecordDecl::base_class_const_iterator B = bases_begin(),
1248                                              BEnd = bases_end();
1249        B != BEnd; ++B) {
1250     CXXRecordDecl *BaseDecl
1251       = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl());
1252     if (BaseDecl->isAbstract())
1253       return true;
1254   }
1255 
1256   return false;
1257 }
1258 
anchor()1259 void CXXMethodDecl::anchor() { }
1260 
isStatic() const1261 bool CXXMethodDecl::isStatic() const {
1262   const CXXMethodDecl *MD = getCanonicalDecl();
1263 
1264   if (MD->getStorageClass() == SC_Static)
1265     return true;
1266 
1267   DeclarationName Name = getDeclName();
1268   // [class.free]p1:
1269   // Any allocation function for a class T is a static member
1270   // (even if not explicitly declared static).
1271   if (Name.getCXXOverloadedOperator() == OO_New ||
1272       Name.getCXXOverloadedOperator() == OO_Array_New)
1273     return true;
1274 
1275   // [class.free]p6 Any deallocation function for a class X is a static member
1276   // (even if not explicitly declared static).
1277   if (Name.getCXXOverloadedOperator() == OO_Delete ||
1278       Name.getCXXOverloadedOperator() == OO_Array_Delete)
1279     return true;
1280 
1281   return false;
1282 }
1283 
recursivelyOverrides(const CXXMethodDecl * DerivedMD,const CXXMethodDecl * BaseMD)1284 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1285                                  const CXXMethodDecl *BaseMD) {
1286   for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
1287          E = DerivedMD->end_overridden_methods(); I != E; ++I) {
1288     const CXXMethodDecl *MD = *I;
1289     if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1290       return true;
1291     if (recursivelyOverrides(MD, BaseMD))
1292       return true;
1293   }
1294   return false;
1295 }
1296 
1297 CXXMethodDecl *
getCorrespondingMethodInClass(const CXXRecordDecl * RD,bool MayBeBase)1298 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1299                                              bool MayBeBase) {
1300   if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1301     return this;
1302 
1303   // Lookup doesn't work for destructors, so handle them separately.
1304   if (isa<CXXDestructorDecl>(this)) {
1305     CXXMethodDecl *MD = RD->getDestructor();
1306     if (MD) {
1307       if (recursivelyOverrides(MD, this))
1308         return MD;
1309       if (MayBeBase && recursivelyOverrides(this, MD))
1310         return MD;
1311     }
1312     return NULL;
1313   }
1314 
1315   lookup_const_result Candidates = RD->lookup(getDeclName());
1316   for (NamedDecl * const * I = Candidates.begin(); I != Candidates.end(); ++I) {
1317     CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I);
1318     if (!MD)
1319       continue;
1320     if (recursivelyOverrides(MD, this))
1321       return MD;
1322     if (MayBeBase && recursivelyOverrides(this, MD))
1323       return MD;
1324   }
1325 
1326   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1327          E = RD->bases_end(); I != E; ++I) {
1328     const RecordType *RT = I->getType()->getAs<RecordType>();
1329     if (!RT)
1330       continue;
1331     const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1332     CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1333     if (T)
1334       return T;
1335   }
1336 
1337   return NULL;
1338 }
1339 
1340 CXXMethodDecl *
Create(ASTContext & C,CXXRecordDecl * RD,SourceLocation StartLoc,const DeclarationNameInfo & NameInfo,QualType T,TypeSourceInfo * TInfo,StorageClass SC,bool isInline,bool isConstexpr,SourceLocation EndLocation)1341 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1342                       SourceLocation StartLoc,
1343                       const DeclarationNameInfo &NameInfo,
1344                       QualType T, TypeSourceInfo *TInfo,
1345                       StorageClass SC, bool isInline,
1346                       bool isConstexpr, SourceLocation EndLocation) {
1347   return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo,
1348                                SC, isInline, isConstexpr,
1349                                EndLocation);
1350 }
1351 
CreateDeserialized(ASTContext & C,unsigned ID)1352 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1353   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXMethodDecl));
1354   return new (Mem) CXXMethodDecl(CXXMethod, 0, SourceLocation(),
1355                                  DeclarationNameInfo(), QualType(),
1356                                  0, SC_None, false, false,
1357                                  SourceLocation());
1358 }
1359 
isUsualDeallocationFunction() const1360 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1361   if (getOverloadedOperator() != OO_Delete &&
1362       getOverloadedOperator() != OO_Array_Delete)
1363     return false;
1364 
1365   // C++ [basic.stc.dynamic.deallocation]p2:
1366   //   A template instance is never a usual deallocation function,
1367   //   regardless of its signature.
1368   if (getPrimaryTemplate())
1369     return false;
1370 
1371   // C++ [basic.stc.dynamic.deallocation]p2:
1372   //   If a class T has a member deallocation function named operator delete
1373   //   with exactly one parameter, then that function is a usual (non-placement)
1374   //   deallocation function. [...]
1375   if (getNumParams() == 1)
1376     return true;
1377 
1378   // C++ [basic.stc.dynamic.deallocation]p2:
1379   //   [...] If class T does not declare such an operator delete but does
1380   //   declare a member deallocation function named operator delete with
1381   //   exactly two parameters, the second of which has type std::size_t (18.1),
1382   //   then this function is a usual deallocation function.
1383   ASTContext &Context = getASTContext();
1384   if (getNumParams() != 2 ||
1385       !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1386                                       Context.getSizeType()))
1387     return false;
1388 
1389   // This function is a usual deallocation function if there are no
1390   // single-parameter deallocation functions of the same kind.
1391   DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
1392   for (DeclContext::lookup_const_result::iterator I = R.begin(), E = R.end();
1393        I != E; ++I) {
1394     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
1395       if (FD->getNumParams() == 1)
1396         return false;
1397   }
1398 
1399   return true;
1400 }
1401 
isCopyAssignmentOperator() const1402 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1403   // C++0x [class.copy]p17:
1404   //  A user-declared copy assignment operator X::operator= is a non-static
1405   //  non-template member function of class X with exactly one parameter of
1406   //  type X, X&, const X&, volatile X& or const volatile X&.
1407   if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1408       /*non-static*/ isStatic() ||
1409       /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1410       getNumParams() != 1)
1411     return false;
1412 
1413   QualType ParamType = getParamDecl(0)->getType();
1414   if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1415     ParamType = Ref->getPointeeType();
1416 
1417   ASTContext &Context = getASTContext();
1418   QualType ClassType
1419     = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1420   return Context.hasSameUnqualifiedType(ClassType, ParamType);
1421 }
1422 
isMoveAssignmentOperator() const1423 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1424   // C++0x [class.copy]p19:
1425   //  A user-declared move assignment operator X::operator= is a non-static
1426   //  non-template member function of class X with exactly one parameter of type
1427   //  X&&, const X&&, volatile X&&, or const volatile X&&.
1428   if (getOverloadedOperator() != OO_Equal || isStatic() ||
1429       getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1430       getNumParams() != 1)
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 
addOverriddenMethod(const CXXMethodDecl * MD)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 
begin_overridden_methods() const1453 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
1454   if (isa<CXXConstructorDecl>(this)) return 0;
1455   return getASTContext().overridden_methods_begin(this);
1456 }
1457 
end_overridden_methods() const1458 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
1459   if (isa<CXXConstructorDecl>(this)) return 0;
1460   return getASTContext().overridden_methods_end(this);
1461 }
1462 
size_overridden_methods() const1463 unsigned CXXMethodDecl::size_overridden_methods() const {
1464   if (isa<CXXConstructorDecl>(this)) return 0;
1465   return getASTContext().overridden_methods_size(this);
1466 }
1467 
getThisType(ASTContext & C) const1468 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 
hasInlineBody() const1483 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 
isLambdaStaticInvoker() const1494 bool CXXMethodDecl::isLambdaStaticInvoker() const {
1495   return getParent()->isLambda() &&
1496          getIdentifier() && getIdentifier()->getName() == "__invoke";
1497 }
1498 
1499 
CXXCtorInitializer(ASTContext & Context,TypeSourceInfo * TInfo,bool IsVirtual,SourceLocation L,Expr * Init,SourceLocation R,SourceLocation EllipsisLoc)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 
CXXCtorInitializer(ASTContext & Context,FieldDecl * Member,SourceLocation MemberLoc,SourceLocation L,Expr * Init,SourceLocation R)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 
CXXCtorInitializer(ASTContext & Context,IndirectFieldDecl * Member,SourceLocation MemberLoc,SourceLocation L,Expr * Init,SourceLocation R)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 
CXXCtorInitializer(ASTContext & Context,TypeSourceInfo * TInfo,SourceLocation L,Expr * Init,SourceLocation R)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 
CXXCtorInitializer(ASTContext & Context,FieldDecl * Member,SourceLocation MemberLoc,SourceLocation L,Expr * Init,SourceLocation R,VarDecl ** Indices,unsigned NumIndices)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 
Create(ASTContext & Context,FieldDecl * Member,SourceLocation MemberLoc,SourceLocation L,Expr * Init,SourceLocation R,VarDecl ** Indices,unsigned NumIndices)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 
getBaseClassLoc() const1572 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
1573   if (isBaseInitializer())
1574     return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
1575   else
1576     return TypeLoc();
1577 }
1578 
getBaseClass() const1579 const Type *CXXCtorInitializer::getBaseClass() const {
1580   if (isBaseInitializer())
1581     return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1582   else
1583     return 0;
1584 }
1585 
getSourceLocation() const1586 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 
getSourceRange() const1599 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 
anchor()1610 void CXXConstructorDecl::anchor() { }
1611 
1612 CXXConstructorDecl *
CreateDeserialized(ASTContext & C,unsigned ID)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 *
Create(ASTContext & C,CXXRecordDecl * RD,SourceLocation StartLoc,const DeclarationNameInfo & NameInfo,QualType T,TypeSourceInfo * TInfo,bool isExplicit,bool isInline,bool isImplicitlyDeclared,bool isConstexpr)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 
getTargetConstructor() const1634 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 
isDefaultConstructor() const1643 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
isCopyConstructor(unsigned & TypeQuals) const1652 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
1653   return isCopyOrMoveConstructor(TypeQuals) &&
1654          getParamDecl(0)->getType()->isLValueReferenceType();
1655 }
1656 
isMoveConstructor(unsigned & TypeQuals) const1657 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.
isCopyOrMoveConstructor(unsigned & TypeQuals) const1663 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 
isConvertingConstructor(bool AllowExplicit) const1704 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 
isSpecializationCopyingObject() const1722 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 
getInheritedConstructor() const1743 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
setInheritedConstructor(const CXXConstructorDecl * BaseCtor)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 
anchor()1760 void CXXDestructorDecl::anchor() { }
1761 
1762 CXXDestructorDecl *
CreateDeserialized(ASTContext & C,unsigned ID)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 *
Create(ASTContext & C,CXXRecordDecl * RD,SourceLocation StartLoc,const DeclarationNameInfo & NameInfo,QualType T,TypeSourceInfo * TInfo,bool isInline,bool isImplicitlyDeclared)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 
anchor()1782 void CXXConversionDecl::anchor() { }
1783 
1784 CXXConversionDecl *
CreateDeserialized(ASTContext & C,unsigned ID)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 *
Create(ASTContext & C,CXXRecordDecl * RD,SourceLocation StartLoc,const DeclarationNameInfo & NameInfo,QualType T,TypeSourceInfo * TInfo,bool isInline,bool isExplicit,bool isConstexpr,SourceLocation EndLocation)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 
isLambdaToBlockPointerConversion() const1807 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1808   return isImplicit() && getParent()->isLambda() &&
1809          getConversionType()->isBlockPointerType();
1810 }
1811 
anchor()1812 void LinkageSpecDecl::anchor() { }
1813 
Create(ASTContext & C,DeclContext * DC,SourceLocation ExternLoc,SourceLocation LangLoc,LanguageIDs Lang,bool HasBraces)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 
CreateDeserialized(ASTContext & C,unsigned ID)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 
anchor()1829 void UsingDirectiveDecl::anchor() { }
1830 
Create(ASTContext & C,DeclContext * DC,SourceLocation L,SourceLocation NamespaceLoc,NestedNameSpecifierLoc QualifierLoc,SourceLocation IdentLoc,NamedDecl * Used,DeclContext * CommonAncestor)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 *
CreateDeserialized(ASTContext & C,unsigned ID)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 
getNominatedNamespace()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 
anchor()1859 void NamespaceDecl::anchor() { }
1860 
NamespaceDecl(DeclContext * DC,bool Inline,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,NamespaceDecl * PrevDecl)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 
Create(ASTContext & C,DeclContext * DC,bool Inline,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,NamespaceDecl * PrevDecl)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 
CreateDeserialized(ASTContext & C,unsigned ID)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 
anchor()1887 void NamespaceAliasDecl::anchor() { }
1888 
Create(ASTContext & C,DeclContext * DC,SourceLocation UsingLoc,SourceLocation AliasLoc,IdentifierInfo * Alias,NestedNameSpecifierLoc QualifierLoc,SourceLocation IdentLoc,NamedDecl * Namespace)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 *
CreateDeserialized(ASTContext & C,unsigned ID)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 
anchor()1910 void UsingShadowDecl::anchor() { }
1911 
1912 UsingShadowDecl *
CreateDeserialized(ASTContext & C,unsigned ID)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 
getUsingDecl() const1918 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 
anchor()1926 void UsingDecl::anchor() { }
1927 
addShadowDecl(UsingShadowDecl * S)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 
removeShadowDecl(UsingShadowDecl * S)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 
Create(ASTContext & C,DeclContext * DC,SourceLocation UL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,bool HasTypename)1959 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
1960                              NestedNameSpecifierLoc QualifierLoc,
1961                              const DeclarationNameInfo &NameInfo,
1962                              bool HasTypename) {
1963   return new (C) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
1964 }
1965 
CreateDeserialized(ASTContext & C,unsigned ID)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 
getSourceRange() const1972 SourceRange UsingDecl::getSourceRange() const {
1973   SourceLocation Begin = isAccessDeclaration()
1974     ? getQualifierLoc().getBeginLoc() : UsingLocation;
1975   return SourceRange(Begin, getNameInfo().getEndLoc());
1976 }
1977 
anchor()1978 void UnresolvedUsingValueDecl::anchor() { }
1979 
1980 UnresolvedUsingValueDecl *
Create(ASTContext & C,DeclContext * DC,SourceLocation UsingLoc,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo)1981 UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
1982                                  SourceLocation UsingLoc,
1983                                  NestedNameSpecifierLoc QualifierLoc,
1984                                  const DeclarationNameInfo &NameInfo) {
1985   return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
1986                                           QualifierLoc, NameInfo);
1987 }
1988 
1989 UnresolvedUsingValueDecl *
CreateDeserialized(ASTContext & C,unsigned ID)1990 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1991   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UnresolvedUsingValueDecl));
1992   return new (Mem) UnresolvedUsingValueDecl(0, QualType(), SourceLocation(),
1993                                             NestedNameSpecifierLoc(),
1994                                             DeclarationNameInfo());
1995 }
1996 
getSourceRange() const1997 SourceRange UnresolvedUsingValueDecl::getSourceRange() const {
1998   SourceLocation Begin = isAccessDeclaration()
1999     ? getQualifierLoc().getBeginLoc() : UsingLocation;
2000   return SourceRange(Begin, getNameInfo().getEndLoc());
2001 }
2002 
anchor()2003 void UnresolvedUsingTypenameDecl::anchor() { }
2004 
2005 UnresolvedUsingTypenameDecl *
Create(ASTContext & C,DeclContext * DC,SourceLocation UsingLoc,SourceLocation TypenameLoc,NestedNameSpecifierLoc QualifierLoc,SourceLocation TargetNameLoc,DeclarationName TargetName)2006 UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
2007                                     SourceLocation UsingLoc,
2008                                     SourceLocation TypenameLoc,
2009                                     NestedNameSpecifierLoc QualifierLoc,
2010                                     SourceLocation TargetNameLoc,
2011                                     DeclarationName TargetName) {
2012   return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc,
2013                                              QualifierLoc, TargetNameLoc,
2014                                              TargetName.getAsIdentifierInfo());
2015 }
2016 
2017 UnresolvedUsingTypenameDecl *
CreateDeserialized(ASTContext & C,unsigned ID)2018 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2019   void *Mem = AllocateDeserializedDecl(C, ID,
2020                                        sizeof(UnresolvedUsingTypenameDecl));
2021   return new (Mem) UnresolvedUsingTypenameDecl(0, SourceLocation(),
2022                                                SourceLocation(),
2023                                                NestedNameSpecifierLoc(),
2024                                                SourceLocation(),
2025                                                0);
2026 }
2027 
anchor()2028 void StaticAssertDecl::anchor() { }
2029 
Create(ASTContext & C,DeclContext * DC,SourceLocation StaticAssertLoc,Expr * AssertExpr,StringLiteral * Message,SourceLocation RParenLoc,bool Failed)2030 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
2031                                            SourceLocation StaticAssertLoc,
2032                                            Expr *AssertExpr,
2033                                            StringLiteral *Message,
2034                                            SourceLocation RParenLoc,
2035                                            bool Failed) {
2036   return new (C) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2037                                   RParenLoc, Failed);
2038 }
2039 
CreateDeserialized(ASTContext & C,unsigned ID)2040 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
2041                                                        unsigned ID) {
2042   void *Mem = AllocateDeserializedDecl(C, ID, sizeof(StaticAssertDecl));
2043   return new (Mem) StaticAssertDecl(0, SourceLocation(), 0, 0,
2044                                     SourceLocation(), false);
2045 }
2046 
getAccessName(AccessSpecifier AS)2047 static const char *getAccessName(AccessSpecifier AS) {
2048   switch (AS) {
2049     case AS_none:
2050       llvm_unreachable("Invalid access specifier!");
2051     case AS_public:
2052       return "public";
2053     case AS_private:
2054       return "private";
2055     case AS_protected:
2056       return "protected";
2057   }
2058   llvm_unreachable("Invalid access specifier!");
2059 }
2060 
operator <<(const DiagnosticBuilder & DB,AccessSpecifier AS)2061 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2062                                            AccessSpecifier AS) {
2063   return DB << getAccessName(AS);
2064 }
2065 
operator <<(const PartialDiagnostic & DB,AccessSpecifier AS)2066 const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2067                                            AccessSpecifier AS) {
2068   return DB << getAccessName(AS);
2069 }
2070