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 /// Callback function for CXXRecordDecl::forallBases that acknowledges
389 /// that it saw a base class.
390 static bool SawBase(const CXXRecordDecl
*, void *) {
394 bool CXXRecordDecl::hasAnyDependentBases() const {
395 if (!isDependentContext())
398 return !forallBases(SawBase
, nullptr);
401 bool CXXRecordDecl::isTriviallyCopyable() const {
403 // A trivially copyable class is a class that:
404 // -- has no non-trivial copy constructors,
405 if (hasNonTrivialCopyConstructor()) return false;
406 // -- has no non-trivial move constructors,
407 if (hasNonTrivialMoveConstructor()) return false;
408 // -- has no non-trivial copy assignment operators,
409 if (hasNonTrivialCopyAssignment()) return false;
410 // -- has no non-trivial move assignment operators, and
411 if (hasNonTrivialMoveAssignment()) return false;
412 // -- has a trivial destructor.
413 if (!hasTrivialDestructor()) return false;
418 void CXXRecordDecl::markedVirtualFunctionPure() {
419 // C++ [class.abstract]p2:
420 // A class is abstract if it has at least one pure virtual function.
421 data().Abstract
= true;
424 void CXXRecordDecl::addedMember(Decl
*D
) {
425 if (!D
->isImplicit() &&
426 !isa
<FieldDecl
>(D
) &&
427 !isa
<IndirectFieldDecl
>(D
) &&
428 (!isa
<TagDecl
>(D
) || cast
<TagDecl
>(D
)->getTagKind() == TTK_Class
||
429 cast
<TagDecl
>(D
)->getTagKind() == TTK_Interface
))
430 data().HasOnlyCMembers
= false;
432 // Ignore friends and invalid declarations.
433 if (D
->getFriendObjectKind() || D
->isInvalidDecl())
436 FunctionTemplateDecl
*FunTmpl
= dyn_cast
<FunctionTemplateDecl
>(D
);
438 D
= FunTmpl
->getTemplatedDecl();
440 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(D
)) {
441 if (Method
->isVirtual()) {
442 // C++ [dcl.init.aggr]p1:
443 // An aggregate is an array or a class with [...] no virtual functions.
444 data().Aggregate
= false;
447 // A POD-struct is an aggregate class...
448 data().PlainOldData
= false;
450 // Virtual functions make the class non-empty.
451 // FIXME: Standard ref?
452 data().Empty
= false;
454 // C++ [class.virtual]p1:
455 // A class that declares or inherits a virtual function is called a
456 // polymorphic class.
457 data().Polymorphic
= true;
459 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
460 // A [default constructor, copy/move constructor, or copy/move
461 // assignment operator for a class X] is trivial [...] if:
462 // -- class X has no virtual functions [...]
463 data().HasTrivialSpecialMembers
&= SMF_Destructor
;
466 // A standard-layout class is a class that: [...]
467 // -- has no virtual functions
468 data().IsStandardLayout
= false;
472 // Notify the listener if an implicit member was added after the definition
474 if (!isBeingDefined() && D
->isImplicit())
475 if (ASTMutationListener
*L
= getASTMutationListener())
476 L
->AddedCXXImplicitMember(data().Definition
, D
);
478 // The kind of special member this declaration is, if any.
481 // Handle constructors.
482 if (CXXConstructorDecl
*Constructor
= dyn_cast
<CXXConstructorDecl
>(D
)) {
483 if (!Constructor
->isImplicit()) {
484 // Note that we have a user-declared constructor.
485 data().UserDeclaredConstructor
= true;
488 // A POD-struct is an aggregate class [...]
489 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
490 // type is technically an aggregate in C++0x since it wouldn't be in 03.
491 data().PlainOldData
= false;
494 // Technically, "user-provided" is only defined for special member
495 // functions, but the intent of the standard is clearly that it should apply
497 bool UserProvided
= Constructor
->isUserProvided();
499 if (Constructor
->isDefaultConstructor()) {
500 SMKind
|= SMF_DefaultConstructor
;
503 data().UserProvidedDefaultConstructor
= true;
504 if (Constructor
->isConstexpr())
505 data().HasConstexprDefaultConstructor
= true;
510 if (Constructor
->isCopyConstructor(Quals
)) {
511 SMKind
|= SMF_CopyConstructor
;
513 if (Quals
& Qualifiers::Const
)
514 data().HasDeclaredCopyConstructorWithConstParam
= true;
515 } else if (Constructor
->isMoveConstructor())
516 SMKind
|= SMF_MoveConstructor
;
519 // Record if we see any constexpr constructors which are neither copy
520 // nor move constructors.
521 if (Constructor
->isConstexpr() && !Constructor
->isCopyOrMoveConstructor())
522 data().HasConstexprNonCopyMoveConstructor
= true;
524 // C++ [dcl.init.aggr]p1:
525 // An aggregate is an array or a class with no user-declared
526 // constructors [...].
527 // C++11 [dcl.init.aggr]p1:
528 // An aggregate is an array or a class with no user-provided
529 // constructors [...].
530 if (getASTContext().getLangOpts().CPlusPlus11
531 ? UserProvided
: !Constructor
->isImplicit())
532 data().Aggregate
= false;
535 // Handle destructors.
536 if (CXXDestructorDecl
*DD
= dyn_cast
<CXXDestructorDecl
>(D
)) {
537 SMKind
|= SMF_Destructor
;
539 if (DD
->isUserProvided())
540 data().HasIrrelevantDestructor
= false;
541 // If the destructor is explicitly defaulted and not trivial or not public
542 // or if the destructor is deleted, we clear HasIrrelevantDestructor in
543 // finishedDefaultedOrDeletedMember.
545 // C++11 [class.dtor]p5:
546 // A destructor is trivial if [...] the destructor is not virtual.
548 data().HasTrivialSpecialMembers
&= ~SMF_Destructor
;
551 // Handle member functions.
552 if (CXXMethodDecl
*Method
= dyn_cast
<CXXMethodDecl
>(D
)) {
553 if (Method
->isCopyAssignmentOperator()) {
554 SMKind
|= SMF_CopyAssignment
;
556 const ReferenceType
*ParamTy
=
557 Method
->getParamDecl(0)->getType()->getAs
<ReferenceType
>();
558 if (!ParamTy
|| ParamTy
->getPointeeType().isConstQualified())
559 data().HasDeclaredCopyAssignmentWithConstParam
= true;
562 if (Method
->isMoveAssignmentOperator())
563 SMKind
|= SMF_MoveAssignment
;
565 // Keep the list of conversion functions up-to-date.
566 if (CXXConversionDecl
*Conversion
= dyn_cast
<CXXConversionDecl
>(D
)) {
567 // FIXME: We use the 'unsafe' accessor for the access specifier here,
568 // because Sema may not have set it yet. That's really just a misdesign
569 // in Sema. However, LLDB *will* have set the access specifier correctly,
570 // and adds declarations after the class is technically completed,
571 // so completeDefinition()'s overriding of the access specifiers doesn't
573 AccessSpecifier AS
= Conversion
->getAccessUnsafe();
575 if (Conversion
->getPrimaryTemplate()) {
576 // We don't record specializations.
578 ASTContext
&Ctx
= getASTContext();
579 ASTUnresolvedSet
&Conversions
= data().Conversions
.get(Ctx
);
581 FunTmpl
? cast
<NamedDecl
>(FunTmpl
) : cast
<NamedDecl
>(Conversion
);
582 if (Primary
->getPreviousDecl())
583 Conversions
.replace(cast
<NamedDecl
>(Primary
->getPreviousDecl()),
586 Conversions
.addDecl(Ctx
, Primary
, AS
);
591 // If this is the first declaration of a special member, we no longer have
592 // an implicit trivial special member.
593 data().HasTrivialSpecialMembers
&=
594 data().DeclaredSpecialMembers
| ~SMKind
;
596 if (!Method
->isImplicit() && !Method
->isUserProvided()) {
597 // This method is user-declared but not user-provided. We can't work out
598 // whether it's trivial yet (not until we get to the end of the class).
599 // We'll handle this method in finishedDefaultedOrDeletedMember.
600 } else if (Method
->isTrivial())
601 data().HasTrivialSpecialMembers
|= SMKind
;
603 data().DeclaredNonTrivialSpecialMembers
|= SMKind
;
605 // Note when we have declared a declared special member, and suppress the
606 // implicit declaration of this special member.
607 data().DeclaredSpecialMembers
|= SMKind
;
609 if (!Method
->isImplicit()) {
610 data().UserDeclaredSpecialMembers
|= SMKind
;
613 // A POD-struct is an aggregate class that has [...] no user-defined
614 // copy assignment operator and no user-defined destructor.
616 // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
617 // aggregates could not have any constructors, clear it even for an
618 // explicitly defaulted or deleted constructor.
619 // type is technically an aggregate in C++0x since it wouldn't be in 03.
621 // Also, a user-declared move assignment operator makes a class non-POD.
622 // This is an extension in C++03.
623 data().PlainOldData
= false;
630 // Handle non-static data members.
631 if (FieldDecl
*Field
= dyn_cast
<FieldDecl
>(D
)) {
632 // C++ [class.bit]p2:
633 // A declaration for a bit-field that omits the identifier declares an
634 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
636 if (Field
->isUnnamedBitfield())
639 // C++ [dcl.init.aggr]p1:
640 // An aggregate is an array or a class (clause 9) with [...] no
641 // private or protected non-static data members (clause 11).
643 // A POD must be an aggregate.
644 if (D
->getAccess() == AS_private
|| D
->getAccess() == AS_protected
) {
645 data().Aggregate
= false;
646 data().PlainOldData
= false;
650 // A standard-layout class is a class that:
652 // -- has the same access control for all non-static data members,
653 switch (D
->getAccess()) {
654 case AS_private
: data().HasPrivateFields
= true; break;
655 case AS_protected
: data().HasProtectedFields
= true; break;
656 case AS_public
: data().HasPublicFields
= true; break;
657 case AS_none
: llvm_unreachable("Invalid access specifier");
659 if ((data().HasPrivateFields
+ data().HasProtectedFields
+
660 data().HasPublicFields
) > 1)
661 data().IsStandardLayout
= false;
663 // Keep track of the presence of mutable fields.
664 if (Field
->isMutable())
665 data().HasMutableFields
= true;
667 // C++11 [class.union]p8, DR1460:
668 // If X is a union, a non-static data member of X that is not an anonymous
669 // union is a variant member of X.
670 if (isUnion() && !Field
->isAnonymousStructOrUnion())
671 data().HasVariantMembers
= true;
674 // A POD struct is a class that is both a trivial class and a
675 // standard-layout class, and has no non-static data members of type
676 // non-POD struct, non-POD union (or array of such types).
678 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
679 // that does not explicitly have no lifetime makes the class a non-POD.
680 ASTContext
&Context
= getASTContext();
681 QualType T
= Context
.getBaseElementType(Field
->getType());
682 if (T
->isObjCRetainableType() || T
.isObjCGCStrong()) {
683 if (!Context
.getLangOpts().ObjCAutoRefCount
) {
684 setHasObjectMember(true);
685 } else if (T
.getObjCLifetime() != Qualifiers::OCL_ExplicitNone
) {
686 // Objective-C Automatic Reference Counting:
687 // If a class has a non-static data member of Objective-C pointer
688 // type (or array thereof), it is a non-POD type and its
689 // default constructor (if any), copy constructor, move constructor,
690 // copy assignment operator, move assignment operator, and destructor are
692 setHasObjectMember(true);
693 struct DefinitionData
&Data
= data();
694 Data
.PlainOldData
= false;
695 Data
.HasTrivialSpecialMembers
= 0;
696 Data
.HasIrrelevantDestructor
= false;
698 } else if (!T
.isCXX98PODType(Context
))
699 data().PlainOldData
= false;
701 if (T
->isReferenceType()) {
702 if (!Field
->hasInClassInitializer())
703 data().HasUninitializedReferenceMember
= true;
706 // A standard-layout class is a class that:
707 // -- has no non-static data members of type [...] reference,
708 data().IsStandardLayout
= false;
711 // Record if this field is the first non-literal or volatile field or base.
712 if (!T
->isLiteralType(Context
) || T
.isVolatileQualified())
713 data().HasNonLiteralTypeFieldsOrBases
= true;
715 if (Field
->hasInClassInitializer() ||
716 (Field
->isAnonymousStructOrUnion() &&
717 Field
->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
718 data().HasInClassInitializer
= true;
721 // A default constructor is trivial if [...] no non-static data member
722 // of its class has a brace-or-equal-initializer.
723 data().HasTrivialSpecialMembers
&= ~SMF_DefaultConstructor
;
725 // C++11 [dcl.init.aggr]p1:
726 // An aggregate is a [...] class with [...] no
727 // brace-or-equal-initializers for non-static data members.
729 // This rule was removed in C++1y.
730 if (!getASTContext().getLangOpts().CPlusPlus14
)
731 data().Aggregate
= false;
734 // A POD struct is [...] a trivial class.
735 data().PlainOldData
= false;
738 // C++11 [class.copy]p23:
739 // A defaulted copy/move assignment operator for a class X is defined
740 // as deleted if X has:
741 // -- a non-static data member of reference type
742 if (T
->isReferenceType())
743 data().DefaultedMoveAssignmentIsDeleted
= true;
745 if (const RecordType
*RecordTy
= T
->getAs
<RecordType
>()) {
746 CXXRecordDecl
* FieldRec
= cast
<CXXRecordDecl
>(RecordTy
->getDecl());
747 if (FieldRec
->getDefinition()) {
748 addedClassSubobject(FieldRec
);
750 // We may need to perform overload resolution to determine whether a
751 // field can be moved if it's const or volatile qualified.
752 if (T
.getCVRQualifiers() & (Qualifiers::Const
| Qualifiers::Volatile
)) {
753 data().NeedOverloadResolutionForMoveConstructor
= true;
754 data().NeedOverloadResolutionForMoveAssignment
= true;
757 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
758 // A defaulted [special member] for a class X is defined as
760 // -- X is a union-like class that has a variant member with a
761 // non-trivial [corresponding special member]
763 if (FieldRec
->hasNonTrivialMoveConstructor())
764 data().DefaultedMoveConstructorIsDeleted
= true;
765 if (FieldRec
->hasNonTrivialMoveAssignment())
766 data().DefaultedMoveAssignmentIsDeleted
= true;
767 if (FieldRec
->hasNonTrivialDestructor())
768 data().DefaultedDestructorIsDeleted
= true;
771 // C++0x [class.ctor]p5:
772 // A default constructor is trivial [...] if:
773 // -- for all the non-static data members of its class that are of
774 // class type (or array thereof), each such class has a trivial
775 // default constructor.
776 if (!FieldRec
->hasTrivialDefaultConstructor())
777 data().HasTrivialSpecialMembers
&= ~SMF_DefaultConstructor
;
779 // C++0x [class.copy]p13:
780 // A copy/move constructor for class X is trivial if [...]
782 // -- for each non-static data member of X that is of class type (or
783 // an array thereof), the constructor selected to copy/move that
784 // member is trivial;
785 if (!FieldRec
->hasTrivialCopyConstructor())
786 data().HasTrivialSpecialMembers
&= ~SMF_CopyConstructor
;
787 // If the field doesn't have a simple move constructor, we'll eagerly
788 // declare the move constructor for this class and we'll decide whether
789 // it's trivial then.
790 if (!FieldRec
->hasTrivialMoveConstructor())
791 data().HasTrivialSpecialMembers
&= ~SMF_MoveConstructor
;
793 // C++0x [class.copy]p27:
794 // A copy/move assignment operator for class X is trivial if [...]
796 // -- for each non-static data member of X that is of class type (or
797 // an array thereof), the assignment operator selected to
798 // copy/move that member is trivial;
799 if (!FieldRec
->hasTrivialCopyAssignment())
800 data().HasTrivialSpecialMembers
&= ~SMF_CopyAssignment
;
801 // If the field doesn't have a simple move assignment, we'll eagerly
802 // declare the move assignment for this class and we'll decide whether
803 // it's trivial then.
804 if (!FieldRec
->hasTrivialMoveAssignment())
805 data().HasTrivialSpecialMembers
&= ~SMF_MoveAssignment
;
807 if (!FieldRec
->hasTrivialDestructor())
808 data().HasTrivialSpecialMembers
&= ~SMF_Destructor
;
809 if (!FieldRec
->hasIrrelevantDestructor())
810 data().HasIrrelevantDestructor
= false;
811 if (FieldRec
->hasObjectMember())
812 setHasObjectMember(true);
813 if (FieldRec
->hasVolatileMember())
814 setHasVolatileMember(true);
817 // A standard-layout class is a class that:
818 // -- has no non-static data members of type non-standard-layout
819 // class (or array of such types) [...]
820 if (!FieldRec
->isStandardLayout())
821 data().IsStandardLayout
= false;
824 // A standard-layout class is a class that:
826 // -- has no base classes of the same type as the first non-static
828 // We don't want to expend bits in the state of the record decl
829 // tracking whether this is the first non-static data member so we
830 // cheat a bit and use some of the existing state: the empty bit.
831 // Virtual bases and virtual methods make a class non-empty, but they
832 // also make it non-standard-layout so we needn't check here.
833 // A non-empty base class may leave the class standard-layout, but not
834 // if we have arrived here, and have at least one non-static data
835 // member. If IsStandardLayout remains true, then the first non-static
836 // data member must come through here with Empty still true, and Empty
837 // will subsequently be set to false below.
838 if (data().IsStandardLayout
&& data().Empty
) {
839 for (const auto &BI
: bases()) {
840 if (Context
.hasSameUnqualifiedType(BI
.getType(), T
)) {
841 data().IsStandardLayout
= false;
847 // Keep track of the presence of mutable fields.
848 if (FieldRec
->hasMutableFields())
849 data().HasMutableFields
= true;
851 // C++11 [class.copy]p13:
852 // If the implicitly-defined constructor would satisfy the
853 // requirements of a constexpr constructor, the implicitly-defined
854 // constructor is constexpr.
855 // C++11 [dcl.constexpr]p4:
856 // -- every constructor involved in initializing non-static data
857 // members [...] shall be a constexpr constructor
858 if (!Field
->hasInClassInitializer() &&
859 !FieldRec
->hasConstexprDefaultConstructor() && !isUnion())
860 // The standard requires any in-class initializer to be a constant
861 // expression. We consider this to be a defect.
862 data().DefaultedDefaultConstructorIsConstexpr
= false;
864 // C++11 [class.copy]p8:
865 // The implicitly-declared copy constructor for a class X will have
866 // the form 'X::X(const X&)' if [...] for all the non-static data
867 // members of X that are of a class type M (or array thereof), each
868 // such class type has a copy constructor whose first parameter is
869 // of type 'const M&' or 'const volatile M&'.
870 if (!FieldRec
->hasCopyConstructorWithConstParam())
871 data().ImplicitCopyConstructorHasConstParam
= false;
873 // C++11 [class.copy]p18:
874 // The implicitly-declared copy assignment oeprator for a class X will
875 // have the form 'X& X::operator=(const X&)' if [...] for all the
876 // non-static data members of X that are of a class type M (or array
877 // thereof), each such class type has a copy assignment operator whose
878 // parameter is of type 'const M&', 'const volatile M&' or 'M'.
879 if (!FieldRec
->hasCopyAssignmentWithConstParam())
880 data().ImplicitCopyAssignmentHasConstParam
= false;
882 if (FieldRec
->hasUninitializedReferenceMember() &&
883 !Field
->hasInClassInitializer())
884 data().HasUninitializedReferenceMember
= true;
886 // C++11 [class.union]p8, DR1460:
887 // a non-static data member of an anonymous union that is a member of
888 // X is also a variant member of X.
889 if (FieldRec
->hasVariantMembers() &&
890 Field
->isAnonymousStructOrUnion())
891 data().HasVariantMembers
= true;
894 // Base element type of field is a non-class type.
895 if (!T
->isLiteralType(Context
) ||
896 (!Field
->hasInClassInitializer() && !isUnion()))
897 data().DefaultedDefaultConstructorIsConstexpr
= false;
899 // C++11 [class.copy]p23:
900 // A defaulted copy/move assignment operator for a class X is defined
901 // as deleted if X has:
902 // -- a non-static data member of const non-class type (or array
904 if (T
.isConstQualified())
905 data().DefaultedMoveAssignmentIsDeleted
= true;
909 // A standard-layout class is a class that:
911 // -- either has no non-static data members in the most derived
912 // class and at most one base class with non-static data members,
913 // or has no base classes with non-static data members, and
914 // At this point we know that we have a non-static data member, so the last
916 if (!data().HasNoNonEmptyBases
)
917 data().IsStandardLayout
= false;
919 // If this is not a zero-length bit-field, then the class is not empty.
921 if (!Field
->isBitField() ||
922 (!Field
->getBitWidth()->isTypeDependent() &&
923 !Field
->getBitWidth()->isValueDependent() &&
924 Field
->getBitWidthValue(Context
) != 0))
925 data().Empty
= false;
929 // Handle using declarations of conversion functions.
930 if (UsingShadowDecl
*Shadow
= dyn_cast
<UsingShadowDecl
>(D
)) {
931 if (Shadow
->getDeclName().getNameKind()
932 == DeclarationName::CXXConversionFunctionName
) {
933 ASTContext
&Ctx
= getASTContext();
934 data().Conversions
.get(Ctx
).addDecl(Ctx
, Shadow
, Shadow
->getAccess());
939 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl
*D
) {
940 assert(!D
->isImplicit() && !D
->isUserProvided());
942 // The kind of special member this declaration is, if any.
945 if (CXXConstructorDecl
*Constructor
= dyn_cast
<CXXConstructorDecl
>(D
)) {
946 if (Constructor
->isDefaultConstructor()) {
947 SMKind
|= SMF_DefaultConstructor
;
948 if (Constructor
->isConstexpr())
949 data().HasConstexprDefaultConstructor
= true;
951 if (Constructor
->isCopyConstructor())
952 SMKind
|= SMF_CopyConstructor
;
953 else if (Constructor
->isMoveConstructor())
954 SMKind
|= SMF_MoveConstructor
;
955 else if (Constructor
->isConstexpr())
956 // We may now know that the constructor is constexpr.
957 data().HasConstexprNonCopyMoveConstructor
= true;
958 } else if (isa
<CXXDestructorDecl
>(D
)) {
959 SMKind
|= SMF_Destructor
;
960 if (!D
->isTrivial() || D
->getAccess() != AS_public
|| D
->isDeleted())
961 data().HasIrrelevantDestructor
= false;
962 } else if (D
->isCopyAssignmentOperator())
963 SMKind
|= SMF_CopyAssignment
;
964 else if (D
->isMoveAssignmentOperator())
965 SMKind
|= SMF_MoveAssignment
;
967 // Update which trivial / non-trivial special members we have.
968 // addedMember will have skipped this step for this member.
970 data().HasTrivialSpecialMembers
|= SMKind
;
972 data().DeclaredNonTrivialSpecialMembers
|= SMKind
;
975 bool CXXRecordDecl::isCLike() const {
976 if (getTagKind() == TTK_Class
|| getTagKind() == TTK_Interface
||
977 !TemplateOrInstantiation
.isNull())
979 if (!hasDefinition())
982 return isPOD() && data().HasOnlyCMembers
;
985 bool CXXRecordDecl::isGenericLambda() const {
986 if (!isLambda()) return false;
987 return getLambdaData().IsGenericLambda
;
990 CXXMethodDecl
* CXXRecordDecl::getLambdaCallOperator() const {
991 if (!isLambda()) return nullptr;
992 DeclarationName Name
=
993 getASTContext().DeclarationNames
.getCXXOperatorName(OO_Call
);
994 DeclContext::lookup_const_result Calls
= lookup(Name
);
996 assert(!Calls
.empty() && "Missing lambda call operator!");
997 assert(Calls
.size() == 1 && "More than one lambda call operator!");
999 NamedDecl
*CallOp
= Calls
.front();
1000 if (FunctionTemplateDecl
*CallOpTmpl
=
1001 dyn_cast
<FunctionTemplateDecl
>(CallOp
))
1002 return cast
<CXXMethodDecl
>(CallOpTmpl
->getTemplatedDecl());
1004 return cast
<CXXMethodDecl
>(CallOp
);
1007 CXXMethodDecl
* CXXRecordDecl::getLambdaStaticInvoker() const {
1008 if (!isLambda()) return nullptr;
1009 DeclarationName Name
=
1010 &getASTContext().Idents
.get(getLambdaStaticInvokerName());
1011 DeclContext::lookup_const_result Invoker
= lookup(Name
);
1012 if (Invoker
.empty()) return nullptr;
1013 assert(Invoker
.size() == 1 && "More than one static invoker operator!");
1014 NamedDecl
*InvokerFun
= Invoker
.front();
1015 if (FunctionTemplateDecl
*InvokerTemplate
=
1016 dyn_cast
<FunctionTemplateDecl
>(InvokerFun
))
1017 return cast
<CXXMethodDecl
>(InvokerTemplate
->getTemplatedDecl());
1019 return cast
<CXXMethodDecl
>(InvokerFun
);
1022 void CXXRecordDecl::getCaptureFields(
1023 llvm::DenseMap
<const VarDecl
*, FieldDecl
*> &Captures
,
1024 FieldDecl
*&ThisCapture
) const {
1026 ThisCapture
= nullptr;
1028 LambdaDefinitionData
&Lambda
= getLambdaData();
1029 RecordDecl::field_iterator Field
= field_begin();
1030 for (const LambdaCapture
*C
= Lambda
.Captures
, *CEnd
= C
+ Lambda
.NumCaptures
;
1031 C
!= CEnd
; ++C
, ++Field
) {
1032 if (C
->capturesThis())
1033 ThisCapture
= *Field
;
1034 else if (C
->capturesVariable())
1035 Captures
[C
->getCapturedVar()] = *Field
;
1037 assert(Field
== field_end());
1040 TemplateParameterList
*
1041 CXXRecordDecl::getGenericLambdaTemplateParameterList() const {
1042 if (!isLambda()) return nullptr;
1043 CXXMethodDecl
*CallOp
= getLambdaCallOperator();
1044 if (FunctionTemplateDecl
*Tmpl
= CallOp
->getDescribedFunctionTemplate())
1045 return Tmpl
->getTemplateParameters();
1049 static CanQualType
GetConversionType(ASTContext
&Context
, NamedDecl
*Conv
) {
1051 cast
<CXXConversionDecl
>(Conv
->getUnderlyingDecl()->getAsFunction())
1052 ->getConversionType();
1053 return Context
.getCanonicalType(T
);
1056 /// Collect the visible conversions of a base class.
1058 /// \param Record a base class of the class we're considering
1059 /// \param InVirtual whether this base class is a virtual base (or a base
1060 /// of a virtual base)
1061 /// \param Access the access along the inheritance path to this base
1062 /// \param ParentHiddenTypes the conversions provided by the inheritors
1064 /// \param Output the set to which to add conversions from non-virtual bases
1065 /// \param VOutput the set to which to add conversions from virtual bases
1066 /// \param HiddenVBaseCs the set of conversions which were hidden in a
1067 /// virtual base along some inheritance path
1068 static void CollectVisibleConversions(ASTContext
&Context
,
1069 CXXRecordDecl
*Record
,
1071 AccessSpecifier Access
,
1072 const llvm::SmallPtrSet
<CanQualType
, 8> &ParentHiddenTypes
,
1073 ASTUnresolvedSet
&Output
,
1074 UnresolvedSetImpl
&VOutput
,
1075 llvm::SmallPtrSet
<NamedDecl
*, 8> &HiddenVBaseCs
) {
1076 // The set of types which have conversions in this class or its
1077 // subclasses. As an optimization, we don't copy the derived set
1078 // unless it might change.
1079 const llvm::SmallPtrSet
<CanQualType
, 8> *HiddenTypes
= &ParentHiddenTypes
;
1080 llvm::SmallPtrSet
<CanQualType
, 8> HiddenTypesBuffer
;
1082 // Collect the direct conversions and figure out which conversions
1083 // will be hidden in the subclasses.
1084 CXXRecordDecl::conversion_iterator ConvI
= Record
->conversion_begin();
1085 CXXRecordDecl::conversion_iterator ConvE
= Record
->conversion_end();
1086 if (ConvI
!= ConvE
) {
1087 HiddenTypesBuffer
= ParentHiddenTypes
;
1088 HiddenTypes
= &HiddenTypesBuffer
;
1090 for (CXXRecordDecl::conversion_iterator I
= ConvI
; I
!= ConvE
; ++I
) {
1091 CanQualType
ConvType(GetConversionType(Context
, I
.getDecl()));
1092 bool Hidden
= ParentHiddenTypes
.count(ConvType
);
1094 HiddenTypesBuffer
.insert(ConvType
);
1096 // If this conversion is hidden and we're in a virtual base,
1097 // remember that it's hidden along some inheritance path.
1098 if (Hidden
&& InVirtual
)
1099 HiddenVBaseCs
.insert(cast
<NamedDecl
>(I
.getDecl()->getCanonicalDecl()));
1101 // If this conversion isn't hidden, add it to the appropriate output.
1103 AccessSpecifier IAccess
1104 = CXXRecordDecl::MergeAccess(Access
, I
.getAccess());
1107 VOutput
.addDecl(I
.getDecl(), IAccess
);
1109 Output
.addDecl(Context
, I
.getDecl(), IAccess
);
1114 // Collect information recursively from any base classes.
1115 for (const auto &I
: Record
->bases()) {
1116 const RecordType
*RT
= I
.getType()->getAs
<RecordType
>();
1119 AccessSpecifier BaseAccess
1120 = CXXRecordDecl::MergeAccess(Access
, I
.getAccessSpecifier());
1121 bool BaseInVirtual
= InVirtual
|| I
.isVirtual();
1123 CXXRecordDecl
*Base
= cast
<CXXRecordDecl
>(RT
->getDecl());
1124 CollectVisibleConversions(Context
, Base
, BaseInVirtual
, BaseAccess
,
1125 *HiddenTypes
, Output
, VOutput
, HiddenVBaseCs
);
1129 /// Collect the visible conversions of a class.
1131 /// This would be extremely straightforward if it weren't for virtual
1132 /// bases. It might be worth special-casing that, really.
1133 static void CollectVisibleConversions(ASTContext
&Context
,
1134 CXXRecordDecl
*Record
,
1135 ASTUnresolvedSet
&Output
) {
1136 // The collection of all conversions in virtual bases that we've
1137 // found. These will be added to the output as long as they don't
1138 // appear in the hidden-conversions set.
1139 UnresolvedSet
<8> VBaseCs
;
1141 // The set of conversions in virtual bases that we've determined to
1143 llvm::SmallPtrSet
<NamedDecl
*, 8> HiddenVBaseCs
;
1145 // The set of types hidden by classes derived from this one.
1146 llvm::SmallPtrSet
<CanQualType
, 8> HiddenTypes
;
1148 // Go ahead and collect the direct conversions and add them to the
1149 // hidden-types set.
1150 CXXRecordDecl::conversion_iterator ConvI
= Record
->conversion_begin();
1151 CXXRecordDecl::conversion_iterator ConvE
= Record
->conversion_end();
1152 Output
.append(Context
, ConvI
, ConvE
);
1153 for (; ConvI
!= ConvE
; ++ConvI
)
1154 HiddenTypes
.insert(GetConversionType(Context
, ConvI
.getDecl()));
1156 // Recursively collect conversions from base classes.
1157 for (const auto &I
: Record
->bases()) {
1158 const RecordType
*RT
= I
.getType()->getAs
<RecordType
>();
1161 CollectVisibleConversions(Context
, cast
<CXXRecordDecl
>(RT
->getDecl()),
1162 I
.isVirtual(), I
.getAccessSpecifier(),
1163 HiddenTypes
, Output
, VBaseCs
, HiddenVBaseCs
);
1166 // Add any unhidden conversions provided by virtual bases.
1167 for (UnresolvedSetIterator I
= VBaseCs
.begin(), E
= VBaseCs
.end();
1169 if (!HiddenVBaseCs
.count(cast
<NamedDecl
>(I
.getDecl()->getCanonicalDecl())))
1170 Output
.addDecl(Context
, I
.getDecl(), I
.getAccess());
1174 /// getVisibleConversionFunctions - get all conversion functions visible
1175 /// in current class; including conversion function templates.
1176 std::pair
<CXXRecordDecl::conversion_iterator
,CXXRecordDecl::conversion_iterator
>
1177 CXXRecordDecl::getVisibleConversionFunctions() {
1178 ASTContext
&Ctx
= getASTContext();
1180 ASTUnresolvedSet
*Set
;
1181 if (bases_begin() == bases_end()) {
1182 // If root class, all conversions are visible.
1183 Set
= &data().Conversions
.get(Ctx
);
1185 Set
= &data().VisibleConversions
.get(Ctx
);
1186 // If visible conversion list is not evaluated, evaluate it.
1187 if (!data().ComputedVisibleConversions
) {
1188 CollectVisibleConversions(Ctx
, this, *Set
);
1189 data().ComputedVisibleConversions
= true;
1192 return std::make_pair(Set
->begin(), Set
->end());
1195 void CXXRecordDecl::removeConversion(const NamedDecl
*ConvDecl
) {
1196 // This operation is O(N) but extremely rare. Sema only uses it to
1197 // remove UsingShadowDecls in a class that were followed by a direct
1198 // declaration, e.g.:
1200 // using B::operator int;
1203 // This is uncommon by itself and even more uncommon in conjunction
1204 // with sufficiently large numbers of directly-declared conversions
1205 // that asymptotic behavior matters.
1207 ASTUnresolvedSet
&Convs
= data().Conversions
.get(getASTContext());
1208 for (unsigned I
= 0, E
= Convs
.size(); I
!= E
; ++I
) {
1209 if (Convs
[I
].getDecl() == ConvDecl
) {
1211 assert(std::find(Convs
.begin(), Convs
.end(), ConvDecl
) == Convs
.end()
1212 && "conversion was found multiple times in unresolved set");
1217 llvm_unreachable("conversion not found in set!");
1220 CXXRecordDecl
*CXXRecordDecl::getInstantiatedFromMemberClass() const {
1221 if (MemberSpecializationInfo
*MSInfo
= getMemberSpecializationInfo())
1222 return cast
<CXXRecordDecl
>(MSInfo
->getInstantiatedFrom());
1228 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl
*RD
,
1229 TemplateSpecializationKind TSK
) {
1230 assert(TemplateOrInstantiation
.isNull() &&
1231 "Previous template or instantiation?");
1232 assert(!isa
<ClassTemplatePartialSpecializationDecl
>(this));
1233 TemplateOrInstantiation
1234 = new (getASTContext()) MemberSpecializationInfo(RD
, TSK
);
1237 TemplateSpecializationKind
CXXRecordDecl::getTemplateSpecializationKind() const{
1238 if (const ClassTemplateSpecializationDecl
*Spec
1239 = dyn_cast
<ClassTemplateSpecializationDecl
>(this))
1240 return Spec
->getSpecializationKind();
1242 if (MemberSpecializationInfo
*MSInfo
= getMemberSpecializationInfo())
1243 return MSInfo
->getTemplateSpecializationKind();
1245 return TSK_Undeclared
;
1249 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK
) {
1250 if (ClassTemplateSpecializationDecl
*Spec
1251 = dyn_cast
<ClassTemplateSpecializationDecl
>(this)) {
1252 Spec
->setSpecializationKind(TSK
);
1256 if (MemberSpecializationInfo
*MSInfo
= getMemberSpecializationInfo()) {
1257 MSInfo
->setTemplateSpecializationKind(TSK
);
1261 llvm_unreachable("Not a class template or member class specialization");
1264 const CXXRecordDecl
*CXXRecordDecl::getTemplateInstantiationPattern() const {
1265 // If it's a class template specialization, find the template or partial
1266 // specialization from which it was instantiated.
1267 if (auto *TD
= dyn_cast
<ClassTemplateSpecializationDecl
>(this)) {
1268 auto From
= TD
->getInstantiatedFrom();
1269 if (auto *CTD
= From
.dyn_cast
<ClassTemplateDecl
*>()) {
1270 while (auto *NewCTD
= CTD
->getInstantiatedFromMemberTemplate()) {
1271 if (NewCTD
->isMemberSpecialization())
1275 return CTD
->getTemplatedDecl();
1278 From
.dyn_cast
<ClassTemplatePartialSpecializationDecl
*>()) {
1279 while (auto *NewCTPSD
= CTPSD
->getInstantiatedFromMember()) {
1280 if (NewCTPSD
->isMemberSpecialization())
1288 if (MemberSpecializationInfo
*MSInfo
= getMemberSpecializationInfo()) {
1289 if (isTemplateInstantiation(MSInfo
->getTemplateSpecializationKind())) {
1290 const CXXRecordDecl
*RD
= this;
1291 while (auto *NewRD
= RD
->getInstantiatedFromMemberClass())
1297 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) &&
1298 "couldn't find pattern for class template instantiation");
1302 CXXDestructorDecl
*CXXRecordDecl::getDestructor() const {
1303 ASTContext
&Context
= getASTContext();
1304 QualType ClassType
= Context
.getTypeDeclType(this);
1306 DeclarationName Name
1307 = Context
.DeclarationNames
.getCXXDestructorName(
1308 Context
.getCanonicalType(ClassType
));
1310 DeclContext::lookup_const_result R
= lookup(Name
);
1314 CXXDestructorDecl
*Dtor
= cast
<CXXDestructorDecl
>(R
.front());
1318 void CXXRecordDecl::completeDefinition() {
1319 completeDefinition(nullptr);
1322 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap
*FinalOverriders
) {
1323 RecordDecl::completeDefinition();
1325 // If the class may be abstract (but hasn't been marked as such), check for
1326 // any pure final overriders.
1327 if (mayBeAbstract()) {
1328 CXXFinalOverriderMap MyFinalOverriders
;
1329 if (!FinalOverriders
) {
1330 getFinalOverriders(MyFinalOverriders
);
1331 FinalOverriders
= &MyFinalOverriders
;
1335 for (CXXFinalOverriderMap::iterator M
= FinalOverriders
->begin(),
1336 MEnd
= FinalOverriders
->end();
1337 M
!= MEnd
&& !Done
; ++M
) {
1338 for (OverridingMethods::iterator SO
= M
->second
.begin(),
1339 SOEnd
= M
->second
.end();
1340 SO
!= SOEnd
&& !Done
; ++SO
) {
1341 assert(SO
->second
.size() > 0 &&
1342 "All virtual functions have overridding virtual functions");
1344 // C++ [class.abstract]p4:
1345 // A class is abstract if it contains or inherits at least one
1346 // pure virtual function for which the final overrider is pure
1348 if (SO
->second
.front().Method
->isPure()) {
1349 data().Abstract
= true;
1357 // Set access bits correctly on the directly-declared conversions.
1358 for (conversion_iterator I
= conversion_begin(), E
= conversion_end();
1360 I
.setAccess((*I
)->getAccess());
1363 bool CXXRecordDecl::mayBeAbstract() const {
1364 if (data().Abstract
|| isInvalidDecl() || !data().Polymorphic
||
1365 isDependentContext())
1368 for (const auto &B
: bases()) {
1369 CXXRecordDecl
*BaseDecl
1370 = cast
<CXXRecordDecl
>(B
.getType()->getAs
<RecordType
>()->getDecl());
1371 if (BaseDecl
->isAbstract())
1378 void CXXMethodDecl::anchor() { }
1380 bool CXXMethodDecl::isStatic() const {
1381 const CXXMethodDecl
*MD
= getCanonicalDecl();
1383 if (MD
->getStorageClass() == SC_Static
)
1386 OverloadedOperatorKind OOK
= getDeclName().getCXXOverloadedOperator();
1387 return isStaticOverloadedOperator(OOK
);
1390 static bool recursivelyOverrides(const CXXMethodDecl
*DerivedMD
,
1391 const CXXMethodDecl
*BaseMD
) {
1392 for (CXXMethodDecl::method_iterator I
= DerivedMD
->begin_overridden_methods(),
1393 E
= DerivedMD
->end_overridden_methods(); I
!= E
; ++I
) {
1394 const CXXMethodDecl
*MD
= *I
;
1395 if (MD
->getCanonicalDecl() == BaseMD
->getCanonicalDecl())
1397 if (recursivelyOverrides(MD
, BaseMD
))
1404 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl
*RD
,
1406 if (this->getParent()->getCanonicalDecl() == RD
->getCanonicalDecl())
1409 // Lookup doesn't work for destructors, so handle them separately.
1410 if (isa
<CXXDestructorDecl
>(this)) {
1411 CXXMethodDecl
*MD
= RD
->getDestructor();
1413 if (recursivelyOverrides(MD
, this))
1415 if (MayBeBase
&& recursivelyOverrides(this, MD
))
1421 lookup_const_result Candidates
= RD
->lookup(getDeclName());
1422 for (NamedDecl
* const * I
= Candidates
.begin(); I
!= Candidates
.end(); ++I
) {
1423 CXXMethodDecl
*MD
= dyn_cast
<CXXMethodDecl
>(*I
);
1426 if (recursivelyOverrides(MD
, this))
1428 if (MayBeBase
&& recursivelyOverrides(this, MD
))
1432 for (const auto &I
: RD
->bases()) {
1433 const RecordType
*RT
= I
.getType()->getAs
<RecordType
>();
1436 const CXXRecordDecl
*Base
= cast
<CXXRecordDecl
>(RT
->getDecl());
1437 CXXMethodDecl
*T
= this->getCorrespondingMethodInClass(Base
);
1446 CXXMethodDecl::Create(ASTContext
&C
, CXXRecordDecl
*RD
,
1447 SourceLocation StartLoc
,
1448 const DeclarationNameInfo
&NameInfo
,
1449 QualType T
, TypeSourceInfo
*TInfo
,
1450 StorageClass SC
, bool isInline
,
1451 bool isConstexpr
, SourceLocation EndLocation
) {
1452 return new (C
, RD
) CXXMethodDecl(CXXMethod
, C
, RD
, StartLoc
, NameInfo
,
1453 T
, TInfo
, SC
, isInline
, isConstexpr
,
1457 CXXMethodDecl
*CXXMethodDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
1458 return new (C
, ID
) CXXMethodDecl(CXXMethod
, C
, nullptr, SourceLocation(),
1459 DeclarationNameInfo(), QualType(), nullptr,
1460 SC_None
, false, false, SourceLocation());
1463 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1464 if (getOverloadedOperator() != OO_Delete
&&
1465 getOverloadedOperator() != OO_Array_Delete
)
1468 // C++ [basic.stc.dynamic.deallocation]p2:
1469 // A template instance is never a usual deallocation function,
1470 // regardless of its signature.
1471 if (getPrimaryTemplate())
1474 // C++ [basic.stc.dynamic.deallocation]p2:
1475 // If a class T has a member deallocation function named operator delete
1476 // with exactly one parameter, then that function is a usual (non-placement)
1477 // deallocation function. [...]
1478 if (getNumParams() == 1)
1481 // C++ [basic.stc.dynamic.deallocation]p2:
1482 // [...] If class T does not declare such an operator delete but does
1483 // declare a member deallocation function named operator delete with
1484 // exactly two parameters, the second of which has type std::size_t (18.1),
1485 // then this function is a usual deallocation function.
1486 ASTContext
&Context
= getASTContext();
1487 if (getNumParams() != 2 ||
1488 !Context
.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1489 Context
.getSizeType()))
1492 // This function is a usual deallocation function if there are no
1493 // single-parameter deallocation functions of the same kind.
1494 DeclContext::lookup_const_result R
= getDeclContext()->lookup(getDeclName());
1495 for (DeclContext::lookup_const_result::iterator I
= R
.begin(), E
= R
.end();
1497 if (const FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(*I
))
1498 if (FD
->getNumParams() == 1)
1505 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1506 // C++0x [class.copy]p17:
1507 // A user-declared copy assignment operator X::operator= is a non-static
1508 // non-template member function of class X with exactly one parameter of
1509 // type X, X&, const X&, volatile X& or const volatile X&.
1510 if (/*operator=*/getOverloadedOperator() != OO_Equal
||
1511 /*non-static*/ isStatic() ||
1512 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1513 getNumParams() != 1)
1516 QualType ParamType
= getParamDecl(0)->getType();
1517 if (const LValueReferenceType
*Ref
= ParamType
->getAs
<LValueReferenceType
>())
1518 ParamType
= Ref
->getPointeeType();
1520 ASTContext
&Context
= getASTContext();
1522 = Context
.getCanonicalType(Context
.getTypeDeclType(getParent()));
1523 return Context
.hasSameUnqualifiedType(ClassType
, ParamType
);
1526 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1527 // C++0x [class.copy]p19:
1528 // A user-declared move assignment operator X::operator= is a non-static
1529 // non-template member function of class X with exactly one parameter of type
1530 // X&&, const X&&, volatile X&&, or const volatile X&&.
1531 if (getOverloadedOperator() != OO_Equal
|| isStatic() ||
1532 getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1533 getNumParams() != 1)
1536 QualType ParamType
= getParamDecl(0)->getType();
1537 if (!isa
<RValueReferenceType
>(ParamType
))
1539 ParamType
= ParamType
->getPointeeType();
1541 ASTContext
&Context
= getASTContext();
1543 = Context
.getCanonicalType(Context
.getTypeDeclType(getParent()));
1544 return Context
.hasSameUnqualifiedType(ClassType
, ParamType
);
1547 void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl
*MD
) {
1548 assert(MD
->isCanonicalDecl() && "Method is not canonical!");
1549 assert(!MD
->getParent()->isDependentContext() &&
1550 "Can't add an overridden method to a class template!");
1551 assert(MD
->isVirtual() && "Method is not virtual!");
1553 getASTContext().addOverriddenMethod(this, MD
);
1556 CXXMethodDecl::method_iterator
CXXMethodDecl::begin_overridden_methods() const {
1557 if (isa
<CXXConstructorDecl
>(this)) return nullptr;
1558 return getASTContext().overridden_methods_begin(this);
1561 CXXMethodDecl::method_iterator
CXXMethodDecl::end_overridden_methods() const {
1562 if (isa
<CXXConstructorDecl
>(this)) return nullptr;
1563 return getASTContext().overridden_methods_end(this);
1566 unsigned CXXMethodDecl::size_overridden_methods() const {
1567 if (isa
<CXXConstructorDecl
>(this)) return 0;
1568 return getASTContext().overridden_methods_size(this);
1571 QualType
CXXMethodDecl::getThisType(ASTContext
&C
) const {
1572 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1573 // If the member function is declared const, the type of this is const X*,
1574 // if the member function is declared volatile, the type of this is
1575 // volatile X*, and if the member function is declared const volatile,
1576 // the type of this is const volatile X*.
1578 assert(isInstance() && "No 'this' for static methods!");
1580 QualType ClassTy
= C
.getTypeDeclType(getParent());
1581 ClassTy
= C
.getQualifiedType(ClassTy
,
1582 Qualifiers::fromCVRMask(getTypeQualifiers()));
1583 return C
.getPointerType(ClassTy
);
1586 bool CXXMethodDecl::hasInlineBody() const {
1587 // If this function is a template instantiation, look at the template from
1588 // which it was instantiated.
1589 const FunctionDecl
*CheckFn
= getTemplateInstantiationPattern();
1593 const FunctionDecl
*fn
;
1594 return CheckFn
->hasBody(fn
) && !fn
->isOutOfLine();
1597 bool CXXMethodDecl::isLambdaStaticInvoker() const {
1598 const CXXRecordDecl
*P
= getParent();
1599 if (P
->isLambda()) {
1600 if (const CXXMethodDecl
*StaticInvoker
= P
->getLambdaStaticInvoker()) {
1601 if (StaticInvoker
== this) return true;
1602 if (P
->isGenericLambda() && this->isFunctionTemplateSpecialization())
1603 return StaticInvoker
== this->getPrimaryTemplate()->getTemplatedDecl();
1609 CXXCtorInitializer::CXXCtorInitializer(ASTContext
&Context
,
1610 TypeSourceInfo
*TInfo
, bool IsVirtual
,
1611 SourceLocation L
, Expr
*Init
,
1613 SourceLocation EllipsisLoc
)
1614 : Initializee(TInfo
), MemberOrEllipsisLocation(EllipsisLoc
), Init(Init
),
1615 LParenLoc(L
), RParenLoc(R
), IsDelegating(false), IsVirtual(IsVirtual
),
1616 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1620 CXXCtorInitializer::CXXCtorInitializer(ASTContext
&Context
,
1622 SourceLocation MemberLoc
,
1623 SourceLocation L
, Expr
*Init
,
1625 : Initializee(Member
), MemberOrEllipsisLocation(MemberLoc
), Init(Init
),
1626 LParenLoc(L
), RParenLoc(R
), IsDelegating(false), IsVirtual(false),
1627 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1631 CXXCtorInitializer::CXXCtorInitializer(ASTContext
&Context
,
1632 IndirectFieldDecl
*Member
,
1633 SourceLocation MemberLoc
,
1634 SourceLocation L
, Expr
*Init
,
1636 : Initializee(Member
), MemberOrEllipsisLocation(MemberLoc
), Init(Init
),
1637 LParenLoc(L
), RParenLoc(R
), IsDelegating(false), IsVirtual(false),
1638 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1642 CXXCtorInitializer::CXXCtorInitializer(ASTContext
&Context
,
1643 TypeSourceInfo
*TInfo
,
1644 SourceLocation L
, Expr
*Init
,
1646 : Initializee(TInfo
), MemberOrEllipsisLocation(), Init(Init
),
1647 LParenLoc(L
), RParenLoc(R
), IsDelegating(true), IsVirtual(false),
1648 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1652 CXXCtorInitializer::CXXCtorInitializer(ASTContext
&Context
,
1654 SourceLocation MemberLoc
,
1655 SourceLocation L
, Expr
*Init
,
1658 unsigned NumIndices
)
1659 : Initializee(Member
), MemberOrEllipsisLocation(MemberLoc
), Init(Init
),
1660 LParenLoc(L
), RParenLoc(R
), IsDelegating(false), IsVirtual(false),
1661 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices
)
1663 VarDecl
**MyIndices
= reinterpret_cast<VarDecl
**> (this + 1);
1664 memcpy(MyIndices
, Indices
, NumIndices
* sizeof(VarDecl
*));
1667 CXXCtorInitializer
*CXXCtorInitializer::Create(ASTContext
&Context
,
1669 SourceLocation MemberLoc
,
1670 SourceLocation L
, Expr
*Init
,
1673 unsigned NumIndices
) {
1674 void *Mem
= Context
.Allocate(sizeof(CXXCtorInitializer
) +
1675 sizeof(VarDecl
*) * NumIndices
,
1676 llvm::alignOf
<CXXCtorInitializer
>());
1677 return new (Mem
) CXXCtorInitializer(Context
, Member
, MemberLoc
, L
, Init
, R
,
1678 Indices
, NumIndices
);
1681 TypeLoc
CXXCtorInitializer::getBaseClassLoc() const {
1682 if (isBaseInitializer())
1683 return Initializee
.get
<TypeSourceInfo
*>()->getTypeLoc();
1688 const Type
*CXXCtorInitializer::getBaseClass() const {
1689 if (isBaseInitializer())
1690 return Initializee
.get
<TypeSourceInfo
*>()->getType().getTypePtr();
1695 SourceLocation
CXXCtorInitializer::getSourceLocation() const {
1696 if (isInClassMemberInitializer())
1697 return getAnyMember()->getLocation();
1699 if (isAnyMemberInitializer())
1700 return getMemberLocation();
1702 if (TypeSourceInfo
*TSInfo
= Initializee
.get
<TypeSourceInfo
*>())
1703 return TSInfo
->getTypeLoc().getLocalSourceRange().getBegin();
1705 return SourceLocation();
1708 SourceRange
CXXCtorInitializer::getSourceRange() const {
1709 if (isInClassMemberInitializer()) {
1710 FieldDecl
*D
= getAnyMember();
1711 if (Expr
*I
= D
->getInClassInitializer())
1712 return I
->getSourceRange();
1713 return SourceRange();
1716 return SourceRange(getSourceLocation(), getRParenLoc());
1719 void CXXConstructorDecl::anchor() { }
1721 CXXConstructorDecl
*
1722 CXXConstructorDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
1723 return new (C
, ID
) CXXConstructorDecl(C
, nullptr, SourceLocation(),
1724 DeclarationNameInfo(), QualType(),
1725 nullptr, false, false, false, false);
1728 CXXConstructorDecl
*
1729 CXXConstructorDecl::Create(ASTContext
&C
, CXXRecordDecl
*RD
,
1730 SourceLocation StartLoc
,
1731 const DeclarationNameInfo
&NameInfo
,
1732 QualType T
, TypeSourceInfo
*TInfo
,
1733 bool isExplicit
, bool isInline
,
1734 bool isImplicitlyDeclared
, bool isConstexpr
) {
1735 assert(NameInfo
.getName().getNameKind()
1736 == DeclarationName::CXXConstructorName
&&
1737 "Name must refer to a constructor");
1738 return new (C
, RD
) CXXConstructorDecl(C
, RD
, StartLoc
, NameInfo
, T
, TInfo
,
1739 isExplicit
, isInline
,
1740 isImplicitlyDeclared
, isConstexpr
);
1743 CXXConstructorDecl
*CXXConstructorDecl::getTargetConstructor() const {
1744 assert(isDelegatingConstructor() && "Not a delegating constructor!");
1745 Expr
*E
= (*init_begin())->getInit()->IgnoreImplicit();
1746 if (CXXConstructExpr
*Construct
= dyn_cast
<CXXConstructExpr
>(E
))
1747 return Construct
->getConstructor();
1752 bool CXXConstructorDecl::isDefaultConstructor() const {
1753 // C++ [class.ctor]p5:
1754 // A default constructor for a class X is a constructor of class
1755 // X that can be called without an argument.
1756 return (getNumParams() == 0) ||
1757 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
1761 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals
) const {
1762 return isCopyOrMoveConstructor(TypeQuals
) &&
1763 getParamDecl(0)->getType()->isLValueReferenceType();
1766 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals
) const {
1767 return isCopyOrMoveConstructor(TypeQuals
) &&
1768 getParamDecl(0)->getType()->isRValueReferenceType();
1771 /// \brief Determine whether this is a copy or move constructor.
1772 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals
) const {
1773 // C++ [class.copy]p2:
1774 // A non-template constructor for class X is a copy constructor
1775 // if its first parameter is of type X&, const X&, volatile X& or
1776 // const volatile X&, and either there are no other parameters
1777 // or else all other parameters have default arguments (8.3.6).
1778 // C++0x [class.copy]p3:
1779 // A non-template constructor for class X is a move constructor if its
1780 // first parameter is of type X&&, const X&&, volatile X&&, or
1781 // const volatile X&&, and either there are no other parameters or else
1782 // all other parameters have default arguments.
1783 if ((getNumParams() < 1) ||
1784 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1785 (getPrimaryTemplate() != nullptr) ||
1786 (getDescribedFunctionTemplate() != nullptr))
1789 const ParmVarDecl
*Param
= getParamDecl(0);
1791 // Do we have a reference type?
1792 const ReferenceType
*ParamRefType
= Param
->getType()->getAs
<ReferenceType
>();
1796 // Is it a reference to our class type?
1797 ASTContext
&Context
= getASTContext();
1799 CanQualType PointeeType
1800 = Context
.getCanonicalType(ParamRefType
->getPointeeType());
1802 = Context
.getCanonicalType(Context
.getTagDeclType(getParent()));
1803 if (PointeeType
.getUnqualifiedType() != ClassTy
)
1806 // FIXME: other qualifiers?
1808 // We have a copy or move constructor.
1809 TypeQuals
= PointeeType
.getCVRQualifiers();
1813 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit
) const {
1814 // C++ [class.conv.ctor]p1:
1815 // A constructor declared without the function-specifier explicit
1816 // that can be called with a single parameter specifies a
1817 // conversion from the type of its first parameter to the type of
1818 // its class. Such a constructor is called a converting
1820 if (isExplicit() && !AllowExplicit
)
1823 return (getNumParams() == 0 &&
1824 getType()->getAs
<FunctionProtoType
>()->isVariadic()) ||
1825 (getNumParams() == 1) ||
1826 (getNumParams() > 1 &&
1827 (getParamDecl(1)->hasDefaultArg() ||
1828 getParamDecl(1)->isParameterPack()));
1831 bool CXXConstructorDecl::isSpecializationCopyingObject() const {
1832 if ((getNumParams() < 1) ||
1833 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1834 (getDescribedFunctionTemplate() != nullptr))
1837 const ParmVarDecl
*Param
= getParamDecl(0);
1839 ASTContext
&Context
= getASTContext();
1840 CanQualType ParamType
= Context
.getCanonicalType(Param
->getType());
1842 // Is it the same as our our class type?
1844 = Context
.getCanonicalType(Context
.getTagDeclType(getParent()));
1845 if (ParamType
.getUnqualifiedType() != ClassTy
)
1851 const CXXConstructorDecl
*CXXConstructorDecl::getInheritedConstructor() const {
1852 // Hack: we store the inherited constructor in the overridden method table
1853 method_iterator It
= getASTContext().overridden_methods_begin(this);
1854 if (It
== getASTContext().overridden_methods_end(this))
1857 return cast
<CXXConstructorDecl
>(*It
);
1861 CXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl
*BaseCtor
){
1862 // Hack: we store the inherited constructor in the overridden method table
1863 assert(getASTContext().overridden_methods_size(this) == 0 &&
1864 "Base ctor already set.");
1865 getASTContext().addOverriddenMethod(this, BaseCtor
);
1868 void CXXDestructorDecl::anchor() { }
1871 CXXDestructorDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
1873 CXXDestructorDecl(C
, nullptr, SourceLocation(), DeclarationNameInfo(),
1874 QualType(), nullptr, false, false);
1878 CXXDestructorDecl::Create(ASTContext
&C
, CXXRecordDecl
*RD
,
1879 SourceLocation StartLoc
,
1880 const DeclarationNameInfo
&NameInfo
,
1881 QualType T
, TypeSourceInfo
*TInfo
,
1882 bool isInline
, bool isImplicitlyDeclared
) {
1883 assert(NameInfo
.getName().getNameKind()
1884 == DeclarationName::CXXDestructorName
&&
1885 "Name must refer to a destructor");
1886 return new (C
, RD
) CXXDestructorDecl(C
, RD
, StartLoc
, NameInfo
, T
, TInfo
,
1887 isInline
, isImplicitlyDeclared
);
1890 void CXXConversionDecl::anchor() { }
1893 CXXConversionDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
1894 return new (C
, ID
) CXXConversionDecl(C
, nullptr, SourceLocation(),
1895 DeclarationNameInfo(), QualType(),
1896 nullptr, false, false, false,
1901 CXXConversionDecl::Create(ASTContext
&C
, CXXRecordDecl
*RD
,
1902 SourceLocation StartLoc
,
1903 const DeclarationNameInfo
&NameInfo
,
1904 QualType T
, TypeSourceInfo
*TInfo
,
1905 bool isInline
, bool isExplicit
,
1906 bool isConstexpr
, SourceLocation EndLocation
) {
1907 assert(NameInfo
.getName().getNameKind()
1908 == DeclarationName::CXXConversionFunctionName
&&
1909 "Name must refer to a conversion function");
1910 return new (C
, RD
) CXXConversionDecl(C
, RD
, StartLoc
, NameInfo
, T
, TInfo
,
1911 isInline
, isExplicit
, isConstexpr
,
1915 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1916 return isImplicit() && getParent()->isLambda() &&
1917 getConversionType()->isBlockPointerType();
1920 void LinkageSpecDecl::anchor() { }
1922 LinkageSpecDecl
*LinkageSpecDecl::Create(ASTContext
&C
,
1924 SourceLocation ExternLoc
,
1925 SourceLocation LangLoc
,
1928 return new (C
, DC
) LinkageSpecDecl(DC
, ExternLoc
, LangLoc
, Lang
, HasBraces
);
1931 LinkageSpecDecl
*LinkageSpecDecl::CreateDeserialized(ASTContext
&C
,
1933 return new (C
, ID
) LinkageSpecDecl(nullptr, SourceLocation(),
1934 SourceLocation(), lang_c
, false);
1937 void UsingDirectiveDecl::anchor() { }
1939 UsingDirectiveDecl
*UsingDirectiveDecl::Create(ASTContext
&C
, DeclContext
*DC
,
1941 SourceLocation NamespaceLoc
,
1942 NestedNameSpecifierLoc QualifierLoc
,
1943 SourceLocation IdentLoc
,
1945 DeclContext
*CommonAncestor
) {
1946 if (NamespaceDecl
*NS
= dyn_cast_or_null
<NamespaceDecl
>(Used
))
1947 Used
= NS
->getOriginalNamespace();
1948 return new (C
, DC
) UsingDirectiveDecl(DC
, L
, NamespaceLoc
, QualifierLoc
,
1949 IdentLoc
, Used
, CommonAncestor
);
1952 UsingDirectiveDecl
*UsingDirectiveDecl::CreateDeserialized(ASTContext
&C
,
1954 return new (C
, ID
) UsingDirectiveDecl(nullptr, SourceLocation(),
1956 NestedNameSpecifierLoc(),
1957 SourceLocation(), nullptr, nullptr);
1960 NamespaceDecl
*UsingDirectiveDecl::getNominatedNamespace() {
1961 if (NamespaceAliasDecl
*NA
=
1962 dyn_cast_or_null
<NamespaceAliasDecl
>(NominatedNamespace
))
1963 return NA
->getNamespace();
1964 return cast_or_null
<NamespaceDecl
>(NominatedNamespace
);
1967 NamespaceDecl::NamespaceDecl(ASTContext
&C
, DeclContext
*DC
, bool Inline
,
1968 SourceLocation StartLoc
, SourceLocation IdLoc
,
1969 IdentifierInfo
*Id
, NamespaceDecl
*PrevDecl
)
1970 : NamedDecl(Namespace
, DC
, IdLoc
, Id
), DeclContext(Namespace
),
1971 redeclarable_base(C
), LocStart(StartLoc
), RBraceLoc(),
1972 AnonOrFirstNamespaceAndInline(nullptr, Inline
) {
1973 setPreviousDecl(PrevDecl
);
1976 AnonOrFirstNamespaceAndInline
.setPointer(PrevDecl
->getOriginalNamespace());
1979 NamespaceDecl
*NamespaceDecl::Create(ASTContext
&C
, DeclContext
*DC
,
1980 bool Inline
, SourceLocation StartLoc
,
1981 SourceLocation IdLoc
, IdentifierInfo
*Id
,
1982 NamespaceDecl
*PrevDecl
) {
1983 return new (C
, DC
) NamespaceDecl(C
, DC
, Inline
, StartLoc
, IdLoc
, Id
,
1987 NamespaceDecl
*NamespaceDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
1988 return new (C
, ID
) NamespaceDecl(C
, nullptr, false, SourceLocation(),
1989 SourceLocation(), nullptr, nullptr);
1992 NamespaceDecl
*NamespaceDecl::getNextRedeclarationImpl() {
1993 return getNextRedeclaration();
1995 NamespaceDecl
*NamespaceDecl::getPreviousDeclImpl() {
1996 return getPreviousDecl();
1998 NamespaceDecl
*NamespaceDecl::getMostRecentDeclImpl() {
1999 return getMostRecentDecl();
2002 void NamespaceAliasDecl::anchor() { }
2004 NamespaceAliasDecl
*NamespaceAliasDecl::getNextRedeclarationImpl() {
2005 return getNextRedeclaration();
2007 NamespaceAliasDecl
*NamespaceAliasDecl::getPreviousDeclImpl() {
2008 return getPreviousDecl();
2010 NamespaceAliasDecl
*NamespaceAliasDecl::getMostRecentDeclImpl() {
2011 return getMostRecentDecl();
2014 NamespaceAliasDecl
*NamespaceAliasDecl::Create(ASTContext
&C
, DeclContext
*DC
,
2015 SourceLocation UsingLoc
,
2016 SourceLocation AliasLoc
,
2017 IdentifierInfo
*Alias
,
2018 NestedNameSpecifierLoc QualifierLoc
,
2019 SourceLocation IdentLoc
,
2020 NamedDecl
*Namespace
) {
2021 // FIXME: Preserve the aliased namespace as written.
2022 if (NamespaceDecl
*NS
= dyn_cast_or_null
<NamespaceDecl
>(Namespace
))
2023 Namespace
= NS
->getOriginalNamespace();
2024 return new (C
, DC
) NamespaceAliasDecl(C
, DC
, UsingLoc
, AliasLoc
, Alias
,
2025 QualifierLoc
, IdentLoc
, Namespace
);
2028 NamespaceAliasDecl
*
2029 NamespaceAliasDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
2030 return new (C
, ID
) NamespaceAliasDecl(C
, nullptr, SourceLocation(),
2031 SourceLocation(), nullptr,
2032 NestedNameSpecifierLoc(),
2033 SourceLocation(), nullptr);
2036 void UsingShadowDecl::anchor() { }
2039 UsingShadowDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
2040 return new (C
, ID
) UsingShadowDecl(C
, nullptr, SourceLocation(),
2044 UsingDecl
*UsingShadowDecl::getUsingDecl() const {
2045 const UsingShadowDecl
*Shadow
= this;
2046 while (const UsingShadowDecl
*NextShadow
=
2047 dyn_cast
<UsingShadowDecl
>(Shadow
->UsingOrNextShadow
))
2048 Shadow
= NextShadow
;
2049 return cast
<UsingDecl
>(Shadow
->UsingOrNextShadow
);
2052 void UsingDecl::anchor() { }
2054 void UsingDecl::addShadowDecl(UsingShadowDecl
*S
) {
2055 assert(std::find(shadow_begin(), shadow_end(), S
) == shadow_end() &&
2056 "declaration already in set");
2057 assert(S
->getUsingDecl() == this);
2059 if (FirstUsingShadow
.getPointer())
2060 S
->UsingOrNextShadow
= FirstUsingShadow
.getPointer();
2061 FirstUsingShadow
.setPointer(S
);
2064 void UsingDecl::removeShadowDecl(UsingShadowDecl
*S
) {
2065 assert(std::find(shadow_begin(), shadow_end(), S
) != shadow_end() &&
2066 "declaration not in set");
2067 assert(S
->getUsingDecl() == this);
2069 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
2071 if (FirstUsingShadow
.getPointer() == S
) {
2072 FirstUsingShadow
.setPointer(
2073 dyn_cast
<UsingShadowDecl
>(S
->UsingOrNextShadow
));
2074 S
->UsingOrNextShadow
= this;
2078 UsingShadowDecl
*Prev
= FirstUsingShadow
.getPointer();
2079 while (Prev
->UsingOrNextShadow
!= S
)
2080 Prev
= cast
<UsingShadowDecl
>(Prev
->UsingOrNextShadow
);
2081 Prev
->UsingOrNextShadow
= S
->UsingOrNextShadow
;
2082 S
->UsingOrNextShadow
= this;
2085 UsingDecl
*UsingDecl::Create(ASTContext
&C
, DeclContext
*DC
, SourceLocation UL
,
2086 NestedNameSpecifierLoc QualifierLoc
,
2087 const DeclarationNameInfo
&NameInfo
,
2089 return new (C
, DC
) UsingDecl(DC
, UL
, QualifierLoc
, NameInfo
, HasTypename
);
2092 UsingDecl
*UsingDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
2093 return new (C
, ID
) UsingDecl(nullptr, SourceLocation(),
2094 NestedNameSpecifierLoc(), DeclarationNameInfo(),
2098 SourceRange
UsingDecl::getSourceRange() const {
2099 SourceLocation Begin
= isAccessDeclaration()
2100 ? getQualifierLoc().getBeginLoc() : UsingLocation
;
2101 return SourceRange(Begin
, getNameInfo().getEndLoc());
2104 void UnresolvedUsingValueDecl::anchor() { }
2106 UnresolvedUsingValueDecl
*
2107 UnresolvedUsingValueDecl::Create(ASTContext
&C
, DeclContext
*DC
,
2108 SourceLocation UsingLoc
,
2109 NestedNameSpecifierLoc QualifierLoc
,
2110 const DeclarationNameInfo
&NameInfo
) {
2111 return new (C
, DC
) UnresolvedUsingValueDecl(DC
, C
.DependentTy
, UsingLoc
,
2112 QualifierLoc
, NameInfo
);
2115 UnresolvedUsingValueDecl
*
2116 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
2117 return new (C
, ID
) UnresolvedUsingValueDecl(nullptr, QualType(),
2119 NestedNameSpecifierLoc(),
2120 DeclarationNameInfo());
2123 SourceRange
UnresolvedUsingValueDecl::getSourceRange() const {
2124 SourceLocation Begin
= isAccessDeclaration()
2125 ? getQualifierLoc().getBeginLoc() : UsingLocation
;
2126 return SourceRange(Begin
, getNameInfo().getEndLoc());
2129 void UnresolvedUsingTypenameDecl::anchor() { }
2131 UnresolvedUsingTypenameDecl
*
2132 UnresolvedUsingTypenameDecl::Create(ASTContext
&C
, DeclContext
*DC
,
2133 SourceLocation UsingLoc
,
2134 SourceLocation TypenameLoc
,
2135 NestedNameSpecifierLoc QualifierLoc
,
2136 SourceLocation TargetNameLoc
,
2137 DeclarationName TargetName
) {
2138 return new (C
, DC
) UnresolvedUsingTypenameDecl(
2139 DC
, UsingLoc
, TypenameLoc
, QualifierLoc
, TargetNameLoc
,
2140 TargetName
.getAsIdentifierInfo());
2143 UnresolvedUsingTypenameDecl
*
2144 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext
&C
, unsigned ID
) {
2145 return new (C
, ID
) UnresolvedUsingTypenameDecl(
2146 nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
2147 SourceLocation(), nullptr);
2150 void StaticAssertDecl::anchor() { }
2152 StaticAssertDecl
*StaticAssertDecl::Create(ASTContext
&C
, DeclContext
*DC
,
2153 SourceLocation StaticAssertLoc
,
2155 StringLiteral
*Message
,
2156 SourceLocation RParenLoc
,
2158 return new (C
, DC
) StaticAssertDecl(DC
, StaticAssertLoc
, AssertExpr
, Message
,
2162 StaticAssertDecl
*StaticAssertDecl::CreateDeserialized(ASTContext
&C
,
2164 return new (C
, ID
) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
2165 nullptr, SourceLocation(), false);
2168 MSPropertyDecl
*MSPropertyDecl::Create(ASTContext
&C
, DeclContext
*DC
,
2169 SourceLocation L
, DeclarationName N
,
2170 QualType T
, TypeSourceInfo
*TInfo
,
2171 SourceLocation StartL
,
2172 IdentifierInfo
*Getter
,
2173 IdentifierInfo
*Setter
) {
2174 return new (C
, DC
) MSPropertyDecl(DC
, L
, N
, T
, TInfo
, StartL
, Getter
, Setter
);
2177 MSPropertyDecl
*MSPropertyDecl::CreateDeserialized(ASTContext
&C
,
2179 return new (C
, ID
) MSPropertyDecl(nullptr, SourceLocation(),
2180 DeclarationName(), QualType(), nullptr,
2181 SourceLocation(), nullptr, nullptr);
2184 static const char *getAccessName(AccessSpecifier AS
) {
2187 llvm_unreachable("Invalid access specifier!");
2195 llvm_unreachable("Invalid access specifier!");
2198 const DiagnosticBuilder
&clang::operator<<(const DiagnosticBuilder
&DB
,
2199 AccessSpecifier AS
) {
2200 return DB
<< getAccessName(AS
);
2203 const PartialDiagnostic
&clang::operator<<(const PartialDiagnostic
&DB
,
2204 AccessSpecifier AS
) {
2205 return DB
<< getAccessName(AS
);