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 //===----------------------------------------------------------------------===//
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTLambda.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 return new (C, ID) AccessSpecDecl(EmptyShell());
37 void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const {
38 ExternalASTSource *Source = C.getExternalSource();
39 assert(Impl.Decls.isLazy() && "getFromExternalSource for non-lazy set");
40 assert(Source && "getFromExternalSource with no external source");
42 for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); ++I)
43 I.setDecl(cast<NamedDecl>(Source->GetExternalDecl(
44 reinterpret_cast<uintptr_t>(I.getDecl()) >> 2)));
45 Impl.Decls.setLazy(false);
48 CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
49 : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
50 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
51 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
52 HasPrivateFields(false), HasProtectedFields(false), HasPublicFields(false),
53 HasMutableFields(false), HasVariantMembers(false), HasOnlyCMembers(true),
54 HasInClassInitializer(false), HasUninitializedReferenceMember(false),
55 NeedOverloadResolutionForMoveConstructor(false),
56 NeedOverloadResolutionForMoveAssignment(false),
57 NeedOverloadResolutionForDestructor(false),
58 DefaultedMoveConstructorIsDeleted(false),
59 DefaultedMoveAssignmentIsDeleted(false),
60 DefaultedDestructorIsDeleted(false),
61 HasTrivialSpecialMembers(SMF_All),
62 DeclaredNonTrivialSpecialMembers(0),
63 HasIrrelevantDestructor(true),
64 HasConstexprNonCopyMoveConstructor(false),
65 DefaultedDefaultConstructorIsConstexpr(true),
66 HasConstexprDefaultConstructor(false),
67 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
68 UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
69 ImplicitCopyConstructorHasConstParam(true),
70 ImplicitCopyAssignmentHasConstParam(true),
71 HasDeclaredCopyConstructorWithConstParam(false),
72 HasDeclaredCopyAssignmentWithConstParam(false),
73 IsLambda(false), IsParsingBaseSpecifiers(false), NumBases(0), NumVBases(0),
75 Definition(D), FirstFriend() {
78 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
79 return Bases.get(Definition->getASTContext().getExternalSource());
82 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
83 return VBases.get(Definition->getASTContext().getExternalSource());
86 CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C,
87 DeclContext *DC, SourceLocation StartLoc,
88 SourceLocation IdLoc, IdentifierInfo *Id,
89 CXXRecordDecl *PrevDecl)
90 : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl),
91 DefinitionData(PrevDecl ? PrevDecl->DefinitionData
92 : DefinitionDataPtr(this)),
93 TemplateOrInstantiation() {}
95 CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
96 DeclContext *DC, SourceLocation StartLoc,
97 SourceLocation IdLoc, IdentifierInfo *Id,
98 CXXRecordDecl* PrevDecl,
99 bool DelayTypeCreation) {
100 CXXRecordDecl *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc,
101 IdLoc, Id, PrevDecl);
102 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
104 // FIXME: DelayTypeCreation seems like such a hack
105 if (!DelayTypeCreation)
106 C.getTypeDeclType(R, PrevDecl);
111 CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
112 TypeSourceInfo *Info, SourceLocation Loc,
113 bool Dependent, bool IsGeneric,
114 LambdaCaptureDefault CaptureDefault) {
116 new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
118 R->IsBeingDefined = true;
120 new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
122 R->MayHaveOutOfDateDef = false;
123 R->setImplicit(true);
124 C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
129 CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
130 CXXRecordDecl *R = new (C, ID) CXXRecordDecl(
131 CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
133 R->MayHaveOutOfDateDef = false;
138 CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
140 ASTContext &C = getASTContext();
142 if (!data().Bases.isOffset() && data().NumBases > 0)
143 C.Deallocate(data().getBases());
146 // C++ [dcl.init.aggr]p1:
147 // An aggregate is [...] a class with [...] no base classes [...].
148 data().Aggregate = false;
151 // A POD-struct is an aggregate class...
152 data().PlainOldData = false;
155 // The set of seen virtual base types.
156 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
158 // The virtual bases of this class.
159 SmallVector<const CXXBaseSpecifier *, 8> VBases;
161 data().Bases = new(C) CXXBaseSpecifier [NumBases];
162 data().NumBases = NumBases;
163 for (unsigned i = 0; i < NumBases; ++i) {
164 data().getBases()[i] = *Bases[i];
165 // Keep track of inherited vbases for this base class.
166 const CXXBaseSpecifier *Base = Bases[i];
167 QualType BaseType = Base->getType();
168 // Skip dependent types; we can't do any checking on them now.
169 if (BaseType->isDependentType())
171 CXXRecordDecl *BaseClassDecl
172 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
174 // A class with a non-empty base class is not empty.
175 // FIXME: Standard ref?
176 if (!BaseClassDecl->isEmpty()) {
179 // A standard-layout class is a class that:
181 // -- either has no non-static data members in the most derived
182 // class and at most one base class with non-static data members,
183 // or has no base classes with non-static data members, and
184 // If this is the second non-empty base, then neither of these two
185 // clauses can be true.
186 data().IsStandardLayout = false;
189 data().Empty = false;
190 data().HasNoNonEmptyBases = false;
193 // C++ [class.virtual]p1:
194 // A class that declares or inherits a virtual function is called a
195 // polymorphic class.
196 if (BaseClassDecl->isPolymorphic())
197 data().Polymorphic = true;
200 // A standard-layout class is a class that: [...]
201 // -- has no non-standard-layout base classes
202 if (!BaseClassDecl->isStandardLayout())
203 data().IsStandardLayout = false;
205 // Record if this base is the first non-literal field or base.
206 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C))
207 data().HasNonLiteralTypeFieldsOrBases = true;
209 // Now go through all virtual bases of this base and add them.
210 for (const auto &VBase : BaseClassDecl->vbases()) {
211 // Add this base if it's not already in the list.
212 if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
213 VBases.push_back(&VBase);
215 // C++11 [class.copy]p8:
216 // The implicitly-declared copy constructor for a class X will have
217 // the form 'X::X(const X&)' if each [...] virtual base class B of X
218 // has a copy constructor whose first parameter is of type
219 // 'const B&' or 'const volatile B&' [...]
220 if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())
221 if (!VBaseDecl->hasCopyConstructorWithConstParam())
222 data().ImplicitCopyConstructorHasConstParam = false;
226 if (Base->isVirtual()) {
227 // Add this base if it's not already in the list.
228 if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
229 VBases.push_back(Base);
231 // C++0x [meta.unary.prop] is_empty:
232 // T is a class type, but not a union type, with ... no virtual base
234 data().Empty = false;
236 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
237 // A [default constructor, copy/move constructor, or copy/move assignment
238 // operator for a class X] is trivial [...] if:
239 // -- class X has [...] no virtual base classes
240 data().HasTrivialSpecialMembers &= SMF_Destructor;
243 // A standard-layout class is a class that: [...]
244 // -- has [...] no virtual base classes
245 data().IsStandardLayout = false;
247 // C++11 [dcl.constexpr]p4:
248 // In the definition of a constexpr constructor [...]
249 // -- the class shall not have any virtual base classes
250 data().DefaultedDefaultConstructorIsConstexpr = false;
252 // C++ [class.ctor]p5:
253 // A default constructor is trivial [...] if:
254 // -- all the direct base classes of its class have trivial default
256 if (!BaseClassDecl->hasTrivialDefaultConstructor())
257 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
259 // C++0x [class.copy]p13:
260 // A copy/move constructor for class X is trivial if [...]
262 // -- the constructor selected to copy/move each direct base class
263 // subobject is trivial, and
264 if (!BaseClassDecl->hasTrivialCopyConstructor())
265 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
266 // If the base class doesn't have a simple move constructor, we'll eagerly
267 // declare it and perform overload resolution to determine which function
268 // it actually calls. If it does have a simple move constructor, this
270 if (!BaseClassDecl->hasTrivialMoveConstructor())
271 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
273 // C++0x [class.copy]p27:
274 // A copy/move assignment operator for class X is trivial if [...]
276 // -- the assignment operator selected to copy/move each direct base
277 // class subobject is trivial, and
278 if (!BaseClassDecl->hasTrivialCopyAssignment())
279 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
280 // If the base class doesn't have a simple move assignment, we'll eagerly
281 // declare it and perform overload resolution to determine which function
282 // it actually calls. If it does have a simple move assignment, this
284 if (!BaseClassDecl->hasTrivialMoveAssignment())
285 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
287 // C++11 [class.ctor]p6:
288 // If that user-written default constructor would satisfy the
289 // requirements of a constexpr constructor, the implicitly-defined
290 // default constructor is constexpr.
291 if (!BaseClassDecl->hasConstexprDefaultConstructor())
292 data().DefaultedDefaultConstructorIsConstexpr = false;
295 // C++ [class.ctor]p3:
296 // A destructor is trivial if all the direct base classes of its class
297 // have trivial destructors.
298 if (!BaseClassDecl->hasTrivialDestructor())
299 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
301 if (!BaseClassDecl->hasIrrelevantDestructor())
302 data().HasIrrelevantDestructor = false;
304 // C++11 [class.copy]p18:
305 // The implicitly-declared copy assignment oeprator for a class X will
306 // have the form 'X& X::operator=(const X&)' if each direct base class B
307 // of X has a copy assignment operator whose parameter is of type 'const
308 // B&', 'const volatile B&', or 'B' [...]
309 if (!BaseClassDecl->hasCopyAssignmentWithConstParam())
310 data().ImplicitCopyAssignmentHasConstParam = false;
312 // C++11 [class.copy]p8:
313 // The implicitly-declared copy constructor for a class X will have
314 // the form 'X::X(const X&)' if each direct [...] base class B of X
315 // has a copy constructor whose first parameter is of type
316 // 'const B&' or 'const volatile B&' [...]
317 if (!BaseClassDecl->hasCopyConstructorWithConstParam())
318 data().ImplicitCopyConstructorHasConstParam = false;
320 // A class has an Objective-C object member if... or any of its bases
321 // has an Objective-C object member.
322 if (BaseClassDecl->hasObjectMember())
323 setHasObjectMember(true);
325 if (BaseClassDecl->hasVolatileMember())
326 setHasVolatileMember(true);
328 // Keep track of the presence of mutable fields.
329 if (BaseClassDecl->hasMutableFields())
330 data().HasMutableFields = true;
332 if (BaseClassDecl->hasUninitializedReferenceMember())
333 data().HasUninitializedReferenceMember = true;
335 addedClassSubobject(BaseClassDecl);
338 if (VBases.empty()) {
339 data().IsParsingBaseSpecifiers = false;
343 // Create base specifier for any direct or indirect virtual bases.
344 data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
345 data().NumVBases = VBases.size();
346 for (int I = 0, E = VBases.size(); I != E; ++I) {
347 QualType Type = VBases[I]->getType();
348 if (!Type->isDependentType())
349 addedClassSubobject(Type->getAsCXXRecordDecl());
350 data().getVBases()[I] = *VBases[I];
353 data().IsParsingBaseSpecifiers = false;
356 void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) {
357 // C++11 [class.copy]p11:
358 // A defaulted copy/move constructor for a class X is defined as
360 // -- a direct or virtual base class B that cannot be copied/moved [...]
361 // -- a non-static data member of class type M (or array thereof)
362 // that cannot be copied or moved [...]
363 if (!Subobj->hasSimpleMoveConstructor())
364 data().NeedOverloadResolutionForMoveConstructor = true;
366 // C++11 [class.copy]p23:
367 // A defaulted copy/move assignment operator for a class X is defined as
369 // -- a direct or virtual base class B that cannot be copied/moved [...]
370 // -- a non-static data member of class type M (or array thereof)
371 // that cannot be copied or moved [...]
372 if (!Subobj->hasSimpleMoveAssignment())
373 data().NeedOverloadResolutionForMoveAssignment = true;
375 // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5:
376 // A defaulted [ctor or dtor] for a class X is defined as
378 // -- any direct or virtual base class [...] has a type with a destructor
379 // that is deleted or inaccessible from the defaulted [ctor or dtor].
380 // -- any non-static data member has a type with a destructor
381 // that is deleted or inaccessible from the defaulted [ctor or dtor].
382 if (!Subobj->hasSimpleDestructor()) {
383 data().NeedOverloadResolutionForMoveConstructor = true;
384 data().NeedOverloadResolutionForDestructor = true;
388 bool CXXRecordDecl::hasAnyDependentBases() const {
389 if (!isDependentContext())
392 return !forallBases([](const CXXRecordDecl *) { return true; });
395 bool CXXRecordDecl::isTriviallyCopyable() const {
397 // A trivially copyable class is a class that:
398 // -- has no non-trivial copy constructors,
399 if (hasNonTrivialCopyConstructor()) return false;
400 // -- has no non-trivial move constructors,
401 if (hasNonTrivialMoveConstructor()) return false;
402 // -- has no non-trivial copy assignment operators,
403 if (hasNonTrivialCopyAssignment()) return false;
404 // -- has no non-trivial move assignment operators, and
405 if (hasNonTrivialMoveAssignment()) return false;
406 // -- has a trivial destructor.
407 if (!hasTrivialDestructor()) return false;
412 void CXXRecordDecl::markedVirtualFunctionPure() {
413 // C++ [class.abstract]p2:
414 // A class is abstract if it has at least one pure virtual function.
415 data().Abstract = true;
418 void CXXRecordDecl::addedMember(Decl *D) {
419 if (!D->isImplicit() &&
420 !isa<FieldDecl>(D) &&
421 !isa<IndirectFieldDecl>(D) &&
422 (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
423 cast<TagDecl>(D)->getTagKind() == TTK_Interface))
424 data().HasOnlyCMembers = false;
426 // Ignore friends and invalid declarations.
427 if (D->getFriendObjectKind() || D->isInvalidDecl())
430 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
432 D = FunTmpl->getTemplatedDecl();
434 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
435 if (Method->isVirtual()) {
436 // C++ [dcl.init.aggr]p1:
437 // An aggregate is an array or a class with [...] no virtual functions.
438 data().Aggregate = false;
441 // A POD-struct is an aggregate class...
442 data().PlainOldData = false;
444 // Virtual functions make the class non-empty.
445 // FIXME: Standard ref?
446 data().Empty = false;
448 // C++ [class.virtual]p1:
449 // A class that declares or inherits a virtual function is called a
450 // polymorphic class.
451 data().Polymorphic = true;
453 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
454 // A [default constructor, copy/move constructor, or copy/move
455 // assignment operator for a class X] is trivial [...] if:
456 // -- class X has no virtual functions [...]
457 data().HasTrivialSpecialMembers &= SMF_Destructor;
460 // A standard-layout class is a class that: [...]
461 // -- has no virtual functions
462 data().IsStandardLayout = false;
466 // Notify the listener if an implicit member was added after the definition
468 if (!isBeingDefined() && D->isImplicit())
469 if (ASTMutationListener *L = getASTMutationListener())
470 L->AddedCXXImplicitMember(data().Definition, D);
472 // The kind of special member this declaration is, if any.
475 // Handle constructors.
476 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
477 if (!Constructor->isImplicit()) {
478 // Note that we have a user-declared constructor.
479 data().UserDeclaredConstructor = true;
482 // A POD-struct is an aggregate class [...]
483 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
484 // type is technically an aggregate in C++0x since it wouldn't be in 03.
485 data().PlainOldData = false;
488 // Technically, "user-provided" is only defined for special member
489 // functions, but the intent of the standard is clearly that it should apply
491 bool UserProvided = Constructor->isUserProvided();
493 if (Constructor->isDefaultConstructor()) {
494 SMKind |= SMF_DefaultConstructor;
497 data().UserProvidedDefaultConstructor = true;
498 if (Constructor->isConstexpr())
499 data().HasConstexprDefaultConstructor = true;
504 if (Constructor->isCopyConstructor(Quals)) {
505 SMKind |= SMF_CopyConstructor;
507 if (Quals & Qualifiers::Const)
508 data().HasDeclaredCopyConstructorWithConstParam = true;
509 } else if (Constructor->isMoveConstructor())
510 SMKind |= SMF_MoveConstructor;
513 // Record if we see any constexpr constructors which are neither copy
514 // nor move constructors.
515 if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
516 data().HasConstexprNonCopyMoveConstructor = true;
518 // C++ [dcl.init.aggr]p1:
519 // An aggregate is an array or a class with no user-declared
520 // constructors [...].
521 // C++11 [dcl.init.aggr]p1:
522 // An aggregate is an array or a class with no user-provided
523 // constructors [...].
524 if (getASTContext().getLangOpts().CPlusPlus11
525 ? UserProvided : !Constructor->isImplicit())
526 data().Aggregate = false;
529 // Handle destructors.
530 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
531 SMKind |= SMF_Destructor;
533 if (DD->isUserProvided())
534 data().HasIrrelevantDestructor = false;
535 // If the destructor is explicitly defaulted and not trivial or not public
536 // or if the destructor is deleted, we clear HasIrrelevantDestructor in
537 // finishedDefaultedOrDeletedMember.
539 // C++11 [class.dtor]p5:
540 // A destructor is trivial if [...] the destructor is not virtual.
542 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
545 // Handle member functions.
546 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
547 if (Method->isCopyAssignmentOperator()) {
548 SMKind |= SMF_CopyAssignment;
550 const ReferenceType *ParamTy =
551 Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
552 if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
553 data().HasDeclaredCopyAssignmentWithConstParam = true;
556 if (Method->isMoveAssignmentOperator())
557 SMKind |= SMF_MoveAssignment;
559 // Keep the list of conversion functions up-to-date.
560 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
561 // FIXME: We use the 'unsafe' accessor for the access specifier here,
562 // because Sema may not have set it yet. That's really just a misdesign
563 // in Sema. However, LLDB *will* have set the access specifier correctly,
564 // and adds declarations after the class is technically completed,
565 // so completeDefinition()'s overriding of the access specifiers doesn't
567 AccessSpecifier AS = Conversion->getAccessUnsafe();
569 if (Conversion->getPrimaryTemplate()) {
570 // We don't record specializations.
572 ASTContext &Ctx = getASTContext();
573 ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);
575 FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion);
576 if (Primary->getPreviousDecl())
577 Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),
580 Conversions.addDecl(Ctx, Primary, AS);
585 // If this is the first declaration of a special member, we no longer have
586 // an implicit trivial special member.
587 data().HasTrivialSpecialMembers &=
588 data().DeclaredSpecialMembers | ~SMKind;
590 if (!Method->isImplicit() && !Method->isUserProvided()) {
591 // This method is user-declared but not user-provided. We can't work out
592 // whether it's trivial yet (not until we get to the end of the class).
593 // We'll handle this method in finishedDefaultedOrDeletedMember.
594 } else if (Method->isTrivial())
595 data().HasTrivialSpecialMembers |= SMKind;
597 data().DeclaredNonTrivialSpecialMembers |= SMKind;
599 // Note when we have declared a declared special member, and suppress the
600 // implicit declaration of this special member.
601 data().DeclaredSpecialMembers |= SMKind;
603 if (!Method->isImplicit()) {
604 data().UserDeclaredSpecialMembers |= SMKind;
607 // A POD-struct is an aggregate class that has [...] no user-defined
608 // copy assignment operator and no user-defined destructor.
610 // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
611 // aggregates could not have any constructors, clear it even for an
612 // explicitly defaulted or deleted constructor.
613 // type is technically an aggregate in C++0x since it wouldn't be in 03.
615 // Also, a user-declared move assignment operator makes a class non-POD.
616 // This is an extension in C++03.
617 data().PlainOldData = false;
624 // Handle non-static data members.
625 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
626 // C++ [class.bit]p2:
627 // A declaration for a bit-field that omits the identifier declares an
628 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
630 if (Field->isUnnamedBitfield())
633 // C++ [dcl.init.aggr]p1:
634 // An aggregate is an array or a class (clause 9) with [...] no
635 // private or protected non-static data members (clause 11).
637 // A POD must be an aggregate.
638 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
639 data().Aggregate = false;
640 data().PlainOldData = false;
644 // A standard-layout class is a class that:
646 // -- has the same access control for all non-static data members,
647 switch (D->getAccess()) {
648 case AS_private: data().HasPrivateFields = true; break;
649 case AS_protected: data().HasProtectedFields = true; break;
650 case AS_public: data().HasPublicFields = true; break;
651 case AS_none: llvm_unreachable("Invalid access specifier");
653 if ((data().HasPrivateFields + data().HasProtectedFields +
654 data().HasPublicFields) > 1)
655 data().IsStandardLayout = false;
657 // Keep track of the presence of mutable fields.
658 if (Field->isMutable())
659 data().HasMutableFields = true;
661 // C++11 [class.union]p8, DR1460:
662 // If X is a union, a non-static data member of X that is not an anonymous
663 // union is a variant member of X.
664 if (isUnion() && !Field->isAnonymousStructOrUnion())
665 data().HasVariantMembers = true;
668 // A POD struct is a class that is both a trivial class and a
669 // standard-layout class, and has no non-static data members of type
670 // non-POD struct, non-POD union (or array of such types).
672 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
673 // that does not explicitly have no lifetime makes the class a non-POD.
674 ASTContext &Context = getASTContext();
675 QualType T = Context.getBaseElementType(Field->getType());
676 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
677 if (!Context.getLangOpts().ObjCAutoRefCount) {
678 setHasObjectMember(true);
679 } else if (T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
680 // Objective-C Automatic Reference Counting:
681 // If a class has a non-static data member of Objective-C pointer
682 // type (or array thereof), it is a non-POD type and its
683 // default constructor (if any), copy constructor, move constructor,
684 // copy assignment operator, move assignment operator, and destructor are
686 setHasObjectMember(true);
687 struct DefinitionData &Data = data();
688 Data.PlainOldData = false;
689 Data.HasTrivialSpecialMembers = 0;
690 Data.HasIrrelevantDestructor = false;
692 } else if (!T.isCXX98PODType(Context))
693 data().PlainOldData = false;
695 if (T->isReferenceType()) {
696 if (!Field->hasInClassInitializer())
697 data().HasUninitializedReferenceMember = true;
700 // A standard-layout class is a class that:
701 // -- has no non-static data members of type [...] reference,
702 data().IsStandardLayout = false;
705 // Record if this field is the first non-literal or volatile field or base.
706 if (!T->isLiteralType(Context) || T.isVolatileQualified())
707 data().HasNonLiteralTypeFieldsOrBases = true;
709 if (Field->hasInClassInitializer() ||
710 (Field->isAnonymousStructOrUnion() &&
711 Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
712 data().HasInClassInitializer = true;
715 // A default constructor is trivial if [...] no non-static data member
716 // of its class has a brace-or-equal-initializer.
717 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
719 // C++11 [dcl.init.aggr]p1:
720 // An aggregate is a [...] class with [...] no
721 // brace-or-equal-initializers for non-static data members.
723 // This rule was removed in C++1y.
724 if (!getASTContext().getLangOpts().CPlusPlus14)
725 data().Aggregate = false;
728 // A POD struct is [...] a trivial class.
729 data().PlainOldData = false;
732 // C++11 [class.copy]p23:
733 // A defaulted copy/move assignment operator for a class X is defined
734 // as deleted if X has:
735 // -- a non-static data member of reference type
736 if (T->isReferenceType())
737 data().DefaultedMoveAssignmentIsDeleted = true;
739 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
740 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
741 if (FieldRec->getDefinition()) {
742 addedClassSubobject(FieldRec);
744 // We may need to perform overload resolution to determine whether a
745 // field can be moved if it's const or volatile qualified.
746 if (T.getCVRQualifiers() & (Qualifiers::Const | Qualifiers::Volatile)) {
747 data().NeedOverloadResolutionForMoveConstructor = true;
748 data().NeedOverloadResolutionForMoveAssignment = true;
751 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
752 // A defaulted [special member] for a class X is defined as
754 // -- X is a union-like class that has a variant member with a
755 // non-trivial [corresponding special member]
757 if (FieldRec->hasNonTrivialMoveConstructor())
758 data().DefaultedMoveConstructorIsDeleted = true;
759 if (FieldRec->hasNonTrivialMoveAssignment())
760 data().DefaultedMoveAssignmentIsDeleted = true;
761 if (FieldRec->hasNonTrivialDestructor())
762 data().DefaultedDestructorIsDeleted = true;
765 // C++0x [class.ctor]p5:
766 // A default constructor is trivial [...] if:
767 // -- for all the non-static data members of its class that are of
768 // class type (or array thereof), each such class has a trivial
769 // default constructor.
770 if (!FieldRec->hasTrivialDefaultConstructor())
771 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
773 // C++0x [class.copy]p13:
774 // A copy/move constructor for class X is trivial if [...]
776 // -- for each non-static data member of X that is of class type (or
777 // an array thereof), the constructor selected to copy/move that
778 // member is trivial;
779 if (!FieldRec->hasTrivialCopyConstructor())
780 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
781 // If the field doesn't have a simple move constructor, we'll eagerly
782 // declare the move constructor for this class and we'll decide whether
783 // it's trivial then.
784 if (!FieldRec->hasTrivialMoveConstructor())
785 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
787 // C++0x [class.copy]p27:
788 // A copy/move assignment operator for class X is trivial if [...]
790 // -- for each non-static data member of X that is of class type (or
791 // an array thereof), the assignment operator selected to
792 // copy/move that member is trivial;
793 if (!FieldRec->hasTrivialCopyAssignment())
794 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
795 // If the field doesn't have a simple move assignment, we'll eagerly
796 // declare the move assignment for this class and we'll decide whether
797 // it's trivial then.
798 if (!FieldRec->hasTrivialMoveAssignment())
799 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
801 if (!FieldRec->hasTrivialDestructor())
802 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
803 if (!FieldRec->hasIrrelevantDestructor())
804 data().HasIrrelevantDestructor = false;
805 if (FieldRec->hasObjectMember())
806 setHasObjectMember(true);
807 if (FieldRec->hasVolatileMember())
808 setHasVolatileMember(true);
811 // A standard-layout class is a class that:
812 // -- has no non-static data members of type non-standard-layout
813 // class (or array of such types) [...]
814 if (!FieldRec->isStandardLayout())
815 data().IsStandardLayout = false;
818 // A standard-layout class is a class that:
820 // -- has no base classes of the same type as the first non-static
822 // We don't want to expend bits in the state of the record decl
823 // tracking whether this is the first non-static data member so we
824 // cheat a bit and use some of the existing state: the empty bit.
825 // Virtual bases and virtual methods make a class non-empty, but they
826 // also make it non-standard-layout so we needn't check here.
827 // A non-empty base class may leave the class standard-layout, but not
828 // if we have arrived here, and have at least one non-static data
829 // member. If IsStandardLayout remains true, then the first non-static
830 // data member must come through here with Empty still true, and Empty
831 // will subsequently be set to false below.
832 if (data().IsStandardLayout && data().Empty) {
833 for (const auto &BI : bases()) {
834 if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
835 data().IsStandardLayout = false;
841 // Keep track of the presence of mutable fields.
842 if (FieldRec->hasMutableFields())
843 data().HasMutableFields = true;
845 // C++11 [class.copy]p13:
846 // If the implicitly-defined constructor would satisfy the
847 // requirements of a constexpr constructor, the implicitly-defined
848 // constructor is constexpr.
849 // C++11 [dcl.constexpr]p4:
850 // -- every constructor involved in initializing non-static data
851 // members [...] shall be a constexpr constructor
852 if (!Field->hasInClassInitializer() &&
853 !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
854 // The standard requires any in-class initializer to be a constant
855 // expression. We consider this to be a defect.
856 data().DefaultedDefaultConstructorIsConstexpr = false;
858 // C++11 [class.copy]p8:
859 // The implicitly-declared copy constructor for a class X will have
860 // the form 'X::X(const X&)' if [...] for all the non-static data
861 // members of X that are of a class type M (or array thereof), each
862 // such class type has a copy constructor whose first parameter is
863 // of type 'const M&' or 'const volatile M&'.
864 if (!FieldRec->hasCopyConstructorWithConstParam())
865 data().ImplicitCopyConstructorHasConstParam = false;
867 // C++11 [class.copy]p18:
868 // The implicitly-declared copy assignment oeprator for a class X will
869 // have the form 'X& X::operator=(const X&)' if [...] for all the
870 // non-static data members of X that are of a class type M (or array
871 // thereof), each such class type has a copy assignment operator whose
872 // parameter is of type 'const M&', 'const volatile M&' or 'M'.
873 if (!FieldRec->hasCopyAssignmentWithConstParam())
874 data().ImplicitCopyAssignmentHasConstParam = false;
876 if (FieldRec->hasUninitializedReferenceMember() &&
877 !Field->hasInClassInitializer())
878 data().HasUninitializedReferenceMember = true;
880 // C++11 [class.union]p8, DR1460:
881 // a non-static data member of an anonymous union that is a member of
882 // X is also a variant member of X.
883 if (FieldRec->hasVariantMembers() &&
884 Field->isAnonymousStructOrUnion())
885 data().HasVariantMembers = true;
888 // Base element type of field is a non-class type.
889 if (!T->isLiteralType(Context) ||
890 (!Field->hasInClassInitializer() && !isUnion()))
891 data().DefaultedDefaultConstructorIsConstexpr = false;
893 // C++11 [class.copy]p23:
894 // A defaulted copy/move assignment operator for a class X is defined
895 // as deleted if X has:
896 // -- a non-static data member of const non-class type (or array
898 if (T.isConstQualified())
899 data().DefaultedMoveAssignmentIsDeleted = true;
903 // A standard-layout class is a class that:
905 // -- either has no non-static data members in the most derived
906 // class and at most one base class with non-static data members,
907 // or has no base classes with non-static data members, and
908 // At this point we know that we have a non-static data member, so the last
910 if (!data().HasNoNonEmptyBases)
911 data().IsStandardLayout = false;
913 // If this is not a zero-length bit-field, then the class is not empty.
915 if (!Field->isBitField() ||
916 (!Field->getBitWidth()->isTypeDependent() &&
917 !Field->getBitWidth()->isValueDependent() &&
918 Field->getBitWidthValue(Context) != 0))
919 data().Empty = false;
923 // Handle using declarations of conversion functions.
924 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) {
925 if (Shadow->getDeclName().getNameKind()
926 == DeclarationName::CXXConversionFunctionName) {
927 ASTContext &Ctx = getASTContext();
928 data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
933 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
934 assert(!D->isImplicit() && !D->isUserProvided());
936 // The kind of special member this declaration is, if any.
939 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
940 if (Constructor->isDefaultConstructor()) {
941 SMKind |= SMF_DefaultConstructor;
942 if (Constructor->isConstexpr())
943 data().HasConstexprDefaultConstructor = true;
945 if (Constructor->isCopyConstructor())
946 SMKind |= SMF_CopyConstructor;
947 else if (Constructor->isMoveConstructor())
948 SMKind |= SMF_MoveConstructor;
949 else if (Constructor->isConstexpr())
950 // We may now know that the constructor is constexpr.
951 data().HasConstexprNonCopyMoveConstructor = true;
952 } else if (isa<CXXDestructorDecl>(D)) {
953 SMKind |= SMF_Destructor;
954 if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
955 data().HasIrrelevantDestructor = false;
956 } else if (D->isCopyAssignmentOperator())
957 SMKind |= SMF_CopyAssignment;
958 else if (D->isMoveAssignmentOperator())
959 SMKind |= SMF_MoveAssignment;
961 // Update which trivial / non-trivial special members we have.
962 // addedMember will have skipped this step for this member.
964 data().HasTrivialSpecialMembers |= SMKind;
966 data().DeclaredNonTrivialSpecialMembers |= SMKind;
969 bool CXXRecordDecl::isCLike() const {
970 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
971 !TemplateOrInstantiation.isNull())
973 if (!hasDefinition())
976 return isPOD() && data().HasOnlyCMembers;
979 bool CXXRecordDecl::isGenericLambda() const {
980 if (!isLambda()) return false;
981 return getLambdaData().IsGenericLambda;
984 CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const {
985 if (!isLambda()) return nullptr;
986 DeclarationName Name =
987 getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
988 DeclContext::lookup_result Calls = lookup(Name);
990 assert(!Calls.empty() && "Missing lambda call operator!");
991 assert(Calls.size() == 1 && "More than one lambda call operator!");
993 NamedDecl *CallOp = Calls.front();
994 if (FunctionTemplateDecl *CallOpTmpl =
995 dyn_cast<FunctionTemplateDecl>(CallOp))
996 return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
998 return cast<CXXMethodDecl>(CallOp);
1001 CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
1002 if (!isLambda()) return nullptr;
1003 DeclarationName Name =
1004 &getASTContext().Idents.get(getLambdaStaticInvokerName());
1005 DeclContext::lookup_result Invoker = lookup(Name);
1006 if (Invoker.empty()) return nullptr;
1007 assert(Invoker.size() == 1 && "More than one static invoker operator!");
1008 NamedDecl *InvokerFun = Invoker.front();
1009 if (FunctionTemplateDecl *InvokerTemplate =
1010 dyn_cast<FunctionTemplateDecl>(InvokerFun))
1011 return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
1013 return cast<CXXMethodDecl>(InvokerFun);
1016 void CXXRecordDecl::getCaptureFields(
1017 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
1018 FieldDecl *&ThisCapture) const {
1020 ThisCapture = nullptr;
1022 LambdaDefinitionData &Lambda = getLambdaData();
1023 RecordDecl::field_iterator Field = field_begin();
1024 for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
1025 C != CEnd; ++C, ++Field) {
1026 if (C->capturesThis())
1027 ThisCapture = *Field;
1028 else if (C->capturesVariable())
1029 Captures[C->getCapturedVar()] = *Field;
1031 assert(Field == field_end());
1034 TemplateParameterList *
1035 CXXRecordDecl::getGenericLambdaTemplateParameterList() const {
1036 if (!isLambda()) return nullptr;
1037 CXXMethodDecl *CallOp = getLambdaCallOperator();
1038 if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate())
1039 return Tmpl->getTemplateParameters();
1043 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
1045 cast<CXXConversionDecl>(Conv->getUnderlyingDecl()->getAsFunction())
1046 ->getConversionType();
1047 return Context.getCanonicalType(T);
1050 /// Collect the visible conversions of a base class.
1052 /// \param Record a base class of the class we're considering
1053 /// \param InVirtual whether this base class is a virtual base (or a base
1054 /// of a virtual base)
1055 /// \param Access the access along the inheritance path to this base
1056 /// \param ParentHiddenTypes the conversions provided by the inheritors
1058 /// \param Output the set to which to add conversions from non-virtual bases
1059 /// \param VOutput the set to which to add conversions from virtual bases
1060 /// \param HiddenVBaseCs the set of conversions which were hidden in a
1061 /// virtual base along some inheritance path
1062 static void CollectVisibleConversions(ASTContext &Context,
1063 CXXRecordDecl *Record,
1065 AccessSpecifier Access,
1066 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
1067 ASTUnresolvedSet &Output,
1068 UnresolvedSetImpl &VOutput,
1069 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
1070 // The set of types which have conversions in this class or its
1071 // subclasses. As an optimization, we don't copy the derived set
1072 // unless it might change.
1073 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
1074 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
1076 // Collect the direct conversions and figure out which conversions
1077 // will be hidden in the subclasses.
1078 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1079 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1080 if (ConvI != ConvE) {
1081 HiddenTypesBuffer = ParentHiddenTypes;
1082 HiddenTypes = &HiddenTypesBuffer;
1084 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
1085 CanQualType ConvType(GetConversionType(Context, I.getDecl()));
1086 bool Hidden = ParentHiddenTypes.count(ConvType);
1088 HiddenTypesBuffer.insert(ConvType);
1090 // If this conversion is hidden and we're in a virtual base,
1091 // remember that it's hidden along some inheritance path.
1092 if (Hidden && InVirtual)
1093 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1095 // If this conversion isn't hidden, add it to the appropriate output.
1097 AccessSpecifier IAccess
1098 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1101 VOutput.addDecl(I.getDecl(), IAccess);
1103 Output.addDecl(Context, I.getDecl(), IAccess);
1108 // Collect information recursively from any base classes.
1109 for (const auto &I : Record->bases()) {
1110 const RecordType *RT = I.getType()->getAs<RecordType>();
1113 AccessSpecifier BaseAccess
1114 = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
1115 bool BaseInVirtual = InVirtual || I.isVirtual();
1117 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1118 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1119 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
1123 /// Collect the visible conversions of a class.
1125 /// This would be extremely straightforward if it weren't for virtual
1126 /// bases. It might be worth special-casing that, really.
1127 static void CollectVisibleConversions(ASTContext &Context,
1128 CXXRecordDecl *Record,
1129 ASTUnresolvedSet &Output) {
1130 // The collection of all conversions in virtual bases that we've
1131 // found. These will be added to the output as long as they don't
1132 // appear in the hidden-conversions set.
1133 UnresolvedSet<8> VBaseCs;
1135 // The set of conversions in virtual bases that we've determined to
1137 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1139 // The set of types hidden by classes derived from this one.
1140 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1142 // Go ahead and collect the direct conversions and add them to the
1143 // hidden-types set.
1144 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1145 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1146 Output.append(Context, ConvI, ConvE);
1147 for (; ConvI != ConvE; ++ConvI)
1148 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
1150 // Recursively collect conversions from base classes.
1151 for (const auto &I : Record->bases()) {
1152 const RecordType *RT = I.getType()->getAs<RecordType>();
1155 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
1156 I.isVirtual(), I.getAccessSpecifier(),
1157 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1160 // Add any unhidden conversions provided by virtual bases.
1161 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1163 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
1164 Output.addDecl(Context, I.getDecl(), I.getAccess());
1168 /// getVisibleConversionFunctions - get all conversion functions visible
1169 /// in current class; including conversion function templates.
1170 llvm::iterator_range<CXXRecordDecl::conversion_iterator>
1171 CXXRecordDecl::getVisibleConversionFunctions() {
1172 ASTContext &Ctx = getASTContext();
1174 ASTUnresolvedSet *Set;
1175 if (bases_begin() == bases_end()) {
1176 // If root class, all conversions are visible.
1177 Set = &data().Conversions.get(Ctx);
1179 Set = &data().VisibleConversions.get(Ctx);
1180 // If visible conversion list is not evaluated, evaluate it.
1181 if (!data().ComputedVisibleConversions) {
1182 CollectVisibleConversions(Ctx, this, *Set);
1183 data().ComputedVisibleConversions = true;
1186 return llvm::make_range(Set->begin(), Set->end());
1189 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1190 // This operation is O(N) but extremely rare. Sema only uses it to
1191 // remove UsingShadowDecls in a class that were followed by a direct
1192 // declaration, e.g.:
1194 // using B::operator int;
1197 // This is uncommon by itself and even more uncommon in conjunction
1198 // with sufficiently large numbers of directly-declared conversions
1199 // that asymptotic behavior matters.
1201 ASTUnresolvedSet &Convs = data().Conversions.get(getASTContext());
1202 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1203 if (Convs[I].getDecl() == ConvDecl) {
1205 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1206 && "conversion was found multiple times in unresolved set");
1211 llvm_unreachable("conversion not found in set!");
1214 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1215 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1216 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1221 MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const {
1222 return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>();
1226 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1227 TemplateSpecializationKind TSK) {
1228 assert(TemplateOrInstantiation.isNull() &&
1229 "Previous template or instantiation?");
1230 assert(!isa<ClassTemplatePartialSpecializationDecl>(this));
1231 TemplateOrInstantiation
1232 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1235 ClassTemplateDecl *CXXRecordDecl::getDescribedClassTemplate() const {
1236 return TemplateOrInstantiation.dyn_cast<ClassTemplateDecl *>();
1239 void CXXRecordDecl::setDescribedClassTemplate(ClassTemplateDecl *Template) {
1240 TemplateOrInstantiation = Template;
1243 TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1244 if (const ClassTemplateSpecializationDecl *Spec
1245 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1246 return Spec->getSpecializationKind();
1248 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1249 return MSInfo->getTemplateSpecializationKind();
1251 return TSK_Undeclared;
1255 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1256 if (ClassTemplateSpecializationDecl *Spec
1257 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1258 Spec->setSpecializationKind(TSK);
1262 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1263 MSInfo->setTemplateSpecializationKind(TSK);
1267 llvm_unreachable("Not a class template or member class specialization");
1270 const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {
1271 // If it's a class template specialization, find the template or partial
1272 // specialization from which it was instantiated.
1273 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1274 auto From = TD->getInstantiatedFrom();
1275 if (auto *CTD = From.dyn_cast<ClassTemplateDecl *>()) {
1276 while (auto *NewCTD = CTD->getInstantiatedFromMemberTemplate()) {
1277 if (NewCTD->isMemberSpecialization())
1281 return CTD->getTemplatedDecl()->getDefinition();
1284 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
1285 while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) {
1286 if (NewCTPSD->isMemberSpecialization())
1290 return CTPSD->getDefinition();
1294 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1295 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
1296 const CXXRecordDecl *RD = this;
1297 while (auto *NewRD = RD->getInstantiatedFromMemberClass())
1299 return RD->getDefinition();
1303 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) &&
1304 "couldn't find pattern for class template instantiation");
1308 CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1309 ASTContext &Context = getASTContext();
1310 QualType ClassType = Context.getTypeDeclType(this);
1312 DeclarationName Name
1313 = Context.DeclarationNames.getCXXDestructorName(
1314 Context.getCanonicalType(ClassType));
1316 DeclContext::lookup_result R = lookup(Name);
1320 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
1324 bool CXXRecordDecl::isAnyDestructorNoReturn() const {
1325 // Destructor is noreturn.
1326 if (const CXXDestructorDecl *Destructor = getDestructor())
1327 if (Destructor->isNoReturn())
1330 // Check base classes destructor for noreturn.
1331 for (const auto &Base : bases())
1332 if (Base.getType()->getAsCXXRecordDecl()->isAnyDestructorNoReturn())
1335 // Check fields for noreturn.
1336 for (const auto *Field : fields())
1337 if (const CXXRecordDecl *RD =
1338 Field->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl())
1339 if (RD->isAnyDestructorNoReturn())
1342 // All destructors are not noreturn.
1346 void CXXRecordDecl::completeDefinition() {
1347 completeDefinition(nullptr);
1350 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1351 RecordDecl::completeDefinition();
1353 // If the class may be abstract (but hasn't been marked as such), check for
1354 // any pure final overriders.
1355 if (mayBeAbstract()) {
1356 CXXFinalOverriderMap MyFinalOverriders;
1357 if (!FinalOverriders) {
1358 getFinalOverriders(MyFinalOverriders);
1359 FinalOverriders = &MyFinalOverriders;
1363 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1364 MEnd = FinalOverriders->end();
1365 M != MEnd && !Done; ++M) {
1366 for (OverridingMethods::iterator SO = M->second.begin(),
1367 SOEnd = M->second.end();
1368 SO != SOEnd && !Done; ++SO) {
1369 assert(SO->second.size() > 0 &&
1370 "All virtual functions have overridding virtual functions");
1372 // C++ [class.abstract]p4:
1373 // A class is abstract if it contains or inherits at least one
1374 // pure virtual function for which the final overrider is pure
1376 if (SO->second.front().Method->isPure()) {
1377 data().Abstract = true;
1385 // Set access bits correctly on the directly-declared conversions.
1386 for (conversion_iterator I = conversion_begin(), E = conversion_end();
1388 I.setAccess((*I)->getAccess());
1391 bool CXXRecordDecl::mayBeAbstract() const {
1392 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1393 isDependentContext())
1396 for (const auto &B : bases()) {
1397 CXXRecordDecl *BaseDecl
1398 = cast<CXXRecordDecl>(B.getType()->getAs<RecordType>()->getDecl());
1399 if (BaseDecl->isAbstract())
1406 void CXXMethodDecl::anchor() { }
1408 bool CXXMethodDecl::isStatic() const {
1409 const CXXMethodDecl *MD = getCanonicalDecl();
1411 if (MD->getStorageClass() == SC_Static)
1414 OverloadedOperatorKind OOK = getDeclName().getCXXOverloadedOperator();
1415 return isStaticOverloadedOperator(OOK);
1418 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1419 const CXXMethodDecl *BaseMD) {
1420 for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
1421 E = DerivedMD->end_overridden_methods(); I != E; ++I) {
1422 const CXXMethodDecl *MD = *I;
1423 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1425 if (recursivelyOverrides(MD, BaseMD))
1432 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1434 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1437 // Lookup doesn't work for destructors, so handle them separately.
1438 if (isa<CXXDestructorDecl>(this)) {
1439 CXXMethodDecl *MD = RD->getDestructor();
1441 if (recursivelyOverrides(MD, this))
1443 if (MayBeBase && recursivelyOverrides(this, MD))
1449 for (auto *ND : RD->lookup(getDeclName())) {
1450 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND);
1453 if (recursivelyOverrides(MD, this))
1455 if (MayBeBase && recursivelyOverrides(this, MD))
1459 for (const auto &I : RD->bases()) {
1460 const RecordType *RT = I.getType()->getAs<RecordType>();
1463 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1464 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1473 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1474 SourceLocation StartLoc,
1475 const DeclarationNameInfo &NameInfo,
1476 QualType T, TypeSourceInfo *TInfo,
1477 StorageClass SC, bool isInline,
1478 bool isConstexpr, SourceLocation EndLocation) {
1479 return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
1480 T, TInfo, SC, isInline, isConstexpr,
1484 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1485 return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
1486 DeclarationNameInfo(), QualType(), nullptr,
1487 SC_None, false, false, SourceLocation());
1490 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1491 if (getOverloadedOperator() != OO_Delete &&
1492 getOverloadedOperator() != OO_Array_Delete)
1495 // C++ [basic.stc.dynamic.deallocation]p2:
1496 // A template instance is never a usual deallocation function,
1497 // regardless of its signature.
1498 if (getPrimaryTemplate())
1501 // C++ [basic.stc.dynamic.deallocation]p2:
1502 // If a class T has a member deallocation function named operator delete
1503 // with exactly one parameter, then that function is a usual (non-placement)
1504 // deallocation function. [...]
1505 if (getNumParams() == 1)
1508 // C++ [basic.stc.dynamic.deallocation]p2:
1509 // [...] If class T does not declare such an operator delete but does
1510 // declare a member deallocation function named operator delete with
1511 // exactly two parameters, the second of which has type std::size_t (18.1),
1512 // then this function is a usual deallocation function.
1513 ASTContext &Context = getASTContext();
1514 if (getNumParams() != 2 ||
1515 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1516 Context.getSizeType()))
1519 // This function is a usual deallocation function if there are no
1520 // single-parameter deallocation functions of the same kind.
1521 DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName());
1522 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
1524 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
1525 if (FD->getNumParams() == 1)
1532 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1533 // C++0x [class.copy]p17:
1534 // A user-declared copy assignment operator X::operator= is a non-static
1535 // non-template member function of class X with exactly one parameter of
1536 // type X, X&, const X&, volatile X& or const volatile X&.
1537 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1538 /*non-static*/ isStatic() ||
1539 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1540 getNumParams() != 1)
1543 QualType ParamType = getParamDecl(0)->getType();
1544 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1545 ParamType = Ref->getPointeeType();
1547 ASTContext &Context = getASTContext();
1549 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1550 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1553 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1554 // C++0x [class.copy]p19:
1555 // A user-declared move assignment operator X::operator= is a non-static
1556 // non-template member function of class X with exactly one parameter of type
1557 // X&&, const X&&, volatile X&&, or const volatile X&&.
1558 if (getOverloadedOperator() != OO_Equal || isStatic() ||
1559 getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1560 getNumParams() != 1)
1563 QualType ParamType = getParamDecl(0)->getType();
1564 if (!isa<RValueReferenceType>(ParamType))
1566 ParamType = ParamType->getPointeeType();
1568 ASTContext &Context = getASTContext();
1570 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1571 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1574 void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
1575 assert(MD->isCanonicalDecl() && "Method is not canonical!");
1576 assert(!MD->getParent()->isDependentContext() &&
1577 "Can't add an overridden method to a class template!");
1578 assert(MD->isVirtual() && "Method is not virtual!");
1580 getASTContext().addOverriddenMethod(this, MD);
1583 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
1584 if (isa<CXXConstructorDecl>(this)) return nullptr;
1585 return getASTContext().overridden_methods_begin(this);
1588 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
1589 if (isa<CXXConstructorDecl>(this)) return nullptr;
1590 return getASTContext().overridden_methods_end(this);
1593 unsigned CXXMethodDecl::size_overridden_methods() const {
1594 if (isa<CXXConstructorDecl>(this)) return 0;
1595 return getASTContext().overridden_methods_size(this);
1598 QualType CXXMethodDecl::getThisType(ASTContext &C) const {
1599 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1600 // If the member function is declared const, the type of this is const X*,
1601 // if the member function is declared volatile, the type of this is
1602 // volatile X*, and if the member function is declared const volatile,
1603 // the type of this is const volatile X*.
1605 assert(isInstance() && "No 'this' for static methods!");
1607 QualType ClassTy = C.getTypeDeclType(getParent());
1608 ClassTy = C.getQualifiedType(ClassTy,
1609 Qualifiers::fromCVRMask(getTypeQualifiers()));
1610 return C.getPointerType(ClassTy);
1613 bool CXXMethodDecl::hasInlineBody() const {
1614 // If this function is a template instantiation, look at the template from
1615 // which it was instantiated.
1616 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1620 const FunctionDecl *fn;
1621 return CheckFn->hasBody(fn) && !fn->isOutOfLine();
1624 bool CXXMethodDecl::isLambdaStaticInvoker() const {
1625 const CXXRecordDecl *P = getParent();
1626 if (P->isLambda()) {
1627 if (const CXXMethodDecl *StaticInvoker = P->getLambdaStaticInvoker()) {
1628 if (StaticInvoker == this) return true;
1629 if (P->isGenericLambda() && this->isFunctionTemplateSpecialization())
1630 return StaticInvoker == this->getPrimaryTemplate()->getTemplatedDecl();
1636 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1637 TypeSourceInfo *TInfo, bool IsVirtual,
1638 SourceLocation L, Expr *Init,
1640 SourceLocation EllipsisLoc)
1641 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
1642 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
1643 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1647 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1649 SourceLocation MemberLoc,
1650 SourceLocation L, Expr *Init,
1652 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1653 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1654 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1658 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1659 IndirectFieldDecl *Member,
1660 SourceLocation MemberLoc,
1661 SourceLocation L, Expr *Init,
1663 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1664 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1665 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1669 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1670 TypeSourceInfo *TInfo,
1671 SourceLocation L, Expr *Init,
1673 : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init),
1674 LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false),
1675 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1679 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1681 SourceLocation MemberLoc,
1682 SourceLocation L, Expr *Init,
1685 unsigned NumIndices)
1686 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1687 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1688 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices)
1690 std::uninitialized_copy(Indices, Indices + NumIndices,
1691 getTrailingObjects<VarDecl *>());
1694 CXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context,
1696 SourceLocation MemberLoc,
1697 SourceLocation L, Expr *Init,
1700 unsigned NumIndices) {
1701 void *Mem = Context.Allocate(totalSizeToAlloc<VarDecl *>(NumIndices),
1702 llvm::alignOf<CXXCtorInitializer>());
1703 return new (Mem) CXXCtorInitializer(Context, Member, MemberLoc, L, Init, R,
1704 Indices, NumIndices);
1707 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
1708 if (isBaseInitializer())
1709 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
1714 const Type *CXXCtorInitializer::getBaseClass() const {
1715 if (isBaseInitializer())
1716 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1721 SourceLocation CXXCtorInitializer::getSourceLocation() const {
1722 if (isInClassMemberInitializer())
1723 return getAnyMember()->getLocation();
1725 if (isAnyMemberInitializer())
1726 return getMemberLocation();
1728 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>())
1729 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
1731 return SourceLocation();
1734 SourceRange CXXCtorInitializer::getSourceRange() const {
1735 if (isInClassMemberInitializer()) {
1736 FieldDecl *D = getAnyMember();
1737 if (Expr *I = D->getInClassInitializer())
1738 return I->getSourceRange();
1739 return SourceRange();
1742 return SourceRange(getSourceLocation(), getRParenLoc());
1745 void CXXConstructorDecl::anchor() { }
1747 CXXConstructorDecl *
1748 CXXConstructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1749 return new (C, ID) CXXConstructorDecl(C, nullptr, SourceLocation(),
1750 DeclarationNameInfo(), QualType(),
1751 nullptr, false, false, false, false);
1754 CXXConstructorDecl *
1755 CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1756 SourceLocation StartLoc,
1757 const DeclarationNameInfo &NameInfo,
1758 QualType T, TypeSourceInfo *TInfo,
1759 bool isExplicit, bool isInline,
1760 bool isImplicitlyDeclared, bool isConstexpr) {
1761 assert(NameInfo.getName().getNameKind()
1762 == DeclarationName::CXXConstructorName &&
1763 "Name must refer to a constructor");
1764 return new (C, RD) CXXConstructorDecl(C, RD, StartLoc, NameInfo, T, TInfo,
1765 isExplicit, isInline,
1766 isImplicitlyDeclared, isConstexpr);
1769 CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
1770 return CtorInitializers.get(getASTContext().getExternalSource());
1773 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
1774 assert(isDelegatingConstructor() && "Not a delegating constructor!");
1775 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
1776 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E))
1777 return Construct->getConstructor();
1782 bool CXXConstructorDecl::isDefaultConstructor() const {
1783 // C++ [class.ctor]p5:
1784 // A default constructor for a class X is a constructor of class
1785 // X that can be called without an argument.
1786 return (getNumParams() == 0) ||
1787 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
1791 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
1792 return isCopyOrMoveConstructor(TypeQuals) &&
1793 getParamDecl(0)->getType()->isLValueReferenceType();
1796 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
1797 return isCopyOrMoveConstructor(TypeQuals) &&
1798 getParamDecl(0)->getType()->isRValueReferenceType();
1801 /// \brief Determine whether this is a copy or move constructor.
1802 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
1803 // C++ [class.copy]p2:
1804 // A non-template constructor for class X is a copy constructor
1805 // if its first parameter is of type X&, const X&, volatile X& or
1806 // const volatile X&, and either there are no other parameters
1807 // or else all other parameters have default arguments (8.3.6).
1808 // C++0x [class.copy]p3:
1809 // A non-template constructor for class X is a move constructor if its
1810 // first parameter is of type X&&, const X&&, volatile X&&, or
1811 // const volatile X&&, and either there are no other parameters or else
1812 // all other parameters have default arguments.
1813 if ((getNumParams() < 1) ||
1814 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1815 (getPrimaryTemplate() != nullptr) ||
1816 (getDescribedFunctionTemplate() != nullptr))
1819 const ParmVarDecl *Param = getParamDecl(0);
1821 // Do we have a reference type?
1822 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
1826 // Is it a reference to our class type?
1827 ASTContext &Context = getASTContext();
1829 CanQualType PointeeType
1830 = Context.getCanonicalType(ParamRefType->getPointeeType());
1832 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1833 if (PointeeType.getUnqualifiedType() != ClassTy)
1836 // FIXME: other qualifiers?
1838 // We have a copy or move constructor.
1839 TypeQuals = PointeeType.getCVRQualifiers();
1843 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
1844 // C++ [class.conv.ctor]p1:
1845 // A constructor declared without the function-specifier explicit
1846 // that can be called with a single parameter specifies a
1847 // conversion from the type of its first parameter to the type of
1848 // its class. Such a constructor is called a converting
1850 if (isExplicit() && !AllowExplicit)
1853 return (getNumParams() == 0 &&
1854 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
1855 (getNumParams() == 1) ||
1856 (getNumParams() > 1 &&
1857 (getParamDecl(1)->hasDefaultArg() ||
1858 getParamDecl(1)->isParameterPack()));
1861 bool CXXConstructorDecl::isSpecializationCopyingObject() const {
1862 if ((getNumParams() < 1) ||
1863 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1864 (getDescribedFunctionTemplate() != nullptr))
1867 const ParmVarDecl *Param = getParamDecl(0);
1869 ASTContext &Context = getASTContext();
1870 CanQualType ParamType = Context.getCanonicalType(Param->getType());
1872 // Is it the same as our our class type?
1874 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1875 if (ParamType.getUnqualifiedType() != ClassTy)
1881 const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
1882 // Hack: we store the inherited constructor in the overridden method table
1883 method_iterator It = getASTContext().overridden_methods_begin(this);
1884 if (It == getASTContext().overridden_methods_end(this))
1887 return cast<CXXConstructorDecl>(*It);
1891 CXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl *BaseCtor){
1892 // Hack: we store the inherited constructor in the overridden method table
1893 assert(getASTContext().overridden_methods_size(this) == 0 &&
1894 "Base ctor already set.");
1895 getASTContext().addOverriddenMethod(this, BaseCtor);
1898 void CXXDestructorDecl::anchor() { }
1901 CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1903 CXXDestructorDecl(C, nullptr, SourceLocation(), DeclarationNameInfo(),
1904 QualType(), nullptr, false, false);
1908 CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1909 SourceLocation StartLoc,
1910 const DeclarationNameInfo &NameInfo,
1911 QualType T, TypeSourceInfo *TInfo,
1912 bool isInline, bool isImplicitlyDeclared) {
1913 assert(NameInfo.getName().getNameKind()
1914 == DeclarationName::CXXDestructorName &&
1915 "Name must refer to a destructor");
1916 return new (C, RD) CXXDestructorDecl(C, RD, StartLoc, NameInfo, T, TInfo,
1917 isInline, isImplicitlyDeclared);
1920 void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD) {
1921 auto *First = cast<CXXDestructorDecl>(getFirstDecl());
1922 if (OD && !First->OperatorDelete) {
1923 First->OperatorDelete = OD;
1924 if (auto *L = getASTMutationListener())
1925 L->ResolvedOperatorDelete(First, OD);
1929 void CXXConversionDecl::anchor() { }
1932 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1933 return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
1934 DeclarationNameInfo(), QualType(),
1935 nullptr, false, false, false,
1940 CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1941 SourceLocation StartLoc,
1942 const DeclarationNameInfo &NameInfo,
1943 QualType T, TypeSourceInfo *TInfo,
1944 bool isInline, bool isExplicit,
1945 bool isConstexpr, SourceLocation EndLocation) {
1946 assert(NameInfo.getName().getNameKind()
1947 == DeclarationName::CXXConversionFunctionName &&
1948 "Name must refer to a conversion function");
1949 return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
1950 isInline, isExplicit, isConstexpr,
1954 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1955 return isImplicit() && getParent()->isLambda() &&
1956 getConversionType()->isBlockPointerType();
1959 void LinkageSpecDecl::anchor() { }
1961 LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
1963 SourceLocation ExternLoc,
1964 SourceLocation LangLoc,
1967 return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
1970 LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C,
1972 return new (C, ID) LinkageSpecDecl(nullptr, SourceLocation(),
1973 SourceLocation(), lang_c, false);
1976 void UsingDirectiveDecl::anchor() { }
1978 UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
1980 SourceLocation NamespaceLoc,
1981 NestedNameSpecifierLoc QualifierLoc,
1982 SourceLocation IdentLoc,
1984 DeclContext *CommonAncestor) {
1985 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used))
1986 Used = NS->getOriginalNamespace();
1987 return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
1988 IdentLoc, Used, CommonAncestor);
1991 UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C,
1993 return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
1995 NestedNameSpecifierLoc(),
1996 SourceLocation(), nullptr, nullptr);
1999 NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
2000 if (NamespaceAliasDecl *NA =
2001 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
2002 return NA->getNamespace();
2003 return cast_or_null<NamespaceDecl>(NominatedNamespace);
2006 NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
2007 SourceLocation StartLoc, SourceLocation IdLoc,
2008 IdentifierInfo *Id, NamespaceDecl *PrevDecl)
2009 : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace),
2010 redeclarable_base(C), LocStart(StartLoc), RBraceLoc(),
2011 AnonOrFirstNamespaceAndInline(nullptr, Inline) {
2012 setPreviousDecl(PrevDecl);
2015 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
2018 NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
2019 bool Inline, SourceLocation StartLoc,
2020 SourceLocation IdLoc, IdentifierInfo *Id,
2021 NamespaceDecl *PrevDecl) {
2022 return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id,
2026 NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2027 return new (C, ID) NamespaceDecl(C, nullptr, false, SourceLocation(),
2028 SourceLocation(), nullptr, nullptr);
2031 NamespaceDecl *NamespaceDecl::getOriginalNamespace() {
2035 return AnonOrFirstNamespaceAndInline.getPointer();
2038 const NamespaceDecl *NamespaceDecl::getOriginalNamespace() const {
2042 return AnonOrFirstNamespaceAndInline.getPointer();
2045 bool NamespaceDecl::isOriginalNamespace() const { return isFirstDecl(); }
2047 NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() {
2048 return getNextRedeclaration();
2050 NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() {
2051 return getPreviousDecl();
2053 NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() {
2054 return getMostRecentDecl();
2057 void NamespaceAliasDecl::anchor() { }
2059 NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() {
2060 return getNextRedeclaration();
2062 NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() {
2063 return getPreviousDecl();
2065 NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() {
2066 return getMostRecentDecl();
2069 NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
2070 SourceLocation UsingLoc,
2071 SourceLocation AliasLoc,
2072 IdentifierInfo *Alias,
2073 NestedNameSpecifierLoc QualifierLoc,
2074 SourceLocation IdentLoc,
2075 NamedDecl *Namespace) {
2076 // FIXME: Preserve the aliased namespace as written.
2077 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
2078 Namespace = NS->getOriginalNamespace();
2079 return new (C, DC) NamespaceAliasDecl(C, DC, UsingLoc, AliasLoc, Alias,
2080 QualifierLoc, IdentLoc, Namespace);
2083 NamespaceAliasDecl *
2084 NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2085 return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(),
2086 SourceLocation(), nullptr,
2087 NestedNameSpecifierLoc(),
2088 SourceLocation(), nullptr);
2091 void UsingShadowDecl::anchor() { }
2094 UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2095 return new (C, ID) UsingShadowDecl(C, nullptr, SourceLocation(),
2099 UsingDecl *UsingShadowDecl::getUsingDecl() const {
2100 const UsingShadowDecl *Shadow = this;
2101 while (const UsingShadowDecl *NextShadow =
2102 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
2103 Shadow = NextShadow;
2104 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
2107 void UsingDecl::anchor() { }
2109 void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
2110 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
2111 "declaration already in set");
2112 assert(S->getUsingDecl() == this);
2114 if (FirstUsingShadow.getPointer())
2115 S->UsingOrNextShadow = FirstUsingShadow.getPointer();
2116 FirstUsingShadow.setPointer(S);
2119 void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
2120 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
2121 "declaration not in set");
2122 assert(S->getUsingDecl() == this);
2124 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
2126 if (FirstUsingShadow.getPointer() == S) {
2127 FirstUsingShadow.setPointer(
2128 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
2129 S->UsingOrNextShadow = this;
2133 UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
2134 while (Prev->UsingOrNextShadow != S)
2135 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
2136 Prev->UsingOrNextShadow = S->UsingOrNextShadow;
2137 S->UsingOrNextShadow = this;
2140 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
2141 NestedNameSpecifierLoc QualifierLoc,
2142 const DeclarationNameInfo &NameInfo,
2144 return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
2147 UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2148 return new (C, ID) UsingDecl(nullptr, SourceLocation(),
2149 NestedNameSpecifierLoc(), DeclarationNameInfo(),
2153 SourceRange UsingDecl::getSourceRange() const {
2154 SourceLocation Begin = isAccessDeclaration()
2155 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2156 return SourceRange(Begin, getNameInfo().getEndLoc());
2159 void UnresolvedUsingValueDecl::anchor() { }
2161 UnresolvedUsingValueDecl *
2162 UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
2163 SourceLocation UsingLoc,
2164 NestedNameSpecifierLoc QualifierLoc,
2165 const DeclarationNameInfo &NameInfo) {
2166 return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
2167 QualifierLoc, NameInfo);
2170 UnresolvedUsingValueDecl *
2171 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2172 return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(),
2174 NestedNameSpecifierLoc(),
2175 DeclarationNameInfo());
2178 SourceRange UnresolvedUsingValueDecl::getSourceRange() const {
2179 SourceLocation Begin = isAccessDeclaration()
2180 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2181 return SourceRange(Begin, getNameInfo().getEndLoc());
2184 void UnresolvedUsingTypenameDecl::anchor() { }
2186 UnresolvedUsingTypenameDecl *
2187 UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
2188 SourceLocation UsingLoc,
2189 SourceLocation TypenameLoc,
2190 NestedNameSpecifierLoc QualifierLoc,
2191 SourceLocation TargetNameLoc,
2192 DeclarationName TargetName) {
2193 return new (C, DC) UnresolvedUsingTypenameDecl(
2194 DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc,
2195 TargetName.getAsIdentifierInfo());
2198 UnresolvedUsingTypenameDecl *
2199 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2200 return new (C, ID) UnresolvedUsingTypenameDecl(
2201 nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
2202 SourceLocation(), nullptr);
2205 void StaticAssertDecl::anchor() { }
2207 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
2208 SourceLocation StaticAssertLoc,
2210 StringLiteral *Message,
2211 SourceLocation RParenLoc,
2213 return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2217 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
2219 return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
2220 nullptr, SourceLocation(), false);
2223 MSPropertyDecl *MSPropertyDecl::Create(ASTContext &C, DeclContext *DC,
2224 SourceLocation L, DeclarationName N,
2225 QualType T, TypeSourceInfo *TInfo,
2226 SourceLocation StartL,
2227 IdentifierInfo *Getter,
2228 IdentifierInfo *Setter) {
2229 return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter);
2232 MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C,
2234 return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
2235 DeclarationName(), QualType(), nullptr,
2236 SourceLocation(), nullptr, nullptr);
2239 static const char *getAccessName(AccessSpecifier AS) {
2242 llvm_unreachable("Invalid access specifier!");
2250 llvm_unreachable("Invalid access specifier!");
2253 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2254 AccessSpecifier AS) {
2255 return DB << getAccessName(AS);
2258 const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2259 AccessSpecifier AS) {
2260 return DB << getAccessName(AS);