etc/services - sync with NetBSD-8
[minix.git] / external / bsd / llvm / dist / clang / lib / AST / DeclCXX.cpp
blob9af8c4b242a6a4750244b2f1a30e314dfaa3c42d
1 //===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the C++ related Decl classes.
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),
74 Bases(), VBases(),
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);
107 return R;
110 CXXRecordDecl *
111 CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
112 TypeSourceInfo *Info, SourceLocation Loc,
113 bool Dependent, bool IsGeneric,
114 LambdaCaptureDefault CaptureDefault) {
115 CXXRecordDecl *R =
116 new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
117 nullptr, nullptr);
118 R->IsBeingDefined = true;
119 R->DefinitionData =
120 new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
121 CaptureDefault);
122 R->MayHaveOutOfDateDef = false;
123 R->setImplicit(true);
124 C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
125 return R;
128 CXXRecordDecl *
129 CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
130 CXXRecordDecl *R = new (C, ID) CXXRecordDecl(
131 CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
132 nullptr, nullptr);
133 R->MayHaveOutOfDateDef = false;
134 return R;
137 void
138 CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
139 unsigned NumBases) {
140 ASTContext &C = getASTContext();
142 if (!data().Bases.isOffset() && data().NumBases > 0)
143 C.Deallocate(data().getBases());
145 if (NumBases) {
146 // C++ [dcl.init.aggr]p1:
147 // An aggregate is [...] a class with [...] no base classes [...].
148 data().Aggregate = false;
150 // C++ [class]p4:
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())
170 continue;
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()) {
177 if (!data().Empty) {
178 // C++0x [class]p7:
179 // A standard-layout class is a class that:
180 // [...]
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;
199 // C++0x [class]p7:
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
233 // classes
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;
242 // C++0x [class]p7:
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;
251 } else {
252 // C++ [class.ctor]p5:
253 // A default constructor is trivial [...] if:
254 // -- all the direct base classes of its class have trivial default
255 // constructors.
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 [...]
261 // [...]
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
269 // check is correct.
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 [...]
275 // [...]
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
283 // check is correct.
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;
340 return;
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
359 // deleted if X has:
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
368 // deleted if X has:
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
377 // deleted if X has:
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 *) {
391 return true;
394 bool CXXRecordDecl::hasAnyDependentBases() const {
395 if (!isDependentContext())
396 return false;
398 return !forallBases(SawBase, nullptr);
401 bool CXXRecordDecl::isTriviallyCopyable() const {
402 // C++0x [class]p5:
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;
415 return true;
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())
434 return;
436 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
437 if (FunTmpl)
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;
446 // C++ [class]p4:
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;
465 // C++0x [class]p7:
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
473 // was completed.
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.
479 unsigned SMKind = 0;
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;
487 // C++ [class]p4:
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
496 // to all functions.
497 bool UserProvided = Constructor->isUserProvided();
499 if (Constructor->isDefaultConstructor()) {
500 SMKind |= SMF_DefaultConstructor;
502 if (UserProvided)
503 data().UserProvidedDefaultConstructor = true;
504 if (Constructor->isConstexpr())
505 data().HasConstexprDefaultConstructor = true;
508 if (!FunTmpl) {
509 unsigned Quals;
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.
547 if (DD->isVirtual())
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
572 // work.
573 AccessSpecifier AS = Conversion->getAccessUnsafe();
575 if (Conversion->getPrimaryTemplate()) {
576 // We don't record specializations.
577 } else {
578 ASTContext &Ctx = getASTContext();
579 ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);
580 NamedDecl *Primary =
581 FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion);
582 if (Primary->getPreviousDecl())
583 Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),
584 Primary, AS);
585 else
586 Conversions.addDecl(Ctx, Primary, AS);
590 if (SMKind) {
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;
602 else
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;
612 // C++03 [class]p4:
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;
627 return;
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
635 // initialized.
636 if (Field->isUnnamedBitfield())
637 return;
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;
649 // C++0x [class]p7:
650 // A standard-layout class is a class that:
651 // [...]
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;
673 // C++0x [class]p9:
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
691 // non-trivial.
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;
705 // C++0x [class]p7:
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;
720 // C++11 [class]p5:
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;
733 // C++11 [class]p10:
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
759 // deleted if:
760 // -- X is a union-like class that has a variant member with a
761 // non-trivial [corresponding special member]
762 if (isUnion()) {
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 [...]
781 // [...]
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 [...]
795 // [...]
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);
816 // C++0x [class]p7:
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;
823 // C++0x [class]p7:
824 // A standard-layout class is a class that:
825 // [...]
826 // -- has no base classes of the same type as the first non-static
827 // data member.
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;
842 break;
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;
893 } else {
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
903 // thereof)
904 if (T.isConstQualified())
905 data().DefaultedMoveAssignmentIsDeleted = true;
908 // C++0x [class]p7:
909 // A standard-layout class is a class that:
910 // [...]
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
915 // clause holds.
916 if (!data().HasNoNonEmptyBases)
917 data().IsStandardLayout = false;
919 // If this is not a zero-length bit-field, then the class is not empty.
920 if (data().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.
943 unsigned SMKind = 0;
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.
969 if (D->isTrivial())
970 data().HasTrivialSpecialMembers |= SMKind;
971 else
972 data().DeclaredNonTrivialSpecialMembers |= SMKind;
975 bool CXXRecordDecl::isCLike() const {
976 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
977 !TemplateOrInstantiation.isNull())
978 return false;
979 if (!hasDefinition())
980 return true;
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 {
1025 Captures.clear();
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();
1046 return nullptr;
1049 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
1050 QualType T =
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
1063 /// of this base
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,
1070 bool InVirtual,
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);
1093 if (!Hidden)
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.
1102 else if (!Hidden) {
1103 AccessSpecifier IAccess
1104 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1106 if (InVirtual)
1107 VOutput.addDecl(I.getDecl(), IAccess);
1108 else
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>();
1117 if (!RT) continue;
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
1142 // be hidden.
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>();
1159 if (!RT) continue;
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();
1168 I != E; ++I) {
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);
1184 } else {
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.:
1199 // class A : B {
1200 // using B::operator int;
1201 // operator int();
1202 // };
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) {
1210 Convs.erase(I);
1211 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1212 && "conversion was found multiple times in unresolved set");
1213 return;
1217 llvm_unreachable("conversion not found in set!");
1220 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1221 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1222 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1224 return nullptr;
1227 void
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;
1248 void
1249 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1250 if (ClassTemplateSpecializationDecl *Spec
1251 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1252 Spec->setSpecializationKind(TSK);
1253 return;
1256 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1257 MSInfo->setTemplateSpecializationKind(TSK);
1258 return;
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())
1272 break;
1273 CTD = NewCTD;
1275 return CTD->getTemplatedDecl();
1277 if (auto *CTPSD =
1278 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
1279 while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) {
1280 if (NewCTPSD->isMemberSpecialization())
1281 break;
1282 CTPSD = NewCTPSD;
1284 return CTPSD;
1288 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1289 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
1290 const CXXRecordDecl *RD = this;
1291 while (auto *NewRD = RD->getInstantiatedFromMemberClass())
1292 RD = NewRD;
1293 return RD;
1297 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) &&
1298 "couldn't find pattern for class template instantiation");
1299 return nullptr;
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);
1311 if (R.empty())
1312 return nullptr;
1314 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
1315 return Dtor;
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;
1334 bool Done = false;
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
1347 // virtual.
1348 if (SO->second.front().Method->isPure()) {
1349 data().Abstract = true;
1350 Done = true;
1351 break;
1357 // Set access bits correctly on the directly-declared conversions.
1358 for (conversion_iterator I = conversion_begin(), E = conversion_end();
1359 I != E; ++I)
1360 I.setAccess((*I)->getAccess());
1363 bool CXXRecordDecl::mayBeAbstract() const {
1364 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1365 isDependentContext())
1366 return false;
1368 for (const auto &B : bases()) {
1369 CXXRecordDecl *BaseDecl
1370 = cast<CXXRecordDecl>(B.getType()->getAs<RecordType>()->getDecl());
1371 if (BaseDecl->isAbstract())
1372 return true;
1375 return false;
1378 void CXXMethodDecl::anchor() { }
1380 bool CXXMethodDecl::isStatic() const {
1381 const CXXMethodDecl *MD = getCanonicalDecl();
1383 if (MD->getStorageClass() == SC_Static)
1384 return true;
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())
1396 return true;
1397 if (recursivelyOverrides(MD, BaseMD))
1398 return true;
1400 return false;
1403 CXXMethodDecl *
1404 CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1405 bool MayBeBase) {
1406 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1407 return this;
1409 // Lookup doesn't work for destructors, so handle them separately.
1410 if (isa<CXXDestructorDecl>(this)) {
1411 CXXMethodDecl *MD = RD->getDestructor();
1412 if (MD) {
1413 if (recursivelyOverrides(MD, this))
1414 return MD;
1415 if (MayBeBase && recursivelyOverrides(this, MD))
1416 return MD;
1418 return nullptr;
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);
1424 if (!MD)
1425 continue;
1426 if (recursivelyOverrides(MD, this))
1427 return MD;
1428 if (MayBeBase && recursivelyOverrides(this, MD))
1429 return MD;
1432 for (const auto &I : RD->bases()) {
1433 const RecordType *RT = I.getType()->getAs<RecordType>();
1434 if (!RT)
1435 continue;
1436 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1437 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1438 if (T)
1439 return T;
1442 return nullptr;
1445 CXXMethodDecl *
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,
1454 EndLocation);
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)
1466 return false;
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())
1472 return false;
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)
1479 return true;
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()))
1490 return false;
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();
1496 I != E; ++I) {
1497 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
1498 if (FD->getNumParams() == 1)
1499 return false;
1502 return true;
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)
1514 return false;
1516 QualType ParamType = getParamDecl(0)->getType();
1517 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1518 ParamType = Ref->getPointeeType();
1520 ASTContext &Context = getASTContext();
1521 QualType ClassType
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)
1534 return false;
1536 QualType ParamType = getParamDecl(0)->getType();
1537 if (!isa<RValueReferenceType>(ParamType))
1538 return false;
1539 ParamType = ParamType->getPointeeType();
1541 ASTContext &Context = getASTContext();
1542 QualType ClassType
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();
1590 if (!CheckFn)
1591 CheckFn = this;
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();
1606 return false;
1609 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1610 TypeSourceInfo *TInfo, bool IsVirtual,
1611 SourceLocation L, Expr *Init,
1612 SourceLocation R,
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,
1621 FieldDecl *Member,
1622 SourceLocation MemberLoc,
1623 SourceLocation L, Expr *Init,
1624 SourceLocation R)
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,
1635 SourceLocation R)
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,
1645 SourceLocation R)
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,
1653 FieldDecl *Member,
1654 SourceLocation MemberLoc,
1655 SourceLocation L, Expr *Init,
1656 SourceLocation R,
1657 VarDecl **Indices,
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,
1668 FieldDecl *Member,
1669 SourceLocation MemberLoc,
1670 SourceLocation L, Expr *Init,
1671 SourceLocation R,
1672 VarDecl **Indices,
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();
1684 else
1685 return TypeLoc();
1688 const Type *CXXCtorInitializer::getBaseClass() const {
1689 if (isBaseInitializer())
1690 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1691 else
1692 return nullptr;
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();
1749 return nullptr;
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());
1760 bool
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))
1787 return false;
1789 const ParmVarDecl *Param = getParamDecl(0);
1791 // Do we have a reference type?
1792 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
1793 if (!ParamRefType)
1794 return false;
1796 // Is it a reference to our class type?
1797 ASTContext &Context = getASTContext();
1799 CanQualType PointeeType
1800 = Context.getCanonicalType(ParamRefType->getPointeeType());
1801 CanQualType ClassTy
1802 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1803 if (PointeeType.getUnqualifiedType() != ClassTy)
1804 return false;
1806 // FIXME: other qualifiers?
1808 // We have a copy or move constructor.
1809 TypeQuals = PointeeType.getCVRQualifiers();
1810 return true;
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
1819 // constructor.
1820 if (isExplicit() && !AllowExplicit)
1821 return false;
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))
1835 return false;
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?
1843 CanQualType ClassTy
1844 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1845 if (ParamType.getUnqualifiedType() != ClassTy)
1846 return false;
1848 return true;
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))
1855 return nullptr;
1857 return cast<CXXConstructorDecl>(*It);
1860 void
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() { }
1870 CXXDestructorDecl *
1871 CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1872 return new (C, ID)
1873 CXXDestructorDecl(C, nullptr, SourceLocation(), DeclarationNameInfo(),
1874 QualType(), nullptr, false, false);
1877 CXXDestructorDecl *
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() { }
1892 CXXConversionDecl *
1893 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1894 return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
1895 DeclarationNameInfo(), QualType(),
1896 nullptr, false, false, false,
1897 SourceLocation());
1900 CXXConversionDecl *
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,
1912 EndLocation);
1915 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1916 return isImplicit() && getParent()->isLambda() &&
1917 getConversionType()->isBlockPointerType();
1920 void LinkageSpecDecl::anchor() { }
1922 LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
1923 DeclContext *DC,
1924 SourceLocation ExternLoc,
1925 SourceLocation LangLoc,
1926 LanguageIDs Lang,
1927 bool HasBraces) {
1928 return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
1931 LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C,
1932 unsigned ID) {
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,
1940 SourceLocation L,
1941 SourceLocation NamespaceLoc,
1942 NestedNameSpecifierLoc QualifierLoc,
1943 SourceLocation IdentLoc,
1944 NamedDecl *Used,
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,
1953 unsigned ID) {
1954 return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
1955 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);
1975 if (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,
1984 PrevDecl);
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() { }
2038 UsingShadowDecl *
2039 UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2040 return new (C, ID) UsingShadowDecl(C, nullptr, SourceLocation(),
2041 nullptr, nullptr);
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;
2075 return;
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,
2088 bool HasTypename) {
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(),
2095 false);
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(),
2118 SourceLocation(),
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,
2154 Expr *AssertExpr,
2155 StringLiteral *Message,
2156 SourceLocation RParenLoc,
2157 bool Failed) {
2158 return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2159 RParenLoc, Failed);
2162 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
2163 unsigned ID) {
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,
2178 unsigned ID) {
2179 return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
2180 DeclarationName(), QualType(), nullptr,
2181 SourceLocation(), nullptr, nullptr);
2184 static const char *getAccessName(AccessSpecifier AS) {
2185 switch (AS) {
2186 case AS_none:
2187 llvm_unreachable("Invalid access specifier!");
2188 case AS_public:
2189 return "public";
2190 case AS_private:
2191 return "private";
2192 case AS_protected:
2193 return "protected";
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);