1 //===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C++ related Decl classes.
12 //===----------------------------------------------------------------------===//
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;
27 //===----------------------------------------------------------------------===//
28 // Decl Allocation/Deallocation Method Implementations
29 //===----------------------------------------------------------------------===//
31 void AccessSpecDecl::anchor() { }
33 AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
34 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(AccessSpecDecl));
35 return new (Mem) AccessSpecDecl(EmptyShell());
38 CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
39 : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
40 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
41 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
42 HasPrivateFields(false), HasProtectedFields(false), HasPublicFields(false),
43 HasMutableFields(false), HasOnlyCMembers(true),
44 HasInClassInitializer(false), HasUninitializedReferenceMember(false),
45 NeedOverloadResolutionForMoveConstructor(false),
46 NeedOverloadResolutionForMoveAssignment(false),
47 NeedOverloadResolutionForDestructor(false),
48 DefaultedMoveConstructorIsDeleted(false),
49 DefaultedMoveAssignmentIsDeleted(false),
50 DefaultedDestructorIsDeleted(false),
51 HasTrivialSpecialMembers(SMF_All),
52 DeclaredNonTrivialSpecialMembers(0),
53 HasIrrelevantDestructor(true),
54 HasConstexprNonCopyMoveConstructor(false),
55 DefaultedDefaultConstructorIsConstexpr(true),
56 HasConstexprDefaultConstructor(false),
57 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
58 UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
59 ImplicitCopyConstructorHasConstParam(true),
60 ImplicitCopyAssignmentHasConstParam(true),
61 HasDeclaredCopyConstructorWithConstParam(false),
62 HasDeclaredCopyAssignmentWithConstParam(false),
63 FailedImplicitMoveConstructor(false), FailedImplicitMoveAssignment(false),
64 IsLambda(false), NumBases(0), NumVBases(0), Bases(), VBases(),
65 Definition(D), FirstFriend(0) {
68 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
69 return Bases.get(Definition->getASTContext().getExternalSource());
72 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
73 return VBases.get(Definition->getASTContext().getExternalSource());
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() { }
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,
90 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
92 // FIXME: DelayTypeCreation seems like such a hack
93 if (!DelayTypeCreation)
94 C.getTypeDeclType(R, PrevDecl);
98 CXXRecordDecl *CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
99 TypeSourceInfo *Info, SourceLocation Loc,
101 CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TTK_Class, DC, Loc, Loc,
103 R->IsBeingDefined = true;
104 R->DefinitionData = new (C) struct LambdaDefinitionData(R, Info, Dependent);
105 R->MayHaveOutOfDateDef = false;
106 C.getTypeDeclType(R, /*PrevDecl=*/0);
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(),
116 R->MayHaveOutOfDateDef = false;
121 CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
123 ASTContext &C = getASTContext();
125 if (!data().Bases.isOffset() && data().NumBases > 0)
126 C.Deallocate(data().getBases());
129 // C++ [dcl.init.aggr]p1:
130 // An aggregate is [...] a class with [...] no base classes [...].
131 data().Aggregate = false;
134 // A POD-struct is an aggregate class...
135 data().PlainOldData = false;
138 // The set of seen virtual base types.
139 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
141 // The virtual bases of this class.
142 SmallVector<const CXXBaseSpecifier *, 8> VBases;
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())
154 CXXRecordDecl *BaseClassDecl
155 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
157 // A class with a non-empty base class is not empty.
158 // FIXME: Standard ref?
159 if (!BaseClassDecl->isEmpty()) {
162 // A standard-layout class is a class that:
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;
172 data().Empty = false;
173 data().HasNoNonEmptyBases = false;
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;
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;
188 // Record if this base is the first non-literal field or base.
189 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType())
190 data().HasNonLiteralTypeFieldsOrBases = true;
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);
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;
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);
216 // C++0x [meta.unary.prop] is_empty:
217 // T is a class type, but not a union type, with ... no virtual base
219 data().Empty = false;
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;
228 // A standard-layout class is a class that: [...]
229 // -- has [...] no virtual base classes
230 data().IsStandardLayout = false;
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;
237 // C++ [class.ctor]p5:
238 // A default constructor is trivial [...] if:
239 // -- all the direct base classes of its class have trivial default
241 if (!BaseClassDecl->hasTrivialDefaultConstructor())
242 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
244 // C++0x [class.copy]p13:
245 // A copy/move constructor for class X is trivial if [...]
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
255 if (!BaseClassDecl->hasTrivialMoveConstructor())
256 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
258 // C++0x [class.copy]p27:
259 // A copy/move assignment operator for class X is trivial if [...]
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
269 if (!BaseClassDecl->hasTrivialMoveAssignment())
270 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
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;
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;
286 if (!BaseClassDecl->hasIrrelevantDestructor())
287 data().HasIrrelevantDestructor = false;
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;
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;
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);
310 if (BaseClassDecl->hasVolatileMember())
311 setHasVolatileMember(true);
313 // Keep track of the presence of mutable fields.
314 if (BaseClassDecl->hasMutableFields())
315 data().HasMutableFields = true;
317 if (BaseClassDecl->hasUninitializedReferenceMember())
318 data().HasUninitializedReferenceMember = true;
320 addedClassSubobject(BaseClassDecl);
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];
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
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;
347 // C++11 [class.copy]p23:
348 // A defaulted copy/move assignment operator for a class X is defined as
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;
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
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;
369 /// Callback function for CXXRecordDecl::forallBases that acknowledges
370 /// that it saw a base class.
371 static bool SawBase(const CXXRecordDecl *, void *) {
375 bool CXXRecordDecl::hasAnyDependentBases() const {
376 if (!isDependentContext())
379 return !forallBases(SawBase, 0);
382 bool CXXRecordDecl::isTriviallyCopyable() const {
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;
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;
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;
413 // Ignore friends and invalid declarations.
414 if (D->getFriendObjectKind() || D->isInvalidDecl())
417 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
419 D = FunTmpl->getTemplatedDecl();
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;
428 // A POD-struct is an aggregate class...
429 data().PlainOldData = false;
431 // Virtual functions make the class non-empty.
432 // FIXME: Standard ref?
433 data().Empty = false;
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;
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;
447 // A standard-layout class is a class that: [...]
448 // -- has no virtual functions
449 data().IsStandardLayout = false;
453 // Notify the listener if an implicit member was added after the definition
455 if (!isBeingDefined() && D->isImplicit())
456 if (ASTMutationListener *L = getASTMutationListener())
457 L->AddedCXXImplicitMember(data().Definition, D);
459 // The kind of special member this declaration is, if any.
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;
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;
475 // Technically, "user-provided" is only defined for special member
476 // functions, but the intent of the standard is clearly that it should apply
478 bool UserProvided = Constructor->isUserProvided();
480 if (Constructor->isDefaultConstructor()) {
481 SMKind |= SMF_DefaultConstructor;
484 data().UserProvidedDefaultConstructor = true;
485 if (Constructor->isConstexpr())
486 data().HasConstexprDefaultConstructor = true;
491 if (Constructor->isCopyConstructor(Quals)) {
492 SMKind |= SMF_CopyConstructor;
494 if (Quals & Qualifiers::Const)
495 data().HasDeclaredCopyConstructorWithConstParam = true;
496 } else if (Constructor->isMoveConstructor())
497 SMKind |= SMF_MoveConstructor;
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;
505 // C++ [dcl.init.aggr]p1:
506 // An aggregate is an array or a class with no user-declared
507 // constructors [...].
508 // C++0x [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;
516 // Handle destructors.
517 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
518 SMKind |= SMF_Destructor;
520 if (!DD->isImplicit())
521 data().HasIrrelevantDestructor = false;
523 // C++11 [class.dtor]p5:
524 // A destructor is trivial if [...] the destructor is not virtual.
526 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
529 // Handle member functions.
530 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
531 if (Method->isCopyAssignmentOperator()) {
532 SMKind |= SMF_CopyAssignment;
534 const ReferenceType *ParamTy =
535 Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
536 if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
537 data().HasDeclaredCopyAssignmentWithConstParam = true;
540 if (Method->isMoveAssignmentOperator())
541 SMKind |= SMF_MoveAssignment;
543 // Keep the list of conversion functions up-to-date.
544 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
545 // FIXME: We intentionally don't use the decl's access here because it
546 // hasn't been set yet. That's really just a misdesign in Sema.
547 if (Conversion->getPrimaryTemplate()) {
548 // We don't record specializations.
549 } else if (FunTmpl) {
550 if (FunTmpl->getPreviousDecl())
551 data().Conversions.replace(FunTmpl->getPreviousDecl(),
554 data().Conversions.addDecl(getASTContext(), FunTmpl);
556 if (Conversion->getPreviousDecl())
557 data().Conversions.replace(Conversion->getPreviousDecl(),
560 data().Conversions.addDecl(getASTContext(), Conversion);
565 // If this is the first declaration of a special member, we no longer have
566 // an implicit trivial special member.
567 data().HasTrivialSpecialMembers &=
568 data().DeclaredSpecialMembers | ~SMKind;
570 if (!Method->isImplicit() && !Method->isUserProvided()) {
571 // This method is user-declared but not user-provided. We can't work out
572 // whether it's trivial yet (not until we get to the end of the class).
573 // We'll handle this method in finishedDefaultedOrDeletedMember.
574 } else if (Method->isTrivial())
575 data().HasTrivialSpecialMembers |= SMKind;
577 data().DeclaredNonTrivialSpecialMembers |= SMKind;
579 // Note when we have declared a declared special member, and suppress the
580 // implicit declaration of this special member.
581 data().DeclaredSpecialMembers |= SMKind;
583 if (!Method->isImplicit()) {
584 data().UserDeclaredSpecialMembers |= SMKind;
587 // A POD-struct is an aggregate class that has [...] no user-defined
588 // copy assignment operator and no user-defined destructor.
590 // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
591 // aggregates could not have any constructors, clear it even for an
592 // explicitly defaulted or deleted constructor.
593 // type is technically an aggregate in C++0x since it wouldn't be in 03.
595 // Also, a user-declared move assignment operator makes a class non-POD.
596 // This is an extension in C++03.
597 data().PlainOldData = false;
604 // Handle non-static data members.
605 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
606 // C++ [class.bit]p2:
607 // A declaration for a bit-field that omits the identifier declares an
608 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
610 if (Field->isUnnamedBitfield())
613 // C++ [dcl.init.aggr]p1:
614 // An aggregate is an array or a class (clause 9) with [...] no
615 // private or protected non-static data members (clause 11).
617 // A POD must be an aggregate.
618 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
619 data().Aggregate = false;
620 data().PlainOldData = false;
624 // A standard-layout class is a class that:
626 // -- has the same access control for all non-static data members,
627 switch (D->getAccess()) {
628 case AS_private: data().HasPrivateFields = true; break;
629 case AS_protected: data().HasProtectedFields = true; break;
630 case AS_public: data().HasPublicFields = true; break;
631 case AS_none: llvm_unreachable("Invalid access specifier");
633 if ((data().HasPrivateFields + data().HasProtectedFields +
634 data().HasPublicFields) > 1)
635 data().IsStandardLayout = false;
637 // Keep track of the presence of mutable fields.
638 if (Field->isMutable())
639 data().HasMutableFields = true;
642 // A POD struct is a class that is both a trivial class and a
643 // standard-layout class, and has no non-static data members of type
644 // non-POD struct, non-POD union (or array of such types).
646 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
647 // that does not explicitly have no lifetime makes the class a non-POD.
648 // However, we delay setting PlainOldData to false in this case so that
649 // Sema has a chance to diagnostic causes where the same class will be
650 // non-POD with Automatic Reference Counting but a POD without ARC.
651 // In this case, the class will become a non-POD class when we complete
653 ASTContext &Context = getASTContext();
654 QualType T = Context.getBaseElementType(Field->getType());
655 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
656 if (!Context.getLangOpts().ObjCAutoRefCount ||
657 T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone)
658 setHasObjectMember(true);
659 } else if (!T.isPODType(Context))
660 data().PlainOldData = false;
662 if (T->isReferenceType()) {
663 if (!Field->hasInClassInitializer())
664 data().HasUninitializedReferenceMember = true;
667 // A standard-layout class is a class that:
668 // -- has no non-static data members of type [...] reference,
669 data().IsStandardLayout = false;
672 // Record if this field is the first non-literal or volatile field or base.
673 if (!T->isLiteralType() || T.isVolatileQualified())
674 data().HasNonLiteralTypeFieldsOrBases = true;
676 if (Field->hasInClassInitializer()) {
677 data().HasInClassInitializer = true;
680 // A default constructor is trivial if [...] no non-static data member
681 // of its class has a brace-or-equal-initializer.
682 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
684 // C++11 [dcl.init.aggr]p1:
685 // An aggregate is a [...] class with [...] no
686 // brace-or-equal-initializers for non-static data members.
687 data().Aggregate = false;
690 // A POD struct is [...] a trivial class.
691 data().PlainOldData = false;
694 // C++11 [class.copy]p23:
695 // A defaulted copy/move assignment operator for a class X is defined
696 // as deleted if X has:
697 // -- a non-static data member of reference type
698 if (T->isReferenceType())
699 data().DefaultedMoveAssignmentIsDeleted = true;
701 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
702 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
703 if (FieldRec->getDefinition()) {
704 addedClassSubobject(FieldRec);
706 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
707 // A defaulted [special member] for a class X is defined as
709 // -- X is a union-like class that has a variant member with a
710 // non-trivial [corresponding special member]
712 if (FieldRec->hasNonTrivialMoveConstructor())
713 data().DefaultedMoveConstructorIsDeleted = true;
714 if (FieldRec->hasNonTrivialMoveAssignment())
715 data().DefaultedMoveAssignmentIsDeleted = true;
716 if (FieldRec->hasNonTrivialDestructor())
717 data().DefaultedDestructorIsDeleted = true;
720 // C++0x [class.ctor]p5:
721 // A default constructor is trivial [...] if:
722 // -- for all the non-static data members of its class that are of
723 // class type (or array thereof), each such class has a trivial
724 // default constructor.
725 if (!FieldRec->hasTrivialDefaultConstructor())
726 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
728 // C++0x [class.copy]p13:
729 // A copy/move constructor for class X is trivial if [...]
731 // -- for each non-static data member of X that is of class type (or
732 // an array thereof), the constructor selected to copy/move that
733 // member is trivial;
734 if (!FieldRec->hasTrivialCopyConstructor())
735 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
736 // If the field doesn't have a simple move constructor, we'll eagerly
737 // declare the move constructor for this class and we'll decide whether
738 // it's trivial then.
739 if (!FieldRec->hasTrivialMoveConstructor())
740 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
742 // C++0x [class.copy]p27:
743 // A copy/move assignment operator for class X is trivial if [...]
745 // -- for each non-static data member of X that is of class type (or
746 // an array thereof), the assignment operator selected to
747 // copy/move that member is trivial;
748 if (!FieldRec->hasTrivialCopyAssignment())
749 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
750 // If the field doesn't have a simple move assignment, we'll eagerly
751 // declare the move assignment for this class and we'll decide whether
752 // it's trivial then.
753 if (!FieldRec->hasTrivialMoveAssignment())
754 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
756 if (!FieldRec->hasTrivialDestructor())
757 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
758 if (!FieldRec->hasIrrelevantDestructor())
759 data().HasIrrelevantDestructor = false;
760 if (FieldRec->hasObjectMember())
761 setHasObjectMember(true);
762 if (FieldRec->hasVolatileMember())
763 setHasVolatileMember(true);
766 // A standard-layout class is a class that:
767 // -- has no non-static data members of type non-standard-layout
768 // class (or array of such types) [...]
769 if (!FieldRec->isStandardLayout())
770 data().IsStandardLayout = false;
773 // A standard-layout class is a class that:
775 // -- has no base classes of the same type as the first non-static
777 // We don't want to expend bits in the state of the record decl
778 // tracking whether this is the first non-static data member so we
779 // cheat a bit and use some of the existing state: the empty bit.
780 // Virtual bases and virtual methods make a class non-empty, but they
781 // also make it non-standard-layout so we needn't check here.
782 // A non-empty base class may leave the class standard-layout, but not
783 // if we have arrived here, and have at least on non-static data
784 // member. If IsStandardLayout remains true, then the first non-static
785 // data member must come through here with Empty still true, and Empty
786 // will subsequently be set to false below.
787 if (data().IsStandardLayout && data().Empty) {
788 for (CXXRecordDecl::base_class_const_iterator BI = bases_begin(),
791 if (Context.hasSameUnqualifiedType(BI->getType(), T)) {
792 data().IsStandardLayout = false;
798 // Keep track of the presence of mutable fields.
799 if (FieldRec->hasMutableFields())
800 data().HasMutableFields = true;
802 // C++11 [class.copy]p13:
803 // If the implicitly-defined constructor would satisfy the
804 // requirements of a constexpr constructor, the implicitly-defined
805 // constructor is constexpr.
806 // C++11 [dcl.constexpr]p4:
807 // -- every constructor involved in initializing non-static data
808 // members [...] shall be a constexpr constructor
809 if (!Field->hasInClassInitializer() &&
810 !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
811 // The standard requires any in-class initializer to be a constant
812 // expression. We consider this to be a defect.
813 data().DefaultedDefaultConstructorIsConstexpr = false;
815 // C++11 [class.copy]p8:
816 // The implicitly-declared copy constructor for a class X will have
817 // the form 'X::X(const X&)' if [...] for all the non-static data
818 // members of X that are of a class type M (or array thereof), each
819 // such class type has a copy constructor whose first parameter is
820 // of type 'const M&' or 'const volatile M&'.
821 if (!FieldRec->hasCopyConstructorWithConstParam())
822 data().ImplicitCopyConstructorHasConstParam = false;
824 // C++11 [class.copy]p18:
825 // The implicitly-declared copy assignment oeprator for a class X will
826 // have the form 'X& X::operator=(const X&)' if [...] for all the
827 // non-static data members of X that are of a class type M (or array
828 // thereof), each such class type has a copy assignment operator whose
829 // parameter is of type 'const M&', 'const volatile M&' or 'M'.
830 if (!FieldRec->hasCopyAssignmentWithConstParam())
831 data().ImplicitCopyAssignmentHasConstParam = false;
833 if (FieldRec->hasUninitializedReferenceMember() &&
834 !Field->hasInClassInitializer())
835 data().HasUninitializedReferenceMember = true;
838 // Base element type of field is a non-class type.
839 if (!T->isLiteralType() ||
840 (!Field->hasInClassInitializer() && !isUnion()))
841 data().DefaultedDefaultConstructorIsConstexpr = false;
843 // C++11 [class.copy]p23:
844 // A defaulted copy/move assignment operator for a class X is defined
845 // as deleted if X has:
846 // -- a non-static data member of const non-class type (or array
848 if (T.isConstQualified())
849 data().DefaultedMoveAssignmentIsDeleted = true;
853 // A standard-layout class is a class that:
855 // -- either has no non-static data members in the most derived
856 // class and at most one base class with non-static data members,
857 // or has no base classes with non-static data members, and
858 // At this point we know that we have a non-static data member, so the last
860 if (!data().HasNoNonEmptyBases)
861 data().IsStandardLayout = false;
863 // If this is not a zero-length bit-field, then the class is not empty.
865 if (!Field->isBitField() ||
866 (!Field->getBitWidth()->isTypeDependent() &&
867 !Field->getBitWidth()->isValueDependent() &&
868 Field->getBitWidthValue(Context) != 0))
869 data().Empty = false;
873 // Handle using declarations of conversion functions.
874 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D))
875 if (Shadow->getDeclName().getNameKind()
876 == DeclarationName::CXXConversionFunctionName)
877 data().Conversions.addDecl(getASTContext(), Shadow, Shadow->getAccess());
880 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
881 assert(!D->isImplicit() && !D->isUserProvided());
883 // The kind of special member this declaration is, if any.
886 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
887 if (Constructor->isDefaultConstructor()) {
888 SMKind |= SMF_DefaultConstructor;
889 if (Constructor->isConstexpr())
890 data().HasConstexprDefaultConstructor = true;
892 if (Constructor->isCopyConstructor())
893 SMKind |= SMF_CopyConstructor;
894 else if (Constructor->isMoveConstructor())
895 SMKind |= SMF_MoveConstructor;
896 else if (Constructor->isConstexpr())
897 // We may now know that the constructor is constexpr.
898 data().HasConstexprNonCopyMoveConstructor = true;
899 } else if (isa<CXXDestructorDecl>(D))
900 SMKind |= SMF_Destructor;
901 else if (D->isCopyAssignmentOperator())
902 SMKind |= SMF_CopyAssignment;
903 else if (D->isMoveAssignmentOperator())
904 SMKind |= SMF_MoveAssignment;
906 // Update which trivial / non-trivial special members we have.
907 // addedMember will have skipped this step for this member.
909 data().HasTrivialSpecialMembers |= SMKind;
911 data().DeclaredNonTrivialSpecialMembers |= SMKind;
914 bool CXXRecordDecl::isCLike() const {
915 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
916 !TemplateOrInstantiation.isNull())
918 if (!hasDefinition())
921 return isPOD() && data().HasOnlyCMembers;
924 void CXXRecordDecl::getCaptureFields(
925 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
926 FieldDecl *&ThisCapture) const {
930 LambdaDefinitionData &Lambda = getLambdaData();
931 RecordDecl::field_iterator Field = field_begin();
932 for (LambdaExpr::Capture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
933 C != CEnd; ++C, ++Field) {
934 if (C->capturesThis()) {
935 ThisCapture = *Field;
939 Captures[C->getCapturedVar()] = *Field;
944 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
946 if (isa<UsingShadowDecl>(Conv))
947 Conv = cast<UsingShadowDecl>(Conv)->getTargetDecl();
948 if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv))
949 T = ConvTemp->getTemplatedDecl()->getResultType();
951 T = cast<CXXConversionDecl>(Conv)->getConversionType();
952 return Context.getCanonicalType(T);
955 /// Collect the visible conversions of a base class.
957 /// \param Record a base class of the class we're considering
958 /// \param InVirtual whether this base class is a virtual base (or a base
959 /// of a virtual base)
960 /// \param Access the access along the inheritance path to this base
961 /// \param ParentHiddenTypes the conversions provided by the inheritors
963 /// \param Output the set to which to add conversions from non-virtual bases
964 /// \param VOutput the set to which to add conversions from virtual bases
965 /// \param HiddenVBaseCs the set of conversions which were hidden in a
966 /// virtual base along some inheritance path
967 static void CollectVisibleConversions(ASTContext &Context,
968 CXXRecordDecl *Record,
970 AccessSpecifier Access,
971 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
972 ASTUnresolvedSet &Output,
973 UnresolvedSetImpl &VOutput,
974 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
975 // The set of types which have conversions in this class or its
976 // subclasses. As an optimization, we don't copy the derived set
977 // unless it might change.
978 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
979 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
981 // Collect the direct conversions and figure out which conversions
982 // will be hidden in the subclasses.
983 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
984 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
985 if (ConvI != ConvE) {
986 HiddenTypesBuffer = ParentHiddenTypes;
987 HiddenTypes = &HiddenTypesBuffer;
989 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
990 CanQualType ConvType(GetConversionType(Context, I.getDecl()));
991 bool Hidden = ParentHiddenTypes.count(ConvType);
993 HiddenTypesBuffer.insert(ConvType);
995 // If this conversion is hidden and we're in a virtual base,
996 // remember that it's hidden along some inheritance path.
997 if (Hidden && InVirtual)
998 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1000 // If this conversion isn't hidden, add it to the appropriate output.
1002 AccessSpecifier IAccess
1003 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1006 VOutput.addDecl(I.getDecl(), IAccess);
1008 Output.addDecl(Context, I.getDecl(), IAccess);
1013 // Collect information recursively from any base classes.
1014 for (CXXRecordDecl::base_class_iterator
1015 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1016 const RecordType *RT = I->getType()->getAs<RecordType>();
1019 AccessSpecifier BaseAccess
1020 = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier());
1021 bool BaseInVirtual = InVirtual || I->isVirtual();
1023 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1024 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1025 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
1029 /// Collect the visible conversions of a class.
1031 /// This would be extremely straightforward if it weren't for virtual
1032 /// bases. It might be worth special-casing that, really.
1033 static void CollectVisibleConversions(ASTContext &Context,
1034 CXXRecordDecl *Record,
1035 ASTUnresolvedSet &Output) {
1036 // The collection of all conversions in virtual bases that we've
1037 // found. These will be added to the output as long as they don't
1038 // appear in the hidden-conversions set.
1039 UnresolvedSet<8> VBaseCs;
1041 // The set of conversions in virtual bases that we've determined to
1043 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1045 // The set of types hidden by classes derived from this one.
1046 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1048 // Go ahead and collect the direct conversions and add them to the
1049 // hidden-types set.
1050 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1051 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1052 Output.append(Context, ConvI, ConvE);
1053 for (; ConvI != ConvE; ++ConvI)
1054 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
1056 // Recursively collect conversions from base classes.
1057 for (CXXRecordDecl::base_class_iterator
1058 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1059 const RecordType *RT = I->getType()->getAs<RecordType>();
1062 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
1063 I->isVirtual(), I->getAccessSpecifier(),
1064 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1067 // Add any unhidden conversions provided by virtual bases.
1068 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1070 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
1071 Output.addDecl(Context, I.getDecl(), I.getAccess());
1075 /// getVisibleConversionFunctions - get all conversion functions visible
1076 /// in current class; including conversion function templates.
1077 std::pair<CXXRecordDecl::conversion_iterator,CXXRecordDecl::conversion_iterator>
1078 CXXRecordDecl::getVisibleConversionFunctions() {
1079 // If root class, all conversions are visible.
1080 if (bases_begin() == bases_end())
1081 return std::make_pair(data().Conversions.begin(), data().Conversions.end());
1082 // If visible conversion list is already evaluated, return it.
1083 if (!data().ComputedVisibleConversions) {
1084 CollectVisibleConversions(getASTContext(), this, data().VisibleConversions);
1085 data().ComputedVisibleConversions = true;
1087 return std::make_pair(data().VisibleConversions.begin(),
1088 data().VisibleConversions.end());
1091 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1092 // This operation is O(N) but extremely rare. Sema only uses it to
1093 // remove UsingShadowDecls in a class that were followed by a direct
1094 // declaration, e.g.:
1096 // using B::operator int;
1099 // This is uncommon by itself and even more uncommon in conjunction
1100 // with sufficiently large numbers of directly-declared conversions
1101 // that asymptotic behavior matters.
1103 ASTUnresolvedSet &Convs = data().Conversions;
1104 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1105 if (Convs[I].getDecl() == ConvDecl) {
1107 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1108 && "conversion was found multiple times in unresolved set");
1113 llvm_unreachable("conversion not found in set!");
1116 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1117 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1118 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1124 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1125 TemplateSpecializationKind TSK) {
1126 assert(TemplateOrInstantiation.isNull() &&
1127 "Previous template or instantiation?");
1128 assert(!isa<ClassTemplateSpecializationDecl>(this));
1129 TemplateOrInstantiation
1130 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1133 TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1134 if (const ClassTemplateSpecializationDecl *Spec
1135 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1136 return Spec->getSpecializationKind();
1138 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1139 return MSInfo->getTemplateSpecializationKind();
1141 return TSK_Undeclared;
1145 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1146 if (ClassTemplateSpecializationDecl *Spec
1147 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1148 Spec->setSpecializationKind(TSK);
1152 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1153 MSInfo->setTemplateSpecializationKind(TSK);
1157 llvm_unreachable("Not a class template or member class specialization");
1160 CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1161 ASTContext &Context = getASTContext();
1162 QualType ClassType = Context.getTypeDeclType(this);
1164 DeclarationName Name
1165 = Context.DeclarationNames.getCXXDestructorName(
1166 Context.getCanonicalType(ClassType));
1168 DeclContext::lookup_const_result R = lookup(Name);
1172 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
1176 void CXXRecordDecl::completeDefinition() {
1177 completeDefinition(0);
1180 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1181 RecordDecl::completeDefinition();
1183 if (hasObjectMember() && getASTContext().getLangOpts().ObjCAutoRefCount) {
1184 // Objective-C Automatic Reference Counting:
1185 // If a class has a non-static data member of Objective-C pointer
1186 // type (or array thereof), it is a non-POD type and its
1187 // default constructor (if any), copy constructor, move constructor,
1188 // copy assignment operator, move assignment operator, and destructor are
1190 struct DefinitionData &Data = data();
1191 Data.PlainOldData = false;
1192 Data.HasTrivialSpecialMembers = 0;
1193 Data.HasIrrelevantDestructor = false;
1196 // If the class may be abstract (but hasn't been marked as such), check for
1197 // any pure final overriders.
1198 if (mayBeAbstract()) {
1199 CXXFinalOverriderMap MyFinalOverriders;
1200 if (!FinalOverriders) {
1201 getFinalOverriders(MyFinalOverriders);
1202 FinalOverriders = &MyFinalOverriders;
1206 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1207 MEnd = FinalOverriders->end();
1208 M != MEnd && !Done; ++M) {
1209 for (OverridingMethods::iterator SO = M->second.begin(),
1210 SOEnd = M->second.end();
1211 SO != SOEnd && !Done; ++SO) {
1212 assert(SO->second.size() > 0 &&
1213 "All virtual functions have overridding virtual functions");
1215 // C++ [class.abstract]p4:
1216 // A class is abstract if it contains or inherits at least one
1217 // pure virtual function for which the final overrider is pure
1219 if (SO->second.front().Method->isPure()) {
1220 data().Abstract = true;
1228 // Set access bits correctly on the directly-declared conversions.
1229 for (UnresolvedSetIterator I = data().Conversions.begin(),
1230 E = data().Conversions.end();
1232 I.setAccess((*I)->getAccess());
1235 bool CXXRecordDecl::mayBeAbstract() const {
1236 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1237 isDependentContext())
1240 for (CXXRecordDecl::base_class_const_iterator B = bases_begin(),
1243 CXXRecordDecl *BaseDecl
1244 = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl());
1245 if (BaseDecl->isAbstract())
1252 void CXXMethodDecl::anchor() { }
1254 bool CXXMethodDecl::isStatic() const {
1255 const CXXMethodDecl *MD = this;
1257 const CXXMethodDecl *C = MD->getCanonicalDecl();
1263 FunctionTemplateSpecializationInfo *Info =
1264 MD->getTemplateSpecializationInfo();
1267 MD = cast<CXXMethodDecl>(Info->getTemplate()->getTemplatedDecl());
1270 if (MD->getStorageClass() == SC_Static)
1273 DeclarationName Name = getDeclName();
1275 // Any allocation function for a class T is a static member
1276 // (even if not explicitly declared static).
1277 if (Name.getCXXOverloadedOperator() == OO_New ||
1278 Name.getCXXOverloadedOperator() == OO_Array_New)
1281 // [class.free]p6 Any deallocation function for a class X is a static member
1282 // (even if not explicitly declared static).
1283 if (Name.getCXXOverloadedOperator() == OO_Delete ||
1284 Name.getCXXOverloadedOperator() == OO_Array_Delete)
1290 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1291 const CXXMethodDecl *BaseMD) {
1292 for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
1293 E = DerivedMD->end_overridden_methods(); I != E; ++I) {
1294 const CXXMethodDecl *MD = *I;
1295 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1297 if (recursivelyOverrides(MD, BaseMD))
1304 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1306 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1309 // Lookup doesn't work for destructors, so handle them separately.
1310 if (isa<CXXDestructorDecl>(this)) {
1311 CXXMethodDecl *MD = RD->getDestructor();
1313 if (recursivelyOverrides(MD, this))
1315 if (MayBeBase && recursivelyOverrides(this, MD))
1321 lookup_const_result Candidates = RD->lookup(getDeclName());
1322 for (NamedDecl * const * I = Candidates.begin(); I != Candidates.end(); ++I) {
1323 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I);
1326 if (recursivelyOverrides(MD, this))
1328 if (MayBeBase && recursivelyOverrides(this, MD))
1332 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1333 E = RD->bases_end(); I != E; ++I) {
1334 const RecordType *RT = I->getType()->getAs<RecordType>();
1337 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1338 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1347 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1348 SourceLocation StartLoc,
1349 const DeclarationNameInfo &NameInfo,
1350 QualType T, TypeSourceInfo *TInfo,
1351 StorageClass SC, bool isInline,
1352 bool isConstexpr, SourceLocation EndLocation) {
1353 return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo,
1354 SC, isInline, isConstexpr,
1358 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1359 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXMethodDecl));
1360 return new (Mem) CXXMethodDecl(CXXMethod, 0, SourceLocation(),
1361 DeclarationNameInfo(), QualType(),
1362 0, SC_None, false, false,
1366 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1367 if (getOverloadedOperator() != OO_Delete &&
1368 getOverloadedOperator() != OO_Array_Delete)
1371 // C++ [basic.stc.dynamic.deallocation]p2:
1372 // A template instance is never a usual deallocation function,
1373 // regardless of its signature.
1374 if (getPrimaryTemplate())
1377 // C++ [basic.stc.dynamic.deallocation]p2:
1378 // If a class T has a member deallocation function named operator delete
1379 // with exactly one parameter, then that function is a usual (non-placement)
1380 // deallocation function. [...]
1381 if (getNumParams() == 1)
1384 // C++ [basic.stc.dynamic.deallocation]p2:
1385 // [...] If class T does not declare such an operator delete but does
1386 // declare a member deallocation function named operator delete with
1387 // exactly two parameters, the second of which has type std::size_t (18.1),
1388 // then this function is a usual deallocation function.
1389 ASTContext &Context = getASTContext();
1390 if (getNumParams() != 2 ||
1391 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1392 Context.getSizeType()))
1395 // This function is a usual deallocation function if there are no
1396 // single-parameter deallocation functions of the same kind.
1397 DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
1398 for (DeclContext::lookup_const_result::iterator I = R.begin(), E = R.end();
1400 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
1401 if (FD->getNumParams() == 1)
1408 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1409 // C++0x [class.copy]p17:
1410 // A user-declared copy assignment operator X::operator= is a non-static
1411 // non-template member function of class X with exactly one parameter of
1412 // type X, X&, const X&, volatile X& or const volatile X&.
1413 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1414 /*non-static*/ isStatic() ||
1415 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate())
1418 QualType ParamType = getParamDecl(0)->getType();
1419 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1420 ParamType = Ref->getPointeeType();
1422 ASTContext &Context = getASTContext();
1424 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1425 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1428 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1429 // C++0x [class.copy]p19:
1430 // A user-declared move assignment operator X::operator= is a non-static
1431 // non-template member function of class X with exactly one parameter of type
1432 // X&&, const X&&, volatile X&&, or const volatile X&&.
1433 if (getOverloadedOperator() != OO_Equal || isStatic() ||
1434 getPrimaryTemplate() || getDescribedFunctionTemplate())
1437 QualType ParamType = getParamDecl(0)->getType();
1438 if (!isa<RValueReferenceType>(ParamType))
1440 ParamType = ParamType->getPointeeType();
1442 ASTContext &Context = getASTContext();
1444 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1445 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1448 void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
1449 assert(MD->isCanonicalDecl() && "Method is not canonical!");
1450 assert(!MD->getParent()->isDependentContext() &&
1451 "Can't add an overridden method to a class template!");
1452 assert(MD->isVirtual() && "Method is not virtual!");
1454 getASTContext().addOverriddenMethod(this, MD);
1457 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
1458 if (isa<CXXConstructorDecl>(this)) return 0;
1459 return getASTContext().overridden_methods_begin(this);
1462 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
1463 if (isa<CXXConstructorDecl>(this)) return 0;
1464 return getASTContext().overridden_methods_end(this);
1467 unsigned CXXMethodDecl::size_overridden_methods() const {
1468 if (isa<CXXConstructorDecl>(this)) return 0;
1469 return getASTContext().overridden_methods_size(this);
1472 QualType CXXMethodDecl::getThisType(ASTContext &C) const {
1473 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1474 // If the member function is declared const, the type of this is const X*,
1475 // if the member function is declared volatile, the type of this is
1476 // volatile X*, and if the member function is declared const volatile,
1477 // the type of this is const volatile X*.
1479 assert(isInstance() && "No 'this' for static methods!");
1481 QualType ClassTy = C.getTypeDeclType(getParent());
1482 ClassTy = C.getQualifiedType(ClassTy,
1483 Qualifiers::fromCVRMask(getTypeQualifiers()));
1484 return C.getPointerType(ClassTy);
1487 bool CXXMethodDecl::hasInlineBody() const {
1488 // If this function is a template instantiation, look at the template from
1489 // which it was instantiated.
1490 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1494 const FunctionDecl *fn;
1495 return CheckFn->hasBody(fn) && !fn->isOutOfLine();
1498 bool CXXMethodDecl::isLambdaStaticInvoker() const {
1499 return getParent()->isLambda() &&
1500 getIdentifier() && getIdentifier()->getName() == "__invoke";
1504 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1505 TypeSourceInfo *TInfo, bool IsVirtual,
1506 SourceLocation L, Expr *Init,
1508 SourceLocation EllipsisLoc)
1509 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
1510 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
1511 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1515 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1517 SourceLocation MemberLoc,
1518 SourceLocation L, Expr *Init,
1520 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1521 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1522 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1526 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1527 IndirectFieldDecl *Member,
1528 SourceLocation MemberLoc,
1529 SourceLocation L, Expr *Init,
1531 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1532 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1533 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1537 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1538 TypeSourceInfo *TInfo,
1539 SourceLocation L, Expr *Init,
1541 : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init),
1542 LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false),
1543 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1547 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1549 SourceLocation MemberLoc,
1550 SourceLocation L, Expr *Init,
1553 unsigned NumIndices)
1554 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1555 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1556 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices)
1558 VarDecl **MyIndices = reinterpret_cast<VarDecl **> (this + 1);
1559 memcpy(MyIndices, Indices, NumIndices * sizeof(VarDecl *));
1562 CXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context,
1564 SourceLocation MemberLoc,
1565 SourceLocation L, Expr *Init,
1568 unsigned NumIndices) {
1569 void *Mem = Context.Allocate(sizeof(CXXCtorInitializer) +
1570 sizeof(VarDecl *) * NumIndices,
1571 llvm::alignOf<CXXCtorInitializer>());
1572 return new (Mem) CXXCtorInitializer(Context, Member, MemberLoc, L, Init, R,
1573 Indices, NumIndices);
1576 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
1577 if (isBaseInitializer())
1578 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
1583 const Type *CXXCtorInitializer::getBaseClass() const {
1584 if (isBaseInitializer())
1585 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1590 SourceLocation CXXCtorInitializer::getSourceLocation() const {
1591 if (isAnyMemberInitializer())
1592 return getMemberLocation();
1594 if (isInClassMemberInitializer())
1595 return getAnyMember()->getLocation();
1597 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>())
1598 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
1600 return SourceLocation();
1603 SourceRange CXXCtorInitializer::getSourceRange() const {
1604 if (isInClassMemberInitializer()) {
1605 FieldDecl *D = getAnyMember();
1606 if (Expr *I = D->getInClassInitializer())
1607 return I->getSourceRange();
1608 return SourceRange();
1611 return SourceRange(getSourceLocation(), getRParenLoc());
1614 void CXXConstructorDecl::anchor() { }
1616 CXXConstructorDecl *
1617 CXXConstructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1618 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXConstructorDecl));
1619 return new (Mem) CXXConstructorDecl(0, SourceLocation(),DeclarationNameInfo(),
1620 QualType(), 0, false, false, false,false);
1623 CXXConstructorDecl *
1624 CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1625 SourceLocation StartLoc,
1626 const DeclarationNameInfo &NameInfo,
1627 QualType T, TypeSourceInfo *TInfo,
1628 bool isExplicit, bool isInline,
1629 bool isImplicitlyDeclared, bool isConstexpr) {
1630 assert(NameInfo.getName().getNameKind()
1631 == DeclarationName::CXXConstructorName &&
1632 "Name must refer to a constructor");
1633 return new (C) CXXConstructorDecl(RD, StartLoc, NameInfo, T, TInfo,
1634 isExplicit, isInline, isImplicitlyDeclared,
1638 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
1639 assert(isDelegatingConstructor() && "Not a delegating constructor!");
1640 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
1641 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E))
1642 return Construct->getConstructor();
1647 bool CXXConstructorDecl::isDefaultConstructor() const {
1648 // C++ [class.ctor]p5:
1649 // A default constructor for a class X is a constructor of class
1650 // X that can be called without an argument.
1651 return (getNumParams() == 0) ||
1652 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
1656 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
1657 return isCopyOrMoveConstructor(TypeQuals) &&
1658 getParamDecl(0)->getType()->isLValueReferenceType();
1661 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
1662 return isCopyOrMoveConstructor(TypeQuals) &&
1663 getParamDecl(0)->getType()->isRValueReferenceType();
1666 /// \brief Determine whether this is a copy or move constructor.
1667 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
1668 // C++ [class.copy]p2:
1669 // A non-template constructor for class X is a copy constructor
1670 // if its first parameter is of type X&, const X&, volatile X& or
1671 // const volatile X&, and either there are no other parameters
1672 // or else all other parameters have default arguments (8.3.6).
1673 // C++0x [class.copy]p3:
1674 // A non-template constructor for class X is a move constructor if its
1675 // first parameter is of type X&&, const X&&, volatile X&&, or
1676 // const volatile X&&, and either there are no other parameters or else
1677 // all other parameters have default arguments.
1678 if ((getNumParams() < 1) ||
1679 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1680 (getPrimaryTemplate() != 0) ||
1681 (getDescribedFunctionTemplate() != 0))
1684 const ParmVarDecl *Param = getParamDecl(0);
1686 // Do we have a reference type?
1687 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
1691 // Is it a reference to our class type?
1692 ASTContext &Context = getASTContext();
1694 CanQualType PointeeType
1695 = Context.getCanonicalType(ParamRefType->getPointeeType());
1697 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1698 if (PointeeType.getUnqualifiedType() != ClassTy)
1701 // FIXME: other qualifiers?
1703 // We have a copy or move constructor.
1704 TypeQuals = PointeeType.getCVRQualifiers();
1708 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
1709 // C++ [class.conv.ctor]p1:
1710 // A constructor declared without the function-specifier explicit
1711 // that can be called with a single parameter specifies a
1712 // conversion from the type of its first parameter to the type of
1713 // its class. Such a constructor is called a converting
1715 if (isExplicit() && !AllowExplicit)
1718 return (getNumParams() == 0 &&
1719 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
1720 (getNumParams() == 1) ||
1721 (getNumParams() > 1 &&
1722 (getParamDecl(1)->hasDefaultArg() ||
1723 getParamDecl(1)->isParameterPack()));
1726 bool CXXConstructorDecl::isSpecializationCopyingObject() const {
1727 if ((getNumParams() < 1) ||
1728 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1729 (getPrimaryTemplate() == 0) ||
1730 (getDescribedFunctionTemplate() != 0))
1733 const ParmVarDecl *Param = getParamDecl(0);
1735 ASTContext &Context = getASTContext();
1736 CanQualType ParamType = Context.getCanonicalType(Param->getType());
1738 // Is it the same as our our class type?
1740 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1741 if (ParamType.getUnqualifiedType() != ClassTy)
1747 const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
1748 // Hack: we store the inherited constructor in the overridden method table
1749 method_iterator It = getASTContext().overridden_methods_begin(this);
1750 if (It == getASTContext().overridden_methods_end(this))
1753 return cast<CXXConstructorDecl>(*It);
1757 CXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl *BaseCtor){
1758 // Hack: we store the inherited constructor in the overridden method table
1759 assert(getASTContext().overridden_methods_size(this) == 0 &&
1760 "Base ctor already set.");
1761 getASTContext().addOverriddenMethod(this, BaseCtor);
1764 void CXXDestructorDecl::anchor() { }
1767 CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1768 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXDestructorDecl));
1769 return new (Mem) CXXDestructorDecl(0, SourceLocation(), DeclarationNameInfo(),
1770 QualType(), 0, false, false);
1774 CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1775 SourceLocation StartLoc,
1776 const DeclarationNameInfo &NameInfo,
1777 QualType T, TypeSourceInfo *TInfo,
1778 bool isInline, bool isImplicitlyDeclared) {
1779 assert(NameInfo.getName().getNameKind()
1780 == DeclarationName::CXXDestructorName &&
1781 "Name must refer to a destructor");
1782 return new (C) CXXDestructorDecl(RD, StartLoc, NameInfo, T, TInfo, isInline,
1783 isImplicitlyDeclared);
1786 void CXXConversionDecl::anchor() { }
1789 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1790 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXConversionDecl));
1791 return new (Mem) CXXConversionDecl(0, SourceLocation(), DeclarationNameInfo(),
1792 QualType(), 0, false, false, false,
1797 CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1798 SourceLocation StartLoc,
1799 const DeclarationNameInfo &NameInfo,
1800 QualType T, TypeSourceInfo *TInfo,
1801 bool isInline, bool isExplicit,
1802 bool isConstexpr, SourceLocation EndLocation) {
1803 assert(NameInfo.getName().getNameKind()
1804 == DeclarationName::CXXConversionFunctionName &&
1805 "Name must refer to a conversion function");
1806 return new (C) CXXConversionDecl(RD, StartLoc, NameInfo, T, TInfo,
1807 isInline, isExplicit, isConstexpr,
1811 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1812 return isImplicit() && getParent()->isLambda() &&
1813 getConversionType()->isBlockPointerType();
1816 void LinkageSpecDecl::anchor() { }
1818 LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
1820 SourceLocation ExternLoc,
1821 SourceLocation LangLoc,
1823 SourceLocation RBraceLoc) {
1824 return new (C) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, RBraceLoc);
1827 LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1828 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LinkageSpecDecl));
1829 return new (Mem) LinkageSpecDecl(0, SourceLocation(), SourceLocation(),
1830 lang_c, SourceLocation());
1833 void UsingDirectiveDecl::anchor() { }
1835 UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
1837 SourceLocation NamespaceLoc,
1838 NestedNameSpecifierLoc QualifierLoc,
1839 SourceLocation IdentLoc,
1841 DeclContext *CommonAncestor) {
1842 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used))
1843 Used = NS->getOriginalNamespace();
1844 return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
1845 IdentLoc, Used, CommonAncestor);
1848 UsingDirectiveDecl *
1849 UsingDirectiveDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1850 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingDirectiveDecl));
1851 return new (Mem) UsingDirectiveDecl(0, SourceLocation(), SourceLocation(),
1852 NestedNameSpecifierLoc(),
1853 SourceLocation(), 0, 0);
1856 NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
1857 if (NamespaceAliasDecl *NA =
1858 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
1859 return NA->getNamespace();
1860 return cast_or_null<NamespaceDecl>(NominatedNamespace);
1863 void NamespaceDecl::anchor() { }
1865 NamespaceDecl::NamespaceDecl(DeclContext *DC, bool Inline,
1866 SourceLocation StartLoc,
1867 SourceLocation IdLoc, IdentifierInfo *Id,
1868 NamespaceDecl *PrevDecl)
1869 : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace),
1870 LocStart(StartLoc), RBraceLoc(), AnonOrFirstNamespaceAndInline(0, Inline)
1872 setPreviousDeclaration(PrevDecl);
1875 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
1878 NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
1879 bool Inline, SourceLocation StartLoc,
1880 SourceLocation IdLoc, IdentifierInfo *Id,
1881 NamespaceDecl *PrevDecl) {
1882 return new (C) NamespaceDecl(DC, Inline, StartLoc, IdLoc, Id, PrevDecl);
1885 NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1886 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NamespaceDecl));
1887 return new (Mem) NamespaceDecl(0, false, SourceLocation(), SourceLocation(),
1891 void NamespaceAliasDecl::anchor() { }
1893 NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
1894 SourceLocation UsingLoc,
1895 SourceLocation AliasLoc,
1896 IdentifierInfo *Alias,
1897 NestedNameSpecifierLoc QualifierLoc,
1898 SourceLocation IdentLoc,
1899 NamedDecl *Namespace) {
1900 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
1901 Namespace = NS->getOriginalNamespace();
1902 return new (C) NamespaceAliasDecl(DC, UsingLoc, AliasLoc, Alias,
1903 QualifierLoc, IdentLoc, Namespace);
1906 NamespaceAliasDecl *
1907 NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1908 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NamespaceAliasDecl));
1909 return new (Mem) NamespaceAliasDecl(0, SourceLocation(), SourceLocation(), 0,
1910 NestedNameSpecifierLoc(),
1911 SourceLocation(), 0);
1914 void UsingShadowDecl::anchor() { }
1917 UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1918 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingShadowDecl));
1919 return new (Mem) UsingShadowDecl(0, SourceLocation(), 0, 0);
1922 UsingDecl *UsingShadowDecl::getUsingDecl() const {
1923 const UsingShadowDecl *Shadow = this;
1924 while (const UsingShadowDecl *NextShadow =
1925 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
1926 Shadow = NextShadow;
1927 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
1930 void UsingDecl::anchor() { }
1932 void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
1933 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
1934 "declaration already in set");
1935 assert(S->getUsingDecl() == this);
1937 if (FirstUsingShadow.getPointer())
1938 S->UsingOrNextShadow = FirstUsingShadow.getPointer();
1939 FirstUsingShadow.setPointer(S);
1942 void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
1943 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
1944 "declaration not in set");
1945 assert(S->getUsingDecl() == this);
1947 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
1949 if (FirstUsingShadow.getPointer() == S) {
1950 FirstUsingShadow.setPointer(
1951 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
1952 S->UsingOrNextShadow = this;
1956 UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
1957 while (Prev->UsingOrNextShadow != S)
1958 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
1959 Prev->UsingOrNextShadow = S->UsingOrNextShadow;
1960 S->UsingOrNextShadow = this;
1963 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
1964 NestedNameSpecifierLoc QualifierLoc,
1965 const DeclarationNameInfo &NameInfo,
1966 bool IsTypeNameArg) {
1967 return new (C) UsingDecl(DC, UL, QualifierLoc, NameInfo, IsTypeNameArg);
1970 UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1971 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingDecl));
1972 return new (Mem) UsingDecl(0, SourceLocation(), NestedNameSpecifierLoc(),
1973 DeclarationNameInfo(), false);
1976 void UnresolvedUsingValueDecl::anchor() { }
1978 UnresolvedUsingValueDecl *
1979 UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
1980 SourceLocation UsingLoc,
1981 NestedNameSpecifierLoc QualifierLoc,
1982 const DeclarationNameInfo &NameInfo) {
1983 return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
1984 QualifierLoc, NameInfo);
1987 UnresolvedUsingValueDecl *
1988 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1989 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UnresolvedUsingValueDecl));
1990 return new (Mem) UnresolvedUsingValueDecl(0, QualType(), SourceLocation(),
1991 NestedNameSpecifierLoc(),
1992 DeclarationNameInfo());
1995 void UnresolvedUsingTypenameDecl::anchor() { }
1997 UnresolvedUsingTypenameDecl *
1998 UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
1999 SourceLocation UsingLoc,
2000 SourceLocation TypenameLoc,
2001 NestedNameSpecifierLoc QualifierLoc,
2002 SourceLocation TargetNameLoc,
2003 DeclarationName TargetName) {
2004 return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc,
2005 QualifierLoc, TargetNameLoc,
2006 TargetName.getAsIdentifierInfo());
2009 UnresolvedUsingTypenameDecl *
2010 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2011 void *Mem = AllocateDeserializedDecl(C, ID,
2012 sizeof(UnresolvedUsingTypenameDecl));
2013 return new (Mem) UnresolvedUsingTypenameDecl(0, SourceLocation(),
2015 NestedNameSpecifierLoc(),
2020 void StaticAssertDecl::anchor() { }
2022 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
2023 SourceLocation StaticAssertLoc,
2025 StringLiteral *Message,
2026 SourceLocation RParenLoc,
2028 return new (C) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2032 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
2034 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(StaticAssertDecl));
2035 return new (Mem) StaticAssertDecl(0, SourceLocation(), 0, 0,
2036 SourceLocation(), false);
2039 static const char *getAccessName(AccessSpecifier AS) {
2042 llvm_unreachable("Invalid access specifier!");
2050 llvm_unreachable("Invalid access specifier!");
2053 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2054 AccessSpecifier AS) {
2055 return DB << getAccessName(AS);
2058 const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2059 AccessSpecifier AS) {
2060 return DB << getAccessName(AS);