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(C))
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++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;
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 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
551 AccessSpecifier AS = Conversion->getAccessUnsafe();
553 if (Conversion->getPrimaryTemplate()) {
554 // We don't record specializations.
555 } else if (FunTmpl) {
556 if (FunTmpl->getPreviousDecl())
557 data().Conversions.replace(FunTmpl->getPreviousDecl(),
560 data().Conversions.addDecl(getASTContext(), FunTmpl, AS);
562 if (Conversion->getPreviousDecl())
563 data().Conversions.replace(Conversion->getPreviousDecl(),
566 data().Conversions.addDecl(getASTContext(), Conversion, AS);
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;
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;
583 data().DeclaredNonTrivialSpecialMembers |= SMKind;
585 // Note when we have declared a declared special member, and suppress the
586 // implicit declaration of this special member.
587 data().DeclaredSpecialMembers |= SMKind;
589 if (!Method->isImplicit()) {
590 data().UserDeclaredSpecialMembers |= SMKind;
593 // A POD-struct is an aggregate class that has [...] no user-defined
594 // copy assignment operator and no user-defined destructor.
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.
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;
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
616 if (Field->isUnnamedBitfield())
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).
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;
630 // A standard-layout class is a class that:
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");
639 if ((data().HasPrivateFields + data().HasProtectedFields +
640 data().HasPublicFields) > 1)
641 data().IsStandardLayout = false;
643 // Keep track of the presence of mutable fields.
644 if (Field->isMutable())
645 data().HasMutableFields = true;
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).
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
659 ASTContext &Context = getASTContext();
660 QualType T = Context.getBaseElementType(Field->getType());
661 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
662 if (!Context.getLangOpts().ObjCAutoRefCount ||
663 T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone)
664 setHasObjectMember(true);
665 } else if (!T.isPODType(Context))
666 data().PlainOldData = false;
668 if (T->isReferenceType()) {
669 if (!Field->hasInClassInitializer())
670 data().HasUninitializedReferenceMember = true;
673 // A standard-layout class is a class that:
674 // -- has no non-static data members of type [...] reference,
675 data().IsStandardLayout = false;
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;
682 if (Field->hasInClassInitializer()) {
683 data().HasInClassInitializer = true;
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;
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.
694 // This rule was removed in C++1y.
695 if (!getASTContext().getLangOpts().CPlusPlus1y)
696 data().Aggregate = false;
699 // A POD struct is [...] a trivial class.
700 data().PlainOldData = false;
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;
710 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
711 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
712 if (FieldRec->getDefinition()) {
713 addedClassSubobject(FieldRec);
715 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
716 // A defaulted [special member] for a class X is defined as
718 // -- X is a union-like class that has a variant member with a
719 // non-trivial [corresponding special member]
721 if (FieldRec->hasNonTrivialMoveConstructor())
722 data().DefaultedMoveConstructorIsDeleted = true;
723 if (FieldRec->hasNonTrivialMoveAssignment())
724 data().DefaultedMoveAssignmentIsDeleted = true;
725 if (FieldRec->hasNonTrivialDestructor())
726 data().DefaultedDestructorIsDeleted = true;
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;
737 // C++0x [class.copy]p13:
738 // A copy/move constructor for class X is trivial if [...]
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;
751 // C++0x [class.copy]p27:
752 // A copy/move assignment operator for class X is trivial if [...]
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;
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);
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;
782 // A standard-layout class is a class that:
784 // -- has no base classes of the same type as the first non-static
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(),
800 if (Context.hasSameUnqualifiedType(BI->getType(), T)) {
801 data().IsStandardLayout = false;
807 // Keep track of the presence of mutable fields.
808 if (FieldRec->hasMutableFields())
809 data().HasMutableFields = true;
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;
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;
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;
842 if (FieldRec->hasUninitializedReferenceMember() &&
843 !Field->hasInClassInitializer())
844 data().HasUninitializedReferenceMember = true;
847 // Base element type of field is a non-class type.
848 if (!T->isLiteralType(Context) ||
849 (!Field->hasInClassInitializer() && !isUnion()))
850 data().DefaultedDefaultConstructorIsConstexpr = false;
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
857 if (T.isConstQualified())
858 data().DefaultedMoveAssignmentIsDeleted = true;
862 // A standard-layout class is a class that:
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
869 if (!data().HasNoNonEmptyBases)
870 data().IsStandardLayout = false;
872 // If this is not a zero-length bit-field, then the class is not empty.
874 if (!Field->isBitField() ||
875 (!Field->getBitWidth()->isTypeDependent() &&
876 !Field->getBitWidth()->isValueDependent() &&
877 Field->getBitWidthValue(Context) != 0))
878 data().Empty = false;
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());
889 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
890 assert(!D->isImplicit() && !D->isUserProvided());
892 // The kind of special member this declaration is, if any.
895 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
896 if (Constructor->isDefaultConstructor()) {
897 SMKind |= SMF_DefaultConstructor;
898 if (Constructor->isConstexpr())
899 data().HasConstexprDefaultConstructor = true;
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;
915 // Update which trivial / non-trivial special members we have.
916 // addedMember will have skipped this step for this member.
918 data().HasTrivialSpecialMembers |= SMKind;
920 data().DeclaredNonTrivialSpecialMembers |= SMKind;
923 bool CXXRecordDecl::isCLike() const {
924 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
925 !TemplateOrInstantiation.isNull())
927 if (!hasDefinition())
930 return isPOD() && data().HasOnlyCMembers;
933 void CXXRecordDecl::getCaptureFields(
934 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
935 FieldDecl *&ThisCapture) const {
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;
948 Captures[C->getCapturedVar()] = *Field;
953 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
955 if (isa<UsingShadowDecl>(Conv))
956 Conv = cast<UsingShadowDecl>(Conv)->getTargetDecl();
957 if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv))
958 T = ConvTemp->getTemplatedDecl()->getResultType();
960 T = cast<CXXConversionDecl>(Conv)->getConversionType();
961 return Context.getCanonicalType(T);
964 /// Collect the visible conversions of a base class.
966 /// \param Record a base class of the class we're considering
967 /// \param InVirtual whether this base class is a virtual base (or a base
968 /// of a virtual base)
969 /// \param Access the access along the inheritance path to this base
970 /// \param ParentHiddenTypes the conversions provided by the inheritors
972 /// \param Output the set to which to add conversions from non-virtual bases
973 /// \param VOutput the set to which to add conversions from virtual bases
974 /// \param HiddenVBaseCs the set of conversions which were hidden in a
975 /// virtual base along some inheritance path
976 static void CollectVisibleConversions(ASTContext &Context,
977 CXXRecordDecl *Record,
979 AccessSpecifier Access,
980 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
981 ASTUnresolvedSet &Output,
982 UnresolvedSetImpl &VOutput,
983 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
984 // The set of types which have conversions in this class or its
985 // subclasses. As an optimization, we don't copy the derived set
986 // unless it might change.
987 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
988 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
990 // Collect the direct conversions and figure out which conversions
991 // will be hidden in the subclasses.
992 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
993 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
994 if (ConvI != ConvE) {
995 HiddenTypesBuffer = ParentHiddenTypes;
996 HiddenTypes = &HiddenTypesBuffer;
998 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
999 CanQualType ConvType(GetConversionType(Context, I.getDecl()));
1000 bool Hidden = ParentHiddenTypes.count(ConvType);
1002 HiddenTypesBuffer.insert(ConvType);
1004 // If this conversion is hidden and we're in a virtual base,
1005 // remember that it's hidden along some inheritance path.
1006 if (Hidden && InVirtual)
1007 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1009 // If this conversion isn't hidden, add it to the appropriate output.
1011 AccessSpecifier IAccess
1012 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1015 VOutput.addDecl(I.getDecl(), IAccess);
1017 Output.addDecl(Context, I.getDecl(), IAccess);
1022 // Collect information recursively from any base classes.
1023 for (CXXRecordDecl::base_class_iterator
1024 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1025 const RecordType *RT = I->getType()->getAs<RecordType>();
1028 AccessSpecifier BaseAccess
1029 = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier());
1030 bool BaseInVirtual = InVirtual || I->isVirtual();
1032 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1033 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1034 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
1038 /// Collect the visible conversions of a class.
1040 /// This would be extremely straightforward if it weren't for virtual
1041 /// bases. It might be worth special-casing that, really.
1042 static void CollectVisibleConversions(ASTContext &Context,
1043 CXXRecordDecl *Record,
1044 ASTUnresolvedSet &Output) {
1045 // The collection of all conversions in virtual bases that we've
1046 // found. These will be added to the output as long as they don't
1047 // appear in the hidden-conversions set.
1048 UnresolvedSet<8> VBaseCs;
1050 // The set of conversions in virtual bases that we've determined to
1052 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1054 // The set of types hidden by classes derived from this one.
1055 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1057 // Go ahead and collect the direct conversions and add them to the
1058 // hidden-types set.
1059 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1060 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1061 Output.append(Context, ConvI, ConvE);
1062 for (; ConvI != ConvE; ++ConvI)
1063 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
1065 // Recursively collect conversions from base classes.
1066 for (CXXRecordDecl::base_class_iterator
1067 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
1068 const RecordType *RT = I->getType()->getAs<RecordType>();
1071 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
1072 I->isVirtual(), I->getAccessSpecifier(),
1073 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1076 // Add any unhidden conversions provided by virtual bases.
1077 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1079 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
1080 Output.addDecl(Context, I.getDecl(), I.getAccess());
1084 /// getVisibleConversionFunctions - get all conversion functions visible
1085 /// in current class; including conversion function templates.
1086 std::pair<CXXRecordDecl::conversion_iterator,CXXRecordDecl::conversion_iterator>
1087 CXXRecordDecl::getVisibleConversionFunctions() {
1088 // If root class, all conversions are visible.
1089 if (bases_begin() == bases_end())
1090 return std::make_pair(data().Conversions.begin(), data().Conversions.end());
1091 // If visible conversion list is already evaluated, return it.
1092 if (!data().ComputedVisibleConversions) {
1093 CollectVisibleConversions(getASTContext(), this, data().VisibleConversions);
1094 data().ComputedVisibleConversions = true;
1096 return std::make_pair(data().VisibleConversions.begin(),
1097 data().VisibleConversions.end());
1100 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1101 // This operation is O(N) but extremely rare. Sema only uses it to
1102 // remove UsingShadowDecls in a class that were followed by a direct
1103 // declaration, e.g.:
1105 // using B::operator int;
1108 // This is uncommon by itself and even more uncommon in conjunction
1109 // with sufficiently large numbers of directly-declared conversions
1110 // that asymptotic behavior matters.
1112 ASTUnresolvedSet &Convs = data().Conversions;
1113 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1114 if (Convs[I].getDecl() == ConvDecl) {
1116 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1117 && "conversion was found multiple times in unresolved set");
1122 llvm_unreachable("conversion not found in set!");
1125 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1126 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1127 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1133 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1134 TemplateSpecializationKind TSK) {
1135 assert(TemplateOrInstantiation.isNull() &&
1136 "Previous template or instantiation?");
1137 assert(!isa<ClassTemplateSpecializationDecl>(this));
1138 TemplateOrInstantiation
1139 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1142 TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1143 if (const ClassTemplateSpecializationDecl *Spec
1144 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1145 return Spec->getSpecializationKind();
1147 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1148 return MSInfo->getTemplateSpecializationKind();
1150 return TSK_Undeclared;
1154 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1155 if (ClassTemplateSpecializationDecl *Spec
1156 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1157 Spec->setSpecializationKind(TSK);
1161 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1162 MSInfo->setTemplateSpecializationKind(TSK);
1166 llvm_unreachable("Not a class template or member class specialization");
1169 CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1170 ASTContext &Context = getASTContext();
1171 QualType ClassType = Context.getTypeDeclType(this);
1173 DeclarationName Name
1174 = Context.DeclarationNames.getCXXDestructorName(
1175 Context.getCanonicalType(ClassType));
1177 DeclContext::lookup_const_result R = lookup(Name);
1181 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
1185 void CXXRecordDecl::completeDefinition() {
1186 completeDefinition(0);
1189 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1190 RecordDecl::completeDefinition();
1192 if (hasObjectMember() && getASTContext().getLangOpts().ObjCAutoRefCount) {
1193 // Objective-C Automatic Reference Counting:
1194 // If a class has a non-static data member of Objective-C pointer
1195 // type (or array thereof), it is a non-POD type and its
1196 // default constructor (if any), copy constructor, move constructor,
1197 // copy assignment operator, move assignment operator, and destructor are
1199 struct DefinitionData &Data = data();
1200 Data.PlainOldData = false;
1201 Data.HasTrivialSpecialMembers = 0;
1202 Data.HasIrrelevantDestructor = false;
1205 // If the class may be abstract (but hasn't been marked as such), check for
1206 // any pure final overriders.
1207 if (mayBeAbstract()) {
1208 CXXFinalOverriderMap MyFinalOverriders;
1209 if (!FinalOverriders) {
1210 getFinalOverriders(MyFinalOverriders);
1211 FinalOverriders = &MyFinalOverriders;
1215 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1216 MEnd = FinalOverriders->end();
1217 M != MEnd && !Done; ++M) {
1218 for (OverridingMethods::iterator SO = M->second.begin(),
1219 SOEnd = M->second.end();
1220 SO != SOEnd && !Done; ++SO) {
1221 assert(SO->second.size() > 0 &&
1222 "All virtual functions have overridding virtual functions");
1224 // C++ [class.abstract]p4:
1225 // A class is abstract if it contains or inherits at least one
1226 // pure virtual function for which the final overrider is pure
1228 if (SO->second.front().Method->isPure()) {
1229 data().Abstract = true;
1237 // Set access bits correctly on the directly-declared conversions.
1238 for (UnresolvedSetIterator I = data().Conversions.begin(),
1239 E = data().Conversions.end();
1241 I.setAccess((*I)->getAccess());
1244 bool CXXRecordDecl::mayBeAbstract() const {
1245 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1246 isDependentContext())
1249 for (CXXRecordDecl::base_class_const_iterator B = bases_begin(),
1252 CXXRecordDecl *BaseDecl
1253 = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl());
1254 if (BaseDecl->isAbstract())
1261 void CXXMethodDecl::anchor() { }
1263 bool CXXMethodDecl::isStatic() const {
1264 const CXXMethodDecl *MD = getCanonicalDecl();
1266 if (MD->getStorageClass() == SC_Static)
1269 DeclarationName Name = getDeclName();
1271 // Any allocation function for a class T is a static member
1272 // (even if not explicitly declared static).
1273 if (Name.getCXXOverloadedOperator() == OO_New ||
1274 Name.getCXXOverloadedOperator() == OO_Array_New)
1277 // [class.free]p6 Any deallocation function for a class X is a static member
1278 // (even if not explicitly declared static).
1279 if (Name.getCXXOverloadedOperator() == OO_Delete ||
1280 Name.getCXXOverloadedOperator() == OO_Array_Delete)
1286 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1287 const CXXMethodDecl *BaseMD) {
1288 for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
1289 E = DerivedMD->end_overridden_methods(); I != E; ++I) {
1290 const CXXMethodDecl *MD = *I;
1291 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1293 if (recursivelyOverrides(MD, BaseMD))
1300 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1302 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1305 // Lookup doesn't work for destructors, so handle them separately.
1306 if (isa<CXXDestructorDecl>(this)) {
1307 CXXMethodDecl *MD = RD->getDestructor();
1309 if (recursivelyOverrides(MD, this))
1311 if (MayBeBase && recursivelyOverrides(this, MD))
1317 lookup_const_result Candidates = RD->lookup(getDeclName());
1318 for (NamedDecl * const * I = Candidates.begin(); I != Candidates.end(); ++I) {
1319 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*I);
1322 if (recursivelyOverrides(MD, this))
1324 if (MayBeBase && recursivelyOverrides(this, MD))
1328 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1329 E = RD->bases_end(); I != E; ++I) {
1330 const RecordType *RT = I->getType()->getAs<RecordType>();
1333 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1334 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1343 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1344 SourceLocation StartLoc,
1345 const DeclarationNameInfo &NameInfo,
1346 QualType T, TypeSourceInfo *TInfo,
1347 StorageClass SC, bool isInline,
1348 bool isConstexpr, SourceLocation EndLocation) {
1349 return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo,
1350 SC, isInline, isConstexpr,
1354 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1355 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXMethodDecl));
1356 return new (Mem) CXXMethodDecl(CXXMethod, 0, SourceLocation(),
1357 DeclarationNameInfo(), QualType(),
1358 0, SC_None, false, false,
1362 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1363 if (getOverloadedOperator() != OO_Delete &&
1364 getOverloadedOperator() != OO_Array_Delete)
1367 // C++ [basic.stc.dynamic.deallocation]p2:
1368 // A template instance is never a usual deallocation function,
1369 // regardless of its signature.
1370 if (getPrimaryTemplate())
1373 // C++ [basic.stc.dynamic.deallocation]p2:
1374 // If a class T has a member deallocation function named operator delete
1375 // with exactly one parameter, then that function is a usual (non-placement)
1376 // deallocation function. [...]
1377 if (getNumParams() == 1)
1380 // C++ [basic.stc.dynamic.deallocation]p2:
1381 // [...] If class T does not declare such an operator delete but does
1382 // declare a member deallocation function named operator delete with
1383 // exactly two parameters, the second of which has type std::size_t (18.1),
1384 // then this function is a usual deallocation function.
1385 ASTContext &Context = getASTContext();
1386 if (getNumParams() != 2 ||
1387 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1388 Context.getSizeType()))
1391 // This function is a usual deallocation function if there are no
1392 // single-parameter deallocation functions of the same kind.
1393 DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
1394 for (DeclContext::lookup_const_result::iterator I = R.begin(), E = R.end();
1396 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
1397 if (FD->getNumParams() == 1)
1404 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1405 // C++0x [class.copy]p17:
1406 // A user-declared copy assignment operator X::operator= is a non-static
1407 // non-template member function of class X with exactly one parameter of
1408 // type X, X&, const X&, volatile X& or const volatile X&.
1409 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1410 /*non-static*/ isStatic() ||
1411 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate())
1414 QualType ParamType = getParamDecl(0)->getType();
1415 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1416 ParamType = Ref->getPointeeType();
1418 ASTContext &Context = getASTContext();
1420 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1421 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1424 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1425 // C++0x [class.copy]p19:
1426 // A user-declared move assignment operator X::operator= is a non-static
1427 // non-template member function of class X with exactly one parameter of type
1428 // X&&, const X&&, volatile X&&, or const volatile X&&.
1429 if (getOverloadedOperator() != OO_Equal || isStatic() ||
1430 getPrimaryTemplate() || getDescribedFunctionTemplate())
1433 QualType ParamType = getParamDecl(0)->getType();
1434 if (!isa<RValueReferenceType>(ParamType))
1436 ParamType = ParamType->getPointeeType();
1438 ASTContext &Context = getASTContext();
1440 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1441 return Context.hasSameUnqualifiedType(ClassType, ParamType);
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!");
1450 getASTContext().addOverriddenMethod(this, MD);
1453 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
1454 if (isa<CXXConstructorDecl>(this)) return 0;
1455 return getASTContext().overridden_methods_begin(this);
1458 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
1459 if (isa<CXXConstructorDecl>(this)) return 0;
1460 return getASTContext().overridden_methods_end(this);
1463 unsigned CXXMethodDecl::size_overridden_methods() const {
1464 if (isa<CXXConstructorDecl>(this)) return 0;
1465 return getASTContext().overridden_methods_size(this);
1468 QualType CXXMethodDecl::getThisType(ASTContext &C) const {
1469 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1470 // If the member function is declared const, the type of this is const X*,
1471 // if the member function is declared volatile, the type of this is
1472 // volatile X*, and if the member function is declared const volatile,
1473 // the type of this is const volatile X*.
1475 assert(isInstance() && "No 'this' for static methods!");
1477 QualType ClassTy = C.getTypeDeclType(getParent());
1478 ClassTy = C.getQualifiedType(ClassTy,
1479 Qualifiers::fromCVRMask(getTypeQualifiers()));
1480 return C.getPointerType(ClassTy);
1483 bool CXXMethodDecl::hasInlineBody() const {
1484 // If this function is a template instantiation, look at the template from
1485 // which it was instantiated.
1486 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1490 const FunctionDecl *fn;
1491 return CheckFn->hasBody(fn) && !fn->isOutOfLine();
1494 bool CXXMethodDecl::isLambdaStaticInvoker() const {
1495 return getParent()->isLambda() &&
1496 getIdentifier() && getIdentifier()->getName() == "__invoke";
1500 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1501 TypeSourceInfo *TInfo, bool IsVirtual,
1502 SourceLocation L, Expr *Init,
1504 SourceLocation EllipsisLoc)
1505 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
1506 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
1507 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1511 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1513 SourceLocation MemberLoc,
1514 SourceLocation L, Expr *Init,
1516 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1517 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1518 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1522 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1523 IndirectFieldDecl *Member,
1524 SourceLocation MemberLoc,
1525 SourceLocation L, Expr *Init,
1527 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1528 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1529 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1533 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1534 TypeSourceInfo *TInfo,
1535 SourceLocation L, Expr *Init,
1537 : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init),
1538 LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false),
1539 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1543 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1545 SourceLocation MemberLoc,
1546 SourceLocation L, Expr *Init,
1549 unsigned NumIndices)
1550 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1551 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1552 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices)
1554 VarDecl **MyIndices = reinterpret_cast<VarDecl **> (this + 1);
1555 memcpy(MyIndices, Indices, NumIndices * sizeof(VarDecl *));
1558 CXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context,
1560 SourceLocation MemberLoc,
1561 SourceLocation L, Expr *Init,
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);
1572 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
1573 if (isBaseInitializer())
1574 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
1579 const Type *CXXCtorInitializer::getBaseClass() const {
1580 if (isBaseInitializer())
1581 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1586 SourceLocation CXXCtorInitializer::getSourceLocation() const {
1587 if (isAnyMemberInitializer())
1588 return getMemberLocation();
1590 if (isInClassMemberInitializer())
1591 return getAnyMember()->getLocation();
1593 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>())
1594 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
1596 return SourceLocation();
1599 SourceRange CXXCtorInitializer::getSourceRange() const {
1600 if (isInClassMemberInitializer()) {
1601 FieldDecl *D = getAnyMember();
1602 if (Expr *I = D->getInClassInitializer())
1603 return I->getSourceRange();
1604 return SourceRange();
1607 return SourceRange(getSourceLocation(), getRParenLoc());
1610 void CXXConstructorDecl::anchor() { }
1612 CXXConstructorDecl *
1613 CXXConstructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1614 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXConstructorDecl));
1615 return new (Mem) CXXConstructorDecl(0, SourceLocation(),DeclarationNameInfo(),
1616 QualType(), 0, false, false, false,false);
1619 CXXConstructorDecl *
1620 CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1621 SourceLocation StartLoc,
1622 const DeclarationNameInfo &NameInfo,
1623 QualType T, TypeSourceInfo *TInfo,
1624 bool isExplicit, bool isInline,
1625 bool isImplicitlyDeclared, bool isConstexpr) {
1626 assert(NameInfo.getName().getNameKind()
1627 == DeclarationName::CXXConstructorName &&
1628 "Name must refer to a constructor");
1629 return new (C) CXXConstructorDecl(RD, StartLoc, NameInfo, T, TInfo,
1630 isExplicit, isInline, isImplicitlyDeclared,
1634 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
1635 assert(isDelegatingConstructor() && "Not a delegating constructor!");
1636 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
1637 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E))
1638 return Construct->getConstructor();
1643 bool CXXConstructorDecl::isDefaultConstructor() const {
1644 // C++ [class.ctor]p5:
1645 // A default constructor for a class X is a constructor of class
1646 // X that can be called without an argument.
1647 return (getNumParams() == 0) ||
1648 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
1652 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
1653 return isCopyOrMoveConstructor(TypeQuals) &&
1654 getParamDecl(0)->getType()->isLValueReferenceType();
1657 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
1658 return isCopyOrMoveConstructor(TypeQuals) &&
1659 getParamDecl(0)->getType()->isRValueReferenceType();
1662 /// \brief Determine whether this is a copy or move constructor.
1663 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
1664 // C++ [class.copy]p2:
1665 // A non-template constructor for class X is a copy constructor
1666 // if its first parameter is of type X&, const X&, volatile X& or
1667 // const volatile X&, and either there are no other parameters
1668 // or else all other parameters have default arguments (8.3.6).
1669 // C++0x [class.copy]p3:
1670 // A non-template constructor for class X is a move constructor if its
1671 // first parameter is of type X&&, const X&&, volatile X&&, or
1672 // const volatile X&&, and either there are no other parameters or else
1673 // all other parameters have default arguments.
1674 if ((getNumParams() < 1) ||
1675 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1676 (getPrimaryTemplate() != 0) ||
1677 (getDescribedFunctionTemplate() != 0))
1680 const ParmVarDecl *Param = getParamDecl(0);
1682 // Do we have a reference type?
1683 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
1687 // Is it a reference to our class type?
1688 ASTContext &Context = getASTContext();
1690 CanQualType PointeeType
1691 = Context.getCanonicalType(ParamRefType->getPointeeType());
1693 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1694 if (PointeeType.getUnqualifiedType() != ClassTy)
1697 // FIXME: other qualifiers?
1699 // We have a copy or move constructor.
1700 TypeQuals = PointeeType.getCVRQualifiers();
1704 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
1705 // C++ [class.conv.ctor]p1:
1706 // A constructor declared without the function-specifier explicit
1707 // that can be called with a single parameter specifies a
1708 // conversion from the type of its first parameter to the type of
1709 // its class. Such a constructor is called a converting
1711 if (isExplicit() && !AllowExplicit)
1714 return (getNumParams() == 0 &&
1715 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
1716 (getNumParams() == 1) ||
1717 (getNumParams() > 1 &&
1718 (getParamDecl(1)->hasDefaultArg() ||
1719 getParamDecl(1)->isParameterPack()));
1722 bool CXXConstructorDecl::isSpecializationCopyingObject() const {
1723 if ((getNumParams() < 1) ||
1724 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1725 (getPrimaryTemplate() == 0) ||
1726 (getDescribedFunctionTemplate() != 0))
1729 const ParmVarDecl *Param = getParamDecl(0);
1731 ASTContext &Context = getASTContext();
1732 CanQualType ParamType = Context.getCanonicalType(Param->getType());
1734 // Is it the same as our our class type?
1736 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1737 if (ParamType.getUnqualifiedType() != ClassTy)
1743 const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
1744 // Hack: we store the inherited constructor in the overridden method table
1745 method_iterator It = getASTContext().overridden_methods_begin(this);
1746 if (It == getASTContext().overridden_methods_end(this))
1749 return cast<CXXConstructorDecl>(*It);
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);
1760 void CXXDestructorDecl::anchor() { }
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);
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);
1782 void CXXConversionDecl::anchor() { }
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,
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,
1807 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1808 return isImplicit() && getParent()->isLambda() &&
1809 getConversionType()->isBlockPointerType();
1812 void LinkageSpecDecl::anchor() { }
1814 LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
1816 SourceLocation ExternLoc,
1817 SourceLocation LangLoc,
1820 return new (C) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
1823 LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1824 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LinkageSpecDecl));
1825 return new (Mem) LinkageSpecDecl(0, SourceLocation(), SourceLocation(),
1829 void UsingDirectiveDecl::anchor() { }
1831 UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
1833 SourceLocation NamespaceLoc,
1834 NestedNameSpecifierLoc QualifierLoc,
1835 SourceLocation IdentLoc,
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);
1844 UsingDirectiveDecl *
1845 UsingDirectiveDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1846 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingDirectiveDecl));
1847 return new (Mem) UsingDirectiveDecl(0, SourceLocation(), SourceLocation(),
1848 NestedNameSpecifierLoc(),
1849 SourceLocation(), 0, 0);
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);
1859 void NamespaceDecl::anchor() { }
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)
1868 setPreviousDeclaration(PrevDecl);
1871 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
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);
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(),
1887 void NamespaceAliasDecl::anchor() { }
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);
1902 NamespaceAliasDecl *
1903 NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1904 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(NamespaceAliasDecl));
1905 return new (Mem) NamespaceAliasDecl(0, SourceLocation(), SourceLocation(), 0,
1906 NestedNameSpecifierLoc(),
1907 SourceLocation(), 0);
1910 void UsingShadowDecl::anchor() { }
1913 UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1914 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UsingShadowDecl));
1915 return new (Mem) UsingShadowDecl(0, SourceLocation(), 0, 0);
1918 UsingDecl *UsingShadowDecl::getUsingDecl() const {
1919 const UsingShadowDecl *Shadow = this;
1920 while (const UsingShadowDecl *NextShadow =
1921 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
1922 Shadow = NextShadow;
1923 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
1926 void UsingDecl::anchor() { }
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);
1933 if (FirstUsingShadow.getPointer())
1934 S->UsingOrNextShadow = FirstUsingShadow.getPointer();
1935 FirstUsingShadow.setPointer(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);
1943 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
1945 if (FirstUsingShadow.getPointer() == S) {
1946 FirstUsingShadow.setPointer(
1947 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
1948 S->UsingOrNextShadow = this;
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;
1959 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
1960 NestedNameSpecifierLoc QualifierLoc,
1961 const DeclarationNameInfo &NameInfo,
1962 bool IsTypeNameArg) {
1963 return new (C) UsingDecl(DC, UL, QualifierLoc, NameInfo, IsTypeNameArg);
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);
1972 void UnresolvedUsingValueDecl::anchor() { }
1974 UnresolvedUsingValueDecl *
1975 UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
1976 SourceLocation UsingLoc,
1977 NestedNameSpecifierLoc QualifierLoc,
1978 const DeclarationNameInfo &NameInfo) {
1979 return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
1980 QualifierLoc, NameInfo);
1983 UnresolvedUsingValueDecl *
1984 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1985 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(UnresolvedUsingValueDecl));
1986 return new (Mem) UnresolvedUsingValueDecl(0, QualType(), SourceLocation(),
1987 NestedNameSpecifierLoc(),
1988 DeclarationNameInfo());
1991 void UnresolvedUsingTypenameDecl::anchor() { }
1993 UnresolvedUsingTypenameDecl *
1994 UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
1995 SourceLocation UsingLoc,
1996 SourceLocation TypenameLoc,
1997 NestedNameSpecifierLoc QualifierLoc,
1998 SourceLocation TargetNameLoc,
1999 DeclarationName TargetName) {
2000 return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc,
2001 QualifierLoc, TargetNameLoc,
2002 TargetName.getAsIdentifierInfo());
2005 UnresolvedUsingTypenameDecl *
2006 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2007 void *Mem = AllocateDeserializedDecl(C, ID,
2008 sizeof(UnresolvedUsingTypenameDecl));
2009 return new (Mem) UnresolvedUsingTypenameDecl(0, SourceLocation(),
2011 NestedNameSpecifierLoc(),
2016 void StaticAssertDecl::anchor() { }
2018 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
2019 SourceLocation StaticAssertLoc,
2021 StringLiteral *Message,
2022 SourceLocation RParenLoc,
2024 return new (C) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2028 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
2030 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(StaticAssertDecl));
2031 return new (Mem) StaticAssertDecl(0, SourceLocation(), 0, 0,
2032 SourceLocation(), false);
2035 static const char *getAccessName(AccessSpecifier AS) {
2038 llvm_unreachable("Invalid access specifier!");
2046 llvm_unreachable("Invalid access specifier!");
2049 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2050 AccessSpecifier AS) {
2051 return DB << getAccessName(AS);
2054 const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2055 AccessSpecifier AS) {
2056 return DB << getAccessName(AS);