blob: 32e64b6e4eca960a959bcbc9f79dfbc3c1ea96de [file] [log] [blame]
Ted Kremenek21475702008-09-05 17:16:31 +00001//===--- 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.
11//
12//===----------------------------------------------------------------------===//
Ted Kremenek21475702008-09-05 17:16:31 +000013#include "clang/AST/DeclCXX.h"
14#include "clang/AST/ASTContext.h"
Faisal Vali2b391ab2013-09-26 19:54:12 +000015#include "clang/AST/ASTLambda.h"
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +000016#include "clang/AST/ASTMutationListener.h"
Douglas Gregor8fb95122010-09-29 00:15:42 +000017#include "clang/AST/CXXInheritance.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "clang/AST/DeclTemplate.h"
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000019#include "clang/AST/Expr.h"
Douglas Gregord73f3dd2011-11-01 01:16:03 +000020#include "clang/AST/ExprCXX.h"
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +000021#include "clang/AST/TypeLoc.h"
Douglas Gregorb6acda02008-11-12 23:21:09 +000022#include "clang/Basic/IdentifierTable.h"
Douglas Gregor74a34442008-12-23 21:31:30 +000023#include "llvm/ADT/STLExtras.h"
Fariborz Jahaniana9540492009-09-12 19:52:10 +000024#include "llvm/ADT/SmallPtrSet.h"
Ted Kremenek21475702008-09-05 17:16:31 +000025using namespace clang;
26
27//===----------------------------------------------------------------------===//
28// Decl Allocation/Deallocation Method Implementations
29//===----------------------------------------------------------------------===//
Douglas Gregor5101c242008-12-05 18:15:24 +000030
David Blaikie68e081d2011-12-20 02:48:34 +000031void AccessSpecDecl::anchor() { }
32
Douglas Gregor72172e92012-01-05 21:55:30 +000033AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +000034 return new (C, ID) AccessSpecDecl(EmptyShell());
Douglas Gregor72172e92012-01-05 21:55:30 +000035}
36
Richard Smitha4ba74c2013-08-30 04:46:40 +000037void 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");
41
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);
46}
47
John McCall67da35c2010-02-04 22:26:26 +000048CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
Richard Smith328aae52012-11-30 05:11:39 +000049 : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
Eli Friedmanc80ca682009-08-15 22:23:00 +000050 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
Chandler Carruth583edf82011-04-30 10:07:30 +000051 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
Chandler Carruthb1963742011-04-30 09:17:45 +000052 HasPrivateFields(false), HasProtectedFields(false), HasPublicFields(false),
Richard Smithab44d5b2013-12-10 08:25:00 +000053 HasMutableFields(false), HasVariantMembers(false), HasOnlyCMembers(true),
Richard Smith593f9932012-12-08 02:01:17 +000054 HasInClassInitializer(false), HasUninitializedReferenceMember(false),
Richard Smith6b02d462012-12-08 08:32:28 +000055 NeedOverloadResolutionForMoveConstructor(false),
56 NeedOverloadResolutionForMoveAssignment(false),
57 NeedOverloadResolutionForDestructor(false),
58 DefaultedMoveConstructorIsDeleted(false),
59 DefaultedMoveAssignmentIsDeleted(false),
60 DefaultedDestructorIsDeleted(false),
Richard Smith328aae52012-11-30 05:11:39 +000061 HasTrivialSpecialMembers(SMF_All),
Richard Smith92f241f2012-12-08 02:53:02 +000062 DeclaredNonTrivialSpecialMembers(0),
Richard Smith328aae52012-11-30 05:11:39 +000063 HasIrrelevantDestructor(true),
Richard Smithcc36f692011-12-22 02:22:31 +000064 HasConstexprNonCopyMoveConstructor(false),
65 DefaultedDefaultConstructorIsConstexpr(true),
Richard Smith328aae52012-11-30 05:11:39 +000066 HasConstexprDefaultConstructor(false),
Alexis Huntf479f1b2011-05-09 18:22:59 +000067 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
Richard Smith328aae52012-11-30 05:11:39 +000068 UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
Richard Smith1c33fe82012-11-28 06:23:12 +000069 ImplicitCopyConstructorHasConstParam(true),
70 ImplicitCopyAssignmentHasConstParam(true),
71 HasDeclaredCopyConstructorWithConstParam(false),
72 HasDeclaredCopyAssignmentWithConstParam(false),
David Majnemer5ef4fe72014-06-13 06:43:46 +000073 IsLambda(false), IsParsingBaseSpecifiers(false), NumBases(0), NumVBases(0),
74 Bases(), VBases(),
Richard Smith68ad0e72013-06-26 02:41:25 +000075 Definition(D), FirstFriend() {
John McCall67da35c2010-02-04 22:26:26 +000076}
77
Benjamin Kramer300c0632012-07-04 17:03:33 +000078CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
79 return Bases.get(Definition->getASTContext().getExternalSource());
80}
81
82CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
83 return VBases.get(Definition->getASTContext().getExternalSource());
84}
85
Richard Smith053f6c62014-05-16 23:01:30 +000086CXXRecordDecl::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
Richard Smith64c06302014-05-22 23:19:02 +000092 : DefinitionDataPtr(this)),
Richard Smith053f6c62014-05-16 23:01:30 +000093 TemplateOrInstantiation() {}
Douglas Gregorb6acda02008-11-12 23:21:09 +000094
Jay Foad39c79802011-01-12 09:06:06 +000095CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
Abramo Bagnara29c2d462011-03-09 14:09:51 +000096 DeclContext *DC, SourceLocation StartLoc,
97 SourceLocation IdLoc, IdentifierInfo *Id,
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +000098 CXXRecordDecl* PrevDecl,
99 bool DelayTypeCreation) {
Richard Smith053f6c62014-05-16 23:01:30 +0000100 CXXRecordDecl *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc,
Richard Smithf7981722013-11-22 09:01:48 +0000101 IdLoc, Id, PrevDecl);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000102 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
Mike Stump11289f42009-09-09 15:08:12 +0000103
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +0000104 // FIXME: DelayTypeCreation seems like such a hack
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +0000105 if (!DelayTypeCreation)
Mike Stump11289f42009-09-09 15:08:12 +0000106 C.getTypeDeclType(R, PrevDecl);
Ted Kremenek21475702008-09-05 17:16:31 +0000107 return R;
108}
109
Richard Smith053f6c62014-05-16 23:01:30 +0000110CXXRecordDecl *
111CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
112 TypeSourceInfo *Info, SourceLocation Loc,
113 bool Dependent, bool IsGeneric,
114 LambdaCaptureDefault CaptureDefault) {
Richard Smithf7981722013-11-22 09:01:48 +0000115 CXXRecordDecl *R =
Richard Smith053f6c62014-05-16 23:01:30 +0000116 new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
117 nullptr, nullptr);
Douglas Gregorc8a73492012-02-13 15:44:47 +0000118 R->IsBeingDefined = true;
Richard Smith64c06302014-05-22 23:19:02 +0000119 R->DefinitionData =
Richard Smith053f6c62014-05-16 23:01:30 +0000120 new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
Richard Smith64c06302014-05-22 23:19:02 +0000121 CaptureDefault);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000122 R->MayHaveOutOfDateDef = false;
James Dennett8f60cdd2013-09-05 17:46:21 +0000123 R->setImplicit(true);
Craig Topper36250ad2014-05-12 05:36:57 +0000124 C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
Douglas Gregorc8a73492012-02-13 15:44:47 +0000125 return R;
126}
127
Douglas Gregor72172e92012-01-05 21:55:30 +0000128CXXRecordDecl *
129CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +0000130 CXXRecordDecl *R = new (C, ID) CXXRecordDecl(
Richard Smith053f6c62014-05-16 23:01:30 +0000131 CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +0000132 nullptr, nullptr);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000133 R->MayHaveOutOfDateDef = false;
134 return R;
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +0000135}
136
Mike Stump11289f42009-09-09 15:08:12 +0000137void
Craig Toppere6337e12015-12-25 00:36:02 +0000138CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
139 unsigned NumBases) {
Douglas Gregor4a62bdf2010-02-11 01:30:34 +0000140 ASTContext &C = getASTContext();
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +0000141
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000142 if (!data().Bases.isOffset() && data().NumBases > 0)
143 C.Deallocate(data().getBases());
Mike Stump11289f42009-09-09 15:08:12 +0000144
Craig Toppere6337e12015-12-25 00:36:02 +0000145 if (NumBases) {
Richard Smithaed32b42011-10-18 20:08:55 +0000146 // C++ [dcl.init.aggr]p1:
147 // An aggregate is [...] a class with [...] no base classes [...].
148 data().Aggregate = false;
149
150 // C++ [class]p4:
151 // A POD-struct is an aggregate class...
152 data().PlainOldData = false;
153 }
154
Anders Carlssonabb20e62010-03-29 05:13:12 +0000155 // The set of seen virtual base types.
Anders Carlssone47380f2010-03-29 19:49:09 +0000156 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000157
158 // The virtual bases of this class.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000159 SmallVector<const CXXBaseSpecifier *, 8> VBases;
Mike Stump11289f42009-09-09 15:08:12 +0000160
Craig Toppere6337e12015-12-25 00:36:02 +0000161 data().Bases = new(C) CXXBaseSpecifier [NumBases];
162 data().NumBases = NumBases;
163 for (unsigned i = 0; i < NumBases; ++i) {
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000164 data().getBases()[i] = *Bases[i];
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000165 // Keep track of inherited vbases for this base class.
166 const CXXBaseSpecifier *Base = Bases[i];
167 QualType BaseType = Base->getType();
Douglas Gregorbeab56e2010-02-27 00:25:28 +0000168 // Skip dependent types; we can't do any checking on them now.
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000169 if (BaseType->isDependentType())
170 continue;
171 CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000172 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
Anders Carlssonabb20e62010-03-29 05:13:12 +0000173
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000174 // A class with a non-empty base class is not empty.
175 // FIXME: Standard ref?
Chandler Carruthb1963742011-04-30 09:17:45 +0000176 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.
Chandler Carruth583edf82011-04-30 10:07:30 +0000186 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000187 }
188
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000189 data().Empty = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000190 data().HasNoNonEmptyBases = false;
191 }
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000192
Douglas Gregor11c024b2010-09-28 20:50:54 +0000193 // 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;
Chandler Carruthe71d0622011-04-24 02:49:34 +0000198
Chandler Carruthb1963742011-04-30 09:17:45 +0000199 // C++0x [class]p7:
200 // A standard-layout class is a class that: [...]
201 // -- has no non-standard-layout base classes
Chandler Carruth583edf82011-04-30 10:07:30 +0000202 if (!BaseClassDecl->isStandardLayout())
203 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000204
Chandler Carruthe71d0622011-04-24 02:49:34 +0000205 // Record if this base is the first non-literal field or base.
Richard Smithd9f663b2013-04-22 15:31:51 +0000206 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C))
Chandler Carruthe71d0622011-04-24 02:49:34 +0000207 data().HasNonLiteralTypeFieldsOrBases = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000208
Anders Carlssonabb20e62010-03-29 05:13:12 +0000209 // Now go through all virtual bases of this base and add them.
Aaron Ballman445a9392014-03-13 16:15:17 +0000210 for (const auto &VBase : BaseClassDecl->vbases()) {
Anders Carlssonabb20e62010-03-29 05:13:12 +0000211 // Add this base if it's not already in the list.
David Blaikie82e95a32014-11-19 07:49:47 +0000212 if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
Aaron Ballman445a9392014-03-13 16:15:17 +0000213 VBases.push_back(&VBase);
Richard Smith1c33fe82012-11-28 06:23:12 +0000214
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&' [...]
Aaron Ballman445a9392014-03-13 16:15:17 +0000220 if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())
Richard Smith1c33fe82012-11-28 06:23:12 +0000221 if (!VBaseDecl->hasCopyConstructorWithConstParam())
222 data().ImplicitCopyConstructorHasConstParam = false;
223 }
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000224 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000225
226 if (Base->isVirtual()) {
227 // Add this base if it's not already in the list.
David Blaikie82e95a32014-11-19 07:49:47 +0000228 if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
Richard Smith1c33fe82012-11-28 06:23:12 +0000229 VBases.push_back(Base);
230
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000231 // 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;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000235
Richard Smith328aae52012-11-30 05:11:39 +0000236 // 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;
Chandler Carruthb1963742011-04-30 09:17:45 +0000241
242 // C++0x [class]p7:
243 // A standard-layout class is a class that: [...]
244 // -- has [...] no virtual base classes
Chandler Carruth583edf82011-04-30 10:07:30 +0000245 data().IsStandardLayout = false;
Richard Smithcc36f692011-12-22 02:22:31 +0000246
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;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000251 } else {
252 // C++ [class.ctor]p5:
Alexis Huntf479f1b2011-05-09 18:22:59 +0000253 // A default constructor is trivial [...] if:
254 // -- all the direct base classes of its class have trivial default
255 // constructors.
256 if (!BaseClassDecl->hasTrivialDefaultConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000257 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
258
Chandler Carruthad7d4042011-04-23 23:10:33 +0000259 // 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
Douglas Gregor11c024b2010-09-28 20:50:54 +0000264 if (!BaseClassDecl->hasTrivialCopyConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000265 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
Richard Smith6b02d462012-12-08 08:32:28 +0000266 // 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.
Richard Smith16488472012-11-16 00:53:38 +0000270 if (!BaseClassDecl->hasTrivialMoveConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000271 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000272
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
Douglas Gregor11c024b2010-09-28 20:50:54 +0000278 if (!BaseClassDecl->hasTrivialCopyAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000279 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
Richard Smith6b02d462012-12-08 08:32:28 +0000280 // 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.
Richard Smith16488472012-11-16 00:53:38 +0000284 if (!BaseClassDecl->hasTrivialMoveAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000285 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
Richard Smithcc36f692011-12-22 02:22:31 +0000286
287 // C++11 [class.ctor]p6:
Richard Smithc101e612012-01-11 18:26:05 +0000288 // If that user-written default constructor would satisfy the
Richard Smithcc36f692011-12-22 02:22:31 +0000289 // requirements of a constexpr constructor, the implicitly-defined
290 // default constructor is constexpr.
291 if (!BaseClassDecl->hasConstexprDefaultConstructor())
292 data().DefaultedDefaultConstructorIsConstexpr = false;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000293 }
Richard Smith92f241f2012-12-08 02:53:02 +0000294
Douglas Gregor11c024b2010-09-28 20:50:54 +0000295 // 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())
Richard Smith328aae52012-11-30 05:11:39 +0000299 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000300
301 if (!BaseClassDecl->hasIrrelevantDestructor())
302 data().HasIrrelevantDestructor = false;
303
Richard Smith1c33fe82012-11-28 06:23:12 +0000304 // 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;
311
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;
319
John McCall31168b02011-06-15 23:02:42 +0000320 // 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);
Fariborz Jahanian78652202013-01-25 23:57:05 +0000324
325 if (BaseClassDecl->hasVolatileMember())
326 setHasVolatileMember(true);
John McCall31168b02011-06-15 23:02:42 +0000327
Douglas Gregor61226d32011-05-13 01:05:07 +0000328 // Keep track of the presence of mutable fields.
329 if (BaseClassDecl->hasMutableFields())
330 data().HasMutableFields = true;
Richard Smith593f9932012-12-08 02:01:17 +0000331
332 if (BaseClassDecl->hasUninitializedReferenceMember())
333 data().HasUninitializedReferenceMember = true;
Richard Smith6b02d462012-12-08 08:32:28 +0000334
335 addedClassSubobject(BaseClassDecl);
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000336 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000337
David Majnemer5ef4fe72014-06-13 06:43:46 +0000338 if (VBases.empty()) {
339 data().IsParsingBaseSpecifiers = false;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000340 return;
David Majnemer5ef4fe72014-06-13 06:43:46 +0000341 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000342
343 // Create base specifier for any direct or indirect virtual bases.
344 data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
345 data().NumVBases = VBases.size();
Richard Smith6b02d462012-12-08 08:32:28 +0000346 for (int I = 0, E = VBases.size(); I != E; ++I) {
347 QualType Type = VBases[I]->getType();
348 if (!Type->isDependentType())
349 addedClassSubobject(Type->getAsCXXRecordDecl());
Richard Smith26935e62011-07-12 23:49:11 +0000350 data().getVBases()[I] = *VBases[I];
Richard Smith6b02d462012-12-08 08:32:28 +0000351 }
David Majnemer5ef4fe72014-06-13 06:43:46 +0000352
353 data().IsParsingBaseSpecifiers = false;
Richard Smith6b02d462012-12-08 08:32:28 +0000354}
355
356void 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;
365
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;
374
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;
385 }
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000386}
387
Douglas Gregord2e6a452010-01-14 17:47:39 +0000388bool CXXRecordDecl::hasAnyDependentBases() const {
389 if (!isDependentContext())
390 return false;
391
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +0000392 return !forallBases([](const CXXRecordDecl *) { return true; });
Douglas Gregord2e6a452010-01-14 17:47:39 +0000393}
394
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000395bool CXXRecordDecl::isTriviallyCopyable() const {
396 // C++0x [class]p5:
397 // A trivially copyable class is a class that:
398 // -- has no non-trivial copy constructors,
Richard Smith16488472012-11-16 00:53:38 +0000399 if (hasNonTrivialCopyConstructor()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000400 // -- has no non-trivial move constructors,
Richard Smith16488472012-11-16 00:53:38 +0000401 if (hasNonTrivialMoveConstructor()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000402 // -- has no non-trivial copy assignment operators,
Richard Smith16488472012-11-16 00:53:38 +0000403 if (hasNonTrivialCopyAssignment()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000404 // -- has no non-trivial move assignment operators, and
Richard Smith16488472012-11-16 00:53:38 +0000405 if (hasNonTrivialMoveAssignment()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000406 // -- has a trivial destructor.
407 if (!hasTrivialDestructor()) return false;
408
409 return true;
410}
411
Douglas Gregor7d9120c2010-09-28 21:55:22 +0000412void CXXRecordDecl::markedVirtualFunctionPure() {
413 // C++ [class.abstract]p2:
414 // A class is abstract if it has at least one pure virtual function.
415 data().Abstract = true;
416}
417
418void CXXRecordDecl::addedMember(Decl *D) {
Joao Matose9a3ed42012-08-31 22:18:20 +0000419 if (!D->isImplicit() &&
420 !isa<FieldDecl>(D) &&
421 !isa<IndirectFieldDecl>(D) &&
422 (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
423 cast<TagDecl>(D)->getTagKind() == TTK_Interface))
424 data().HasOnlyCMembers = false;
425
426 // Ignore friends and invalid declarations.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000427 if (D->getFriendObjectKind() || D->isInvalidDecl())
Douglas Gregord30e79f2010-09-27 21:17:54 +0000428 return;
429
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000430 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
431 if (FunTmpl)
432 D = FunTmpl->getTemplatedDecl();
433
Douglas Gregora832d3e2010-09-28 19:45:33 +0000434 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
435 if (Method->isVirtual()) {
436 // C++ [dcl.init.aggr]p1:
437 // An aggregate is an array or a class with [...] no virtual functions.
438 data().Aggregate = false;
439
440 // C++ [class]p4:
441 // A POD-struct is an aggregate class...
442 data().PlainOldData = false;
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000443
444 // Virtual functions make the class non-empty.
445 // FIXME: Standard ref?
446 data().Empty = false;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000447
448 // C++ [class.virtual]p1:
449 // A class that declares or inherits a virtual function is called a
450 // polymorphic class.
451 data().Polymorphic = true;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000452
Richard Smith328aae52012-11-30 05:11:39 +0000453 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
454 // A [default constructor, copy/move constructor, or copy/move
455 // assignment operator for a class X] is trivial [...] if:
Chandler Carruthad7d4042011-04-23 23:10:33 +0000456 // -- class X has no virtual functions [...]
Richard Smith328aae52012-11-30 05:11:39 +0000457 data().HasTrivialSpecialMembers &= SMF_Destructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000458
Chandler Carruthb1963742011-04-30 09:17:45 +0000459 // C++0x [class]p7:
460 // A standard-layout class is a class that: [...]
461 // -- has no virtual functions
Chandler Carruth583edf82011-04-30 10:07:30 +0000462 data().IsStandardLayout = false;
Douglas Gregora832d3e2010-09-28 19:45:33 +0000463 }
464 }
Argyrios Kyrtzidis00f52662010-10-20 23:48:42 +0000465
Richard Smith1c33fe82012-11-28 06:23:12 +0000466 // Notify the listener if an implicit member was added after the definition
467 // was completed.
468 if (!isBeingDefined() && D->isImplicit())
469 if (ASTMutationListener *L = getASTMutationListener())
470 L->AddedCXXImplicitMember(data().Definition, D);
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000471
Richard Smith328aae52012-11-30 05:11:39 +0000472 // The kind of special member this declaration is, if any.
473 unsigned SMKind = 0;
474
Richard Smith1c33fe82012-11-28 06:23:12 +0000475 // Handle constructors.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000476 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
Richard Smith1c33fe82012-11-28 06:23:12 +0000477 if (!Constructor->isImplicit()) {
478 // Note that we have a user-declared constructor.
479 data().UserDeclaredConstructor = true;
480
481 // C++ [class]p4:
482 // A POD-struct is an aggregate class [...]
483 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
484 // type is technically an aggregate in C++0x since it wouldn't be in 03.
485 data().PlainOldData = false;
486 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000487
Richard Smitha5285072011-09-05 02:13:09 +0000488 // Technically, "user-provided" is only defined for special member
489 // functions, but the intent of the standard is clearly that it should apply
490 // to all functions.
491 bool UserProvided = Constructor->isUserProvided();
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000492
Alexis Hunt88c75c32011-05-09 21:45:35 +0000493 if (Constructor->isDefaultConstructor()) {
Richard Smith328aae52012-11-30 05:11:39 +0000494 SMKind |= SMF_DefaultConstructor;
495
496 if (UserProvided)
Alexis Huntea6f0322011-05-11 22:34:38 +0000497 data().UserProvidedDefaultConstructor = true;
Richard Smith1c33fe82012-11-28 06:23:12 +0000498 if (Constructor->isConstexpr())
Richard Smithcc36f692011-12-22 02:22:31 +0000499 data().HasConstexprDefaultConstructor = true;
Alexis Hunt88c75c32011-05-09 21:45:35 +0000500 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000501
Chandler Carruthad7d4042011-04-23 23:10:33 +0000502 if (!FunTmpl) {
Richard Smith1c33fe82012-11-28 06:23:12 +0000503 unsigned Quals;
504 if (Constructor->isCopyConstructor(Quals)) {
Richard Smith328aae52012-11-30 05:11:39 +0000505 SMKind |= SMF_CopyConstructor;
Richard Smith1c33fe82012-11-28 06:23:12 +0000506
507 if (Quals & Qualifiers::Const)
508 data().HasDeclaredCopyConstructorWithConstParam = true;
Richard Smith328aae52012-11-30 05:11:39 +0000509 } else if (Constructor->isMoveConstructor())
510 SMKind |= SMF_MoveConstructor;
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000511 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000512
513 // Record if we see any constexpr constructors which are neither copy
514 // nor move constructors.
515 if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
Richard Smith111af8d2011-08-10 18:11:37 +0000516 data().HasConstexprNonCopyMoveConstructor = true;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000517
Alexis Hunt88c75c32011-05-09 21:45:35 +0000518 // C++ [dcl.init.aggr]p1:
519 // An aggregate is an array or a class with no user-declared
520 // constructors [...].
Richard Smith852c9db2013-04-20 22:23:05 +0000521 // C++11 [dcl.init.aggr]p1:
Alexis Hunt88c75c32011-05-09 21:45:35 +0000522 // An aggregate is an array or a class with no user-provided
523 // constructors [...].
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000524 if (getASTContext().getLangOpts().CPlusPlus11
Richard Smith1c33fe82012-11-28 06:23:12 +0000525 ? UserProvided : !Constructor->isImplicit())
Alexis Hunt88c75c32011-05-09 21:45:35 +0000526 data().Aggregate = false;
Douglas Gregord30e79f2010-09-27 21:17:54 +0000527 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000528
Richard Smith1c33fe82012-11-28 06:23:12 +0000529 // Handle destructors.
Alexis Hunt97ab5542011-05-16 22:41:40 +0000530 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
Richard Smith328aae52012-11-30 05:11:39 +0000531 SMKind |= SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000532
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000533 if (DD->isUserProvided())
Richard Smith1c33fe82012-11-28 06:23:12 +0000534 data().HasIrrelevantDestructor = false;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000535 // If the destructor is explicitly defaulted and not trivial or not public
536 // or if the destructor is deleted, we clear HasIrrelevantDestructor in
537 // finishedDefaultedOrDeletedMember.
Richard Smith1c33fe82012-11-28 06:23:12 +0000538
Richard Smith1c33fe82012-11-28 06:23:12 +0000539 // C++11 [class.dtor]p5:
Richard Smith328aae52012-11-30 05:11:39 +0000540 // A destructor is trivial if [...] the destructor is not virtual.
541 if (DD->isVirtual())
542 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Douglas Gregor8f9ebe52010-09-27 22:48:58 +0000543 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000544
545 // Handle member functions.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000546 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Alexis Huntfcaeae42011-05-25 20:50:04 +0000547 if (Method->isCopyAssignmentOperator()) {
Richard Smith328aae52012-11-30 05:11:39 +0000548 SMKind |= SMF_CopyAssignment;
Richard Smith1c33fe82012-11-28 06:23:12 +0000549
550 const ReferenceType *ParamTy =
551 Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
552 if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
553 data().HasDeclaredCopyAssignmentWithConstParam = true;
Alexis Huntfcaeae42011-05-25 20:50:04 +0000554 }
Alexis Huntfcaeae42011-05-25 20:50:04 +0000555
Richard Smith328aae52012-11-30 05:11:39 +0000556 if (Method->isMoveAssignmentOperator())
557 SMKind |= SMF_MoveAssignment;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000558
Douglas Gregor457104e2010-09-29 04:25:11 +0000559 // Keep the list of conversion functions up-to-date.
560 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
Douglas Gregor92fde2f2013-04-08 17:12:58 +0000561 // FIXME: We use the 'unsafe' accessor for the access specifier here,
562 // because Sema may not have set it yet. That's really just a misdesign
563 // in Sema. However, LLDB *will* have set the access specifier correctly,
564 // and adds declarations after the class is technically completed,
565 // so completeDefinition()'s overriding of the access specifiers doesn't
566 // work.
567 AccessSpecifier AS = Conversion->getAccessUnsafe();
568
Richard Smith328aae52012-11-30 05:11:39 +0000569 if (Conversion->getPrimaryTemplate()) {
570 // We don't record specializations.
Douglas Gregor457104e2010-09-29 04:25:11 +0000571 } else {
Richard Smitha4ba74c2013-08-30 04:46:40 +0000572 ASTContext &Ctx = getASTContext();
573 ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);
574 NamedDecl *Primary =
575 FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion);
576 if (Primary->getPreviousDecl())
577 Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),
578 Primary, AS);
Douglas Gregor457104e2010-09-29 04:25:11 +0000579 else
Richard Smitha4ba74c2013-08-30 04:46:40 +0000580 Conversions.addDecl(Ctx, Primary, AS);
Douglas Gregor457104e2010-09-29 04:25:11 +0000581 }
582 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000583
Richard Smith328aae52012-11-30 05:11:39 +0000584 if (SMKind) {
Richard Smith92f241f2012-12-08 02:53:02 +0000585 // If this is the first declaration of a special member, we no longer have
586 // an implicit trivial special member.
587 data().HasTrivialSpecialMembers &=
588 data().DeclaredSpecialMembers | ~SMKind;
589
590 if (!Method->isImplicit() && !Method->isUserProvided()) {
591 // This method is user-declared but not user-provided. We can't work out
592 // whether it's trivial yet (not until we get to the end of the class).
593 // We'll handle this method in finishedDefaultedOrDeletedMember.
594 } else if (Method->isTrivial())
595 data().HasTrivialSpecialMembers |= SMKind;
596 else
597 data().DeclaredNonTrivialSpecialMembers |= SMKind;
598
Richard Smith328aae52012-11-30 05:11:39 +0000599 // Note when we have declared a declared special member, and suppress the
600 // implicit declaration of this special member.
601 data().DeclaredSpecialMembers |= SMKind;
602
603 if (!Method->isImplicit()) {
604 data().UserDeclaredSpecialMembers |= SMKind;
605
606 // C++03 [class]p4:
607 // A POD-struct is an aggregate class that has [...] no user-defined
608 // copy assignment operator and no user-defined destructor.
609 //
610 // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
611 // aggregates could not have any constructors, clear it even for an
612 // explicitly defaulted or deleted constructor.
613 // type is technically an aggregate in C++0x since it wouldn't be in 03.
614 //
615 // Also, a user-declared move assignment operator makes a class non-POD.
616 // This is an extension in C++03.
617 data().PlainOldData = false;
618 }
Richard Smith328aae52012-11-30 05:11:39 +0000619 }
620
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000621 return;
Douglas Gregor8a273912009-07-22 18:25:24 +0000622 }
Richard Smith328aae52012-11-30 05:11:39 +0000623
Douglas Gregora832d3e2010-09-28 19:45:33 +0000624 // Handle non-static data members.
625 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
Douglas Gregor556e5862011-10-10 17:22:13 +0000626 // C++ [class.bit]p2:
627 // A declaration for a bit-field that omits the identifier declares an
628 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
629 // initialized.
630 if (Field->isUnnamedBitfield())
631 return;
632
Douglas Gregora832d3e2010-09-28 19:45:33 +0000633 // C++ [dcl.init.aggr]p1:
634 // An aggregate is an array or a class (clause 9) with [...] no
635 // private or protected non-static data members (clause 11).
636 //
637 // A POD must be an aggregate.
638 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
639 data().Aggregate = false;
640 data().PlainOldData = false;
641 }
Chandler Carruthb1963742011-04-30 09:17:45 +0000642
643 // C++0x [class]p7:
644 // A standard-layout class is a class that:
645 // [...]
646 // -- has the same access control for all non-static data members,
647 switch (D->getAccess()) {
648 case AS_private: data().HasPrivateFields = true; break;
649 case AS_protected: data().HasProtectedFields = true; break;
650 case AS_public: data().HasPublicFields = true; break;
David Blaikie83d382b2011-09-23 05:06:16 +0000651 case AS_none: llvm_unreachable("Invalid access specifier");
Chandler Carruthb1963742011-04-30 09:17:45 +0000652 };
653 if ((data().HasPrivateFields + data().HasProtectedFields +
654 data().HasPublicFields) > 1)
Chandler Carruth583edf82011-04-30 10:07:30 +0000655 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000656
Douglas Gregor61226d32011-05-13 01:05:07 +0000657 // Keep track of the presence of mutable fields.
658 if (Field->isMutable())
659 data().HasMutableFields = true;
Richard Smithab44d5b2013-12-10 08:25:00 +0000660
661 // C++11 [class.union]p8, DR1460:
662 // If X is a union, a non-static data member of X that is not an anonymous
663 // union is a variant member of X.
664 if (isUnion() && !Field->isAnonymousStructOrUnion())
665 data().HasVariantMembers = true;
666
Chandler Carruthad7d4042011-04-23 23:10:33 +0000667 // C++0x [class]p9:
Douglas Gregora832d3e2010-09-28 19:45:33 +0000668 // A POD struct is a class that is both a trivial class and a
669 // standard-layout class, and has no non-static data members of type
670 // non-POD struct, non-POD union (or array of such types).
John McCall31168b02011-06-15 23:02:42 +0000671 //
672 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
673 // that does not explicitly have no lifetime makes the class a non-POD.
Douglas Gregora832d3e2010-09-28 19:45:33 +0000674 ASTContext &Context = getASTContext();
675 QualType T = Context.getBaseElementType(Field->getType());
John McCall31168b02011-06-15 23:02:42 +0000676 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
Ben Langmuir11eab612014-09-26 15:27:29 +0000677 if (!Context.getLangOpts().ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +0000678 setHasObjectMember(true);
Ben Langmuir11eab612014-09-26 15:27:29 +0000679 } else if (T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
680 // Objective-C Automatic Reference Counting:
681 // If a class has a non-static data member of Objective-C pointer
682 // type (or array thereof), it is a non-POD type and its
683 // default constructor (if any), copy constructor, move constructor,
684 // copy assignment operator, move assignment operator, and destructor are
685 // non-trivial.
686 setHasObjectMember(true);
687 struct DefinitionData &Data = data();
688 Data.PlainOldData = false;
689 Data.HasTrivialSpecialMembers = 0;
690 Data.HasIrrelevantDestructor = false;
691 }
Eli Friedmana5433322013-07-20 01:06:31 +0000692 } else if (!T.isCXX98PODType(Context))
Douglas Gregora832d3e2010-09-28 19:45:33 +0000693 data().PlainOldData = false;
John McCall31168b02011-06-15 23:02:42 +0000694
Chandler Carruthb1963742011-04-30 09:17:45 +0000695 if (T->isReferenceType()) {
Richard Smith593f9932012-12-08 02:01:17 +0000696 if (!Field->hasInClassInitializer())
697 data().HasUninitializedReferenceMember = true;
Chandler Carruthe71d0622011-04-24 02:49:34 +0000698
Chandler Carruthb1963742011-04-30 09:17:45 +0000699 // C++0x [class]p7:
700 // A standard-layout class is a class that:
701 // -- has no non-static data members of type [...] reference,
Chandler Carruth583edf82011-04-30 10:07:30 +0000702 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000703 }
704
Richard Smith3607ffe2012-02-13 03:54:03 +0000705 // Record if this field is the first non-literal or volatile field or base.
Richard Smithd9f663b2013-04-22 15:31:51 +0000706 if (!T->isLiteralType(Context) || T.isVolatileQualified())
Chandler Carruthe71d0622011-04-24 02:49:34 +0000707 data().HasNonLiteralTypeFieldsOrBases = true;
708
Richard Smithab44d5b2013-12-10 08:25:00 +0000709 if (Field->hasInClassInitializer() ||
710 (Field->isAnonymousStructOrUnion() &&
711 Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
Richard Smithe2648ba2012-05-07 01:07:30 +0000712 data().HasInClassInitializer = true;
713
714 // C++11 [class]p5:
Richard Smith938f40b2011-06-11 17:19:42 +0000715 // A default constructor is trivial if [...] no non-static data member
716 // of its class has a brace-or-equal-initializer.
Richard Smith328aae52012-11-30 05:11:39 +0000717 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
Richard Smith938f40b2011-06-11 17:19:42 +0000718
Richard Smithe2648ba2012-05-07 01:07:30 +0000719 // C++11 [dcl.init.aggr]p1:
Richard Smith938f40b2011-06-11 17:19:42 +0000720 // An aggregate is a [...] class with [...] no
721 // brace-or-equal-initializers for non-static data members.
Richard Smith852c9db2013-04-20 22:23:05 +0000722 //
723 // This rule was removed in C++1y.
Aaron Ballmandd69ef32014-08-19 15:55:55 +0000724 if (!getASTContext().getLangOpts().CPlusPlus14)
Richard Smith852c9db2013-04-20 22:23:05 +0000725 data().Aggregate = false;
Richard Smith938f40b2011-06-11 17:19:42 +0000726
Richard Smithe2648ba2012-05-07 01:07:30 +0000727 // C++11 [class]p10:
Richard Smith938f40b2011-06-11 17:19:42 +0000728 // A POD struct is [...] a trivial class.
729 data().PlainOldData = false;
730 }
731
Richard Smith6b02d462012-12-08 08:32:28 +0000732 // C++11 [class.copy]p23:
733 // A defaulted copy/move assignment operator for a class X is defined
734 // as deleted if X has:
735 // -- a non-static data member of reference type
736 if (T->isReferenceType())
737 data().DefaultedMoveAssignmentIsDeleted = true;
738
Douglas Gregor11c024b2010-09-28 20:50:54 +0000739 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
740 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
741 if (FieldRec->getDefinition()) {
Richard Smith6b02d462012-12-08 08:32:28 +0000742 addedClassSubobject(FieldRec);
743
Richard Smithc91d12c2013-11-25 07:07:05 +0000744 // We may need to perform overload resolution to determine whether a
745 // field can be moved if it's const or volatile qualified.
746 if (T.getCVRQualifiers() & (Qualifiers::Const | Qualifiers::Volatile)) {
747 data().NeedOverloadResolutionForMoveConstructor = true;
748 data().NeedOverloadResolutionForMoveAssignment = true;
749 }
750
Richard Smith6b02d462012-12-08 08:32:28 +0000751 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
752 // A defaulted [special member] for a class X is defined as
753 // deleted if:
754 // -- X is a union-like class that has a variant member with a
755 // non-trivial [corresponding special member]
756 if (isUnion()) {
757 if (FieldRec->hasNonTrivialMoveConstructor())
758 data().DefaultedMoveConstructorIsDeleted = true;
759 if (FieldRec->hasNonTrivialMoveAssignment())
760 data().DefaultedMoveAssignmentIsDeleted = true;
761 if (FieldRec->hasNonTrivialDestructor())
762 data().DefaultedDestructorIsDeleted = true;
763 }
764
Alexis Huntf479f1b2011-05-09 18:22:59 +0000765 // C++0x [class.ctor]p5:
Richard Smithcc36f692011-12-22 02:22:31 +0000766 // A default constructor is trivial [...] if:
Alexis Huntf479f1b2011-05-09 18:22:59 +0000767 // -- for all the non-static data members of its class that are of
768 // class type (or array thereof), each such class has a trivial
769 // default constructor.
770 if (!FieldRec->hasTrivialDefaultConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000771 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000772
773 // C++0x [class.copy]p13:
774 // A copy/move constructor for class X is trivial if [...]
775 // [...]
776 // -- for each non-static data member of X that is of class type (or
777 // an array thereof), the constructor selected to copy/move that
778 // member is trivial;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000779 if (!FieldRec->hasTrivialCopyConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000780 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
Richard Smith6b02d462012-12-08 08:32:28 +0000781 // If the field doesn't have a simple move constructor, we'll eagerly
782 // declare the move constructor for this class and we'll decide whether
783 // it's trivial then.
Richard Smith16488472012-11-16 00:53:38 +0000784 if (!FieldRec->hasTrivialMoveConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000785 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000786
787 // C++0x [class.copy]p27:
788 // A copy/move assignment operator for class X is trivial if [...]
789 // [...]
790 // -- for each non-static data member of X that is of class type (or
791 // an array thereof), the assignment operator selected to
792 // copy/move that member is trivial;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000793 if (!FieldRec->hasTrivialCopyAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000794 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
Richard Smith6b02d462012-12-08 08:32:28 +0000795 // If the field doesn't have a simple move assignment, we'll eagerly
796 // declare the move assignment for this class and we'll decide whether
797 // it's trivial then.
Richard Smith16488472012-11-16 00:53:38 +0000798 if (!FieldRec->hasTrivialMoveAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000799 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000800
Douglas Gregor11c024b2010-09-28 20:50:54 +0000801 if (!FieldRec->hasTrivialDestructor())
Richard Smith328aae52012-11-30 05:11:39 +0000802 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000803 if (!FieldRec->hasIrrelevantDestructor())
804 data().HasIrrelevantDestructor = false;
John McCall31168b02011-06-15 23:02:42 +0000805 if (FieldRec->hasObjectMember())
806 setHasObjectMember(true);
Fariborz Jahanian78652202013-01-25 23:57:05 +0000807 if (FieldRec->hasVolatileMember())
808 setHasVolatileMember(true);
Chandler Carruthb1963742011-04-30 09:17:45 +0000809
810 // C++0x [class]p7:
811 // A standard-layout class is a class that:
812 // -- has no non-static data members of type non-standard-layout
813 // class (or array of such types) [...]
Chandler Carruth583edf82011-04-30 10:07:30 +0000814 if (!FieldRec->isStandardLayout())
815 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000816
817 // C++0x [class]p7:
818 // A standard-layout class is a class that:
819 // [...]
820 // -- has no base classes of the same type as the first non-static
821 // data member.
822 // We don't want to expend bits in the state of the record decl
823 // tracking whether this is the first non-static data member so we
824 // cheat a bit and use some of the existing state: the empty bit.
825 // Virtual bases and virtual methods make a class non-empty, but they
826 // also make it non-standard-layout so we needn't check here.
827 // A non-empty base class may leave the class standard-layout, but not
Richard Smithab44d5b2013-12-10 08:25:00 +0000828 // if we have arrived here, and have at least one non-static data
Chandler Carruth583edf82011-04-30 10:07:30 +0000829 // member. If IsStandardLayout remains true, then the first non-static
Chandler Carruthb1963742011-04-30 09:17:45 +0000830 // data member must come through here with Empty still true, and Empty
831 // will subsequently be set to false below.
Chandler Carruth583edf82011-04-30 10:07:30 +0000832 if (data().IsStandardLayout && data().Empty) {
Aaron Ballman574705e2014-03-13 15:41:46 +0000833 for (const auto &BI : bases()) {
834 if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
Chandler Carruth583edf82011-04-30 10:07:30 +0000835 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000836 break;
837 }
838 }
839 }
Douglas Gregor61226d32011-05-13 01:05:07 +0000840
841 // Keep track of the presence of mutable fields.
842 if (FieldRec->hasMutableFields())
843 data().HasMutableFields = true;
Richard Smithcc36f692011-12-22 02:22:31 +0000844
845 // C++11 [class.copy]p13:
846 // If the implicitly-defined constructor would satisfy the
847 // requirements of a constexpr constructor, the implicitly-defined
848 // constructor is constexpr.
849 // C++11 [dcl.constexpr]p4:
850 // -- every constructor involved in initializing non-static data
851 // members [...] shall be a constexpr constructor
852 if (!Field->hasInClassInitializer() &&
Richard Smithe2648ba2012-05-07 01:07:30 +0000853 !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
Richard Smithcc36f692011-12-22 02:22:31 +0000854 // The standard requires any in-class initializer to be a constant
855 // expression. We consider this to be a defect.
856 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smith1c33fe82012-11-28 06:23:12 +0000857
858 // C++11 [class.copy]p8:
859 // The implicitly-declared copy constructor for a class X will have
860 // the form 'X::X(const X&)' if [...] for all the non-static data
861 // members of X that are of a class type M (or array thereof), each
862 // such class type has a copy constructor whose first parameter is
863 // of type 'const M&' or 'const volatile M&'.
864 if (!FieldRec->hasCopyConstructorWithConstParam())
865 data().ImplicitCopyConstructorHasConstParam = false;
866
867 // C++11 [class.copy]p18:
868 // The implicitly-declared copy assignment oeprator for a class X will
869 // have the form 'X& X::operator=(const X&)' if [...] for all the
870 // non-static data members of X that are of a class type M (or array
871 // thereof), each such class type has a copy assignment operator whose
872 // parameter is of type 'const M&', 'const volatile M&' or 'M'.
873 if (!FieldRec->hasCopyAssignmentWithConstParam())
874 data().ImplicitCopyAssignmentHasConstParam = false;
Richard Smith593f9932012-12-08 02:01:17 +0000875
876 if (FieldRec->hasUninitializedReferenceMember() &&
877 !Field->hasInClassInitializer())
878 data().HasUninitializedReferenceMember = true;
Richard Smithab44d5b2013-12-10 08:25:00 +0000879
880 // C++11 [class.union]p8, DR1460:
881 // a non-static data member of an anonymous union that is a member of
882 // X is also a variant member of X.
883 if (FieldRec->hasVariantMembers() &&
884 Field->isAnonymousStructOrUnion())
885 data().HasVariantMembers = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000886 }
Richard Smithcc36f692011-12-22 02:22:31 +0000887 } else {
888 // Base element type of field is a non-class type.
Richard Smithd9f663b2013-04-22 15:31:51 +0000889 if (!T->isLiteralType(Context) ||
Richard Smith4086a132012-06-10 07:07:24 +0000890 (!Field->hasInClassInitializer() && !isUnion()))
Richard Smithcc36f692011-12-22 02:22:31 +0000891 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smith6b02d462012-12-08 08:32:28 +0000892
893 // C++11 [class.copy]p23:
894 // A defaulted copy/move assignment operator for a class X is defined
895 // as deleted if X has:
896 // -- a non-static data member of const non-class type (or array
897 // thereof)
898 if (T.isConstQualified())
899 data().DefaultedMoveAssignmentIsDeleted = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000900 }
Chandler Carruthb1963742011-04-30 09:17:45 +0000901
902 // C++0x [class]p7:
903 // A standard-layout class is a class that:
904 // [...]
905 // -- either has no non-static data members in the most derived
906 // class and at most one base class with non-static data members,
907 // or has no base classes with non-static data members, and
908 // At this point we know that we have a non-static data member, so the last
909 // clause holds.
910 if (!data().HasNoNonEmptyBases)
Chandler Carruth583edf82011-04-30 10:07:30 +0000911 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000912
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000913 // If this is not a zero-length bit-field, then the class is not empty.
914 if (data().Empty) {
Richard Smithcaf33902011-10-10 18:28:20 +0000915 if (!Field->isBitField() ||
916 (!Field->getBitWidth()->isTypeDependent() &&
917 !Field->getBitWidth()->isValueDependent() &&
918 Field->getBitWidthValue(Context) != 0))
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000919 data().Empty = false;
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000920 }
Douglas Gregora832d3e2010-09-28 19:45:33 +0000921 }
Douglas Gregor457104e2010-09-29 04:25:11 +0000922
923 // Handle using declarations of conversion functions.
Richard Smitha4ba74c2013-08-30 04:46:40 +0000924 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) {
Douglas Gregor457104e2010-09-29 04:25:11 +0000925 if (Shadow->getDeclName().getNameKind()
Richard Smitha4ba74c2013-08-30 04:46:40 +0000926 == DeclarationName::CXXConversionFunctionName) {
927 ASTContext &Ctx = getASTContext();
928 data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
929 }
930 }
Joao Matose9a3ed42012-08-31 22:18:20 +0000931}
932
Richard Smith92f241f2012-12-08 02:53:02 +0000933void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
934 assert(!D->isImplicit() && !D->isUserProvided());
935
936 // The kind of special member this declaration is, if any.
937 unsigned SMKind = 0;
938
939 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
940 if (Constructor->isDefaultConstructor()) {
941 SMKind |= SMF_DefaultConstructor;
942 if (Constructor->isConstexpr())
943 data().HasConstexprDefaultConstructor = true;
944 }
945 if (Constructor->isCopyConstructor())
946 SMKind |= SMF_CopyConstructor;
947 else if (Constructor->isMoveConstructor())
948 SMKind |= SMF_MoveConstructor;
949 else if (Constructor->isConstexpr())
950 // We may now know that the constructor is constexpr.
951 data().HasConstexprNonCopyMoveConstructor = true;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000952 } else if (isa<CXXDestructorDecl>(D)) {
Richard Smith92f241f2012-12-08 02:53:02 +0000953 SMKind |= SMF_Destructor;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000954 if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
955 data().HasIrrelevantDestructor = false;
956 } else if (D->isCopyAssignmentOperator())
Richard Smith92f241f2012-12-08 02:53:02 +0000957 SMKind |= SMF_CopyAssignment;
958 else if (D->isMoveAssignmentOperator())
959 SMKind |= SMF_MoveAssignment;
960
961 // Update which trivial / non-trivial special members we have.
962 // addedMember will have skipped this step for this member.
963 if (D->isTrivial())
964 data().HasTrivialSpecialMembers |= SMKind;
965 else
966 data().DeclaredNonTrivialSpecialMembers |= SMKind;
967}
968
Joao Matose9a3ed42012-08-31 22:18:20 +0000969bool CXXRecordDecl::isCLike() const {
970 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
971 !TemplateOrInstantiation.isNull())
972 return false;
973 if (!hasDefinition())
974 return true;
Argyrios Kyrtzidis5c4e0652012-01-23 16:58:45 +0000975
Argyrios Kyrtzidisc3c9ee52012-02-01 06:36:44 +0000976 return isPOD() && data().HasOnlyCMembers;
Argyrios Kyrtzidis5c4e0652012-01-23 16:58:45 +0000977}
Faisal Valic1a6dc42013-10-23 16:10:50 +0000978
Faisal Vali2b391ab2013-09-26 19:54:12 +0000979bool CXXRecordDecl::isGenericLambda() const {
Faisal Valic1a6dc42013-10-23 16:10:50 +0000980 if (!isLambda()) return false;
981 return getLambdaData().IsGenericLambda;
Faisal Vali2b391ab2013-09-26 19:54:12 +0000982}
983
984CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const {
Craig Topper36250ad2014-05-12 05:36:57 +0000985 if (!isLambda()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +0000986 DeclarationName Name =
987 getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
Richard Smithcf4bdde2015-02-21 02:45:19 +0000988 DeclContext::lookup_result Calls = lookup(Name);
Faisal Vali850da1a2013-09-29 17:08:32 +0000989
990 assert(!Calls.empty() && "Missing lambda call operator!");
991 assert(Calls.size() == 1 && "More than one lambda call operator!");
992
993 NamedDecl *CallOp = Calls.front();
994 if (FunctionTemplateDecl *CallOpTmpl =
995 dyn_cast<FunctionTemplateDecl>(CallOp))
996 return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
Faisal Vali2b391ab2013-09-26 19:54:12 +0000997
998 return cast<CXXMethodDecl>(CallOp);
999}
1000
1001CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001002 if (!isLambda()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +00001003 DeclarationName Name =
1004 &getASTContext().Idents.get(getLambdaStaticInvokerName());
Richard Smithcf4bdde2015-02-21 02:45:19 +00001005 DeclContext::lookup_result Invoker = lookup(Name);
Craig Topper36250ad2014-05-12 05:36:57 +00001006 if (Invoker.empty()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +00001007 assert(Invoker.size() == 1 && "More than one static invoker operator!");
1008 NamedDecl *InvokerFun = Invoker.front();
1009 if (FunctionTemplateDecl *InvokerTemplate =
1010 dyn_cast<FunctionTemplateDecl>(InvokerFun))
1011 return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
1012
Faisal Vali571df122013-09-29 08:45:24 +00001013 return cast<CXXMethodDecl>(InvokerFun);
Faisal Vali2b391ab2013-09-26 19:54:12 +00001014}
1015
Douglas Gregor9c702202012-02-10 07:45:31 +00001016void CXXRecordDecl::getCaptureFields(
1017 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
Eli Friedman7e7da2d2012-02-11 00:18:00 +00001018 FieldDecl *&ThisCapture) const {
Douglas Gregor9c702202012-02-10 07:45:31 +00001019 Captures.clear();
Craig Topper36250ad2014-05-12 05:36:57 +00001020 ThisCapture = nullptr;
Douglas Gregor9c702202012-02-10 07:45:31 +00001021
Douglas Gregorc8a73492012-02-13 15:44:47 +00001022 LambdaDefinitionData &Lambda = getLambdaData();
Douglas Gregor9c702202012-02-10 07:45:31 +00001023 RecordDecl::field_iterator Field = field_begin();
Benjamin Kramerf3ca26982014-05-10 16:31:55 +00001024 for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
Douglas Gregor9c702202012-02-10 07:45:31 +00001025 C != CEnd; ++C, ++Field) {
Richard Smithba71c082013-05-16 06:20:58 +00001026 if (C->capturesThis())
David Blaikie40ed2972012-06-06 20:45:41 +00001027 ThisCapture = *Field;
Richard Smithba71c082013-05-16 06:20:58 +00001028 else if (C->capturesVariable())
1029 Captures[C->getCapturedVar()] = *Field;
Douglas Gregor9c702202012-02-10 07:45:31 +00001030 }
Richard Smithbb13c9a2013-09-28 04:02:39 +00001031 assert(Field == field_end());
Douglas Gregor9c702202012-02-10 07:45:31 +00001032}
1033
Faisal Vali2b391ab2013-09-26 19:54:12 +00001034TemplateParameterList *
1035CXXRecordDecl::getGenericLambdaTemplateParameterList() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001036 if (!isLambda()) return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001037 CXXMethodDecl *CallOp = getLambdaCallOperator();
1038 if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate())
1039 return Tmpl->getTemplateParameters();
Craig Topper36250ad2014-05-12 05:36:57 +00001040 return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001041}
Douglas Gregor9c702202012-02-10 07:45:31 +00001042
John McCall1e3a1a72010-03-15 09:07:48 +00001043static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
Alp Tokera2794f92014-01-22 07:29:52 +00001044 QualType T =
1045 cast<CXXConversionDecl>(Conv->getUnderlyingDecl()->getAsFunction())
1046 ->getConversionType();
John McCall1e3a1a72010-03-15 09:07:48 +00001047 return Context.getCanonicalType(T);
Fariborz Jahanian3ee21f12009-10-07 20:43:36 +00001048}
1049
John McCall1e3a1a72010-03-15 09:07:48 +00001050/// Collect the visible conversions of a base class.
1051///
James Dennettb5d5f812012-06-15 22:28:09 +00001052/// \param Record a base class of the class we're considering
John McCall1e3a1a72010-03-15 09:07:48 +00001053/// \param InVirtual whether this base class is a virtual base (or a base
1054/// of a virtual base)
1055/// \param Access the access along the inheritance path to this base
1056/// \param ParentHiddenTypes the conversions provided by the inheritors
1057/// of this base
1058/// \param Output the set to which to add conversions from non-virtual bases
1059/// \param VOutput the set to which to add conversions from virtual bases
1060/// \param HiddenVBaseCs the set of conversions which were hidden in a
1061/// virtual base along some inheritance path
1062static void CollectVisibleConversions(ASTContext &Context,
1063 CXXRecordDecl *Record,
1064 bool InVirtual,
1065 AccessSpecifier Access,
1066 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001067 ASTUnresolvedSet &Output,
John McCall1e3a1a72010-03-15 09:07:48 +00001068 UnresolvedSetImpl &VOutput,
1069 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
1070 // The set of types which have conversions in this class or its
1071 // subclasses. As an optimization, we don't copy the derived set
1072 // unless it might change.
1073 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
1074 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
1075
1076 // Collect the direct conversions and figure out which conversions
1077 // will be hidden in the subclasses.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001078 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1079 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1080 if (ConvI != ConvE) {
John McCall1e3a1a72010-03-15 09:07:48 +00001081 HiddenTypesBuffer = ParentHiddenTypes;
1082 HiddenTypes = &HiddenTypesBuffer;
1083
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001084 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
Richard Smith99fdf8d2012-05-06 00:04:32 +00001085 CanQualType ConvType(GetConversionType(Context, I.getDecl()));
1086 bool Hidden = ParentHiddenTypes.count(ConvType);
1087 if (!Hidden)
1088 HiddenTypesBuffer.insert(ConvType);
John McCall1e3a1a72010-03-15 09:07:48 +00001089
1090 // If this conversion is hidden and we're in a virtual base,
1091 // remember that it's hidden along some inheritance path.
1092 if (Hidden && InVirtual)
1093 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1094
1095 // If this conversion isn't hidden, add it to the appropriate output.
1096 else if (!Hidden) {
1097 AccessSpecifier IAccess
1098 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1099
1100 if (InVirtual)
1101 VOutput.addDecl(I.getDecl(), IAccess);
Fariborz Jahanianb394f502009-09-12 18:26:03 +00001102 else
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001103 Output.addDecl(Context, I.getDecl(), IAccess);
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001104 }
1105 }
1106 }
Sebastian Redl1054fae2009-10-25 17:03:50 +00001107
John McCall1e3a1a72010-03-15 09:07:48 +00001108 // Collect information recursively from any base classes.
Aaron Ballman574705e2014-03-13 15:41:46 +00001109 for (const auto &I : Record->bases()) {
1110 const RecordType *RT = I.getType()->getAs<RecordType>();
John McCall1e3a1a72010-03-15 09:07:48 +00001111 if (!RT) continue;
Sebastian Redl1054fae2009-10-25 17:03:50 +00001112
John McCall1e3a1a72010-03-15 09:07:48 +00001113 AccessSpecifier BaseAccess
Aaron Ballman574705e2014-03-13 15:41:46 +00001114 = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
1115 bool BaseInVirtual = InVirtual || I.isVirtual();
Sebastian Redl1054fae2009-10-25 17:03:50 +00001116
John McCall1e3a1a72010-03-15 09:07:48 +00001117 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1118 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1119 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001120 }
John McCall1e3a1a72010-03-15 09:07:48 +00001121}
Sebastian Redl1054fae2009-10-25 17:03:50 +00001122
John McCall1e3a1a72010-03-15 09:07:48 +00001123/// Collect the visible conversions of a class.
1124///
1125/// This would be extremely straightforward if it weren't for virtual
1126/// bases. It might be worth special-casing that, really.
1127static void CollectVisibleConversions(ASTContext &Context,
1128 CXXRecordDecl *Record,
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001129 ASTUnresolvedSet &Output) {
John McCall1e3a1a72010-03-15 09:07:48 +00001130 // The collection of all conversions in virtual bases that we've
1131 // found. These will be added to the output as long as they don't
1132 // appear in the hidden-conversions set.
1133 UnresolvedSet<8> VBaseCs;
1134
1135 // The set of conversions in virtual bases that we've determined to
1136 // be hidden.
1137 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1138
1139 // The set of types hidden by classes derived from this one.
1140 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1141
1142 // Go ahead and collect the direct conversions and add them to the
1143 // hidden-types set.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001144 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1145 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001146 Output.append(Context, ConvI, ConvE);
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001147 for (; ConvI != ConvE; ++ConvI)
1148 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
John McCall1e3a1a72010-03-15 09:07:48 +00001149
1150 // Recursively collect conversions from base classes.
Aaron Ballman574705e2014-03-13 15:41:46 +00001151 for (const auto &I : Record->bases()) {
1152 const RecordType *RT = I.getType()->getAs<RecordType>();
John McCall1e3a1a72010-03-15 09:07:48 +00001153 if (!RT) continue;
1154
1155 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
Aaron Ballman574705e2014-03-13 15:41:46 +00001156 I.isVirtual(), I.getAccessSpecifier(),
John McCall1e3a1a72010-03-15 09:07:48 +00001157 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1158 }
1159
1160 // Add any unhidden conversions provided by virtual bases.
1161 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1162 I != E; ++I) {
1163 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001164 Output.addDecl(Context, I.getDecl(), I.getAccess());
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001165 }
Fariborz Jahanianb394f502009-09-12 18:26:03 +00001166}
1167
1168/// getVisibleConversionFunctions - get all conversion functions visible
1169/// in current class; including conversion function templates.
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00001170llvm::iterator_range<CXXRecordDecl::conversion_iterator>
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001171CXXRecordDecl::getVisibleConversionFunctions() {
Richard Smitha4ba74c2013-08-30 04:46:40 +00001172 ASTContext &Ctx = getASTContext();
1173
1174 ASTUnresolvedSet *Set;
1175 if (bases_begin() == bases_end()) {
1176 // If root class, all conversions are visible.
1177 Set = &data().Conversions.get(Ctx);
1178 } else {
1179 Set = &data().VisibleConversions.get(Ctx);
1180 // If visible conversion list is not evaluated, evaluate it.
1181 if (!data().ComputedVisibleConversions) {
1182 CollectVisibleConversions(Ctx, this, *Set);
1183 data().ComputedVisibleConversions = true;
1184 }
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001185 }
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00001186 return llvm::make_range(Set->begin(), Set->end());
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001187}
1188
John McCallda4458e2010-03-31 01:36:47 +00001189void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1190 // This operation is O(N) but extremely rare. Sema only uses it to
1191 // remove UsingShadowDecls in a class that were followed by a direct
1192 // declaration, e.g.:
1193 // class A : B {
1194 // using B::operator int;
1195 // operator int();
1196 // };
1197 // This is uncommon by itself and even more uncommon in conjunction
1198 // with sufficiently large numbers of directly-declared conversions
1199 // that asymptotic behavior matters.
1200
Richard Smitha4ba74c2013-08-30 04:46:40 +00001201 ASTUnresolvedSet &Convs = data().Conversions.get(getASTContext());
John McCallda4458e2010-03-31 01:36:47 +00001202 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1203 if (Convs[I].getDecl() == ConvDecl) {
1204 Convs.erase(I);
1205 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1206 && "conversion was found multiple times in unresolved set");
1207 return;
1208 }
1209 }
1210
1211 llvm_unreachable("conversion not found in set!");
Douglas Gregor05155d82009-08-21 23:19:43 +00001212}
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00001213
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001214CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
Douglas Gregor06db9f52009-10-12 20:18:28 +00001215 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001216 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
Craig Topper36250ad2014-05-12 05:36:57 +00001217
1218 return nullptr;
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001219}
1220
1221void
1222CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1223 TemplateSpecializationKind TSK) {
1224 assert(TemplateOrInstantiation.isNull() &&
1225 "Previous template or instantiation?");
Richard Smith8a0dde72013-12-14 01:04:22 +00001226 assert(!isa<ClassTemplatePartialSpecializationDecl>(this));
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001227 TemplateOrInstantiation
1228 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1229}
1230
Anders Carlsson27cfc6e2009-12-07 06:33:48 +00001231TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1232 if (const ClassTemplateSpecializationDecl *Spec
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001233 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1234 return Spec->getSpecializationKind();
1235
Douglas Gregor06db9f52009-10-12 20:18:28 +00001236 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001237 return MSInfo->getTemplateSpecializationKind();
1238
1239 return TSK_Undeclared;
1240}
1241
1242void
1243CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1244 if (ClassTemplateSpecializationDecl *Spec
1245 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1246 Spec->setSpecializationKind(TSK);
1247 return;
1248 }
1249
Douglas Gregor06db9f52009-10-12 20:18:28 +00001250 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001251 MSInfo->setTemplateSpecializationKind(TSK);
1252 return;
1253 }
1254
David Blaikie83d382b2011-09-23 05:06:16 +00001255 llvm_unreachable("Not a class template or member class specialization");
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001256}
1257
Reid Klecknere7367d62014-10-14 20:28:40 +00001258const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {
1259 // If it's a class template specialization, find the template or partial
1260 // specialization from which it was instantiated.
1261 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1262 auto From = TD->getInstantiatedFrom();
1263 if (auto *CTD = From.dyn_cast<ClassTemplateDecl *>()) {
1264 while (auto *NewCTD = CTD->getInstantiatedFromMemberTemplate()) {
1265 if (NewCTD->isMemberSpecialization())
1266 break;
1267 CTD = NewCTD;
1268 }
Richard Smith7a591a42015-07-08 02:22:15 +00001269 return CTD->getTemplatedDecl()->getDefinition();
Reid Klecknere7367d62014-10-14 20:28:40 +00001270 }
1271 if (auto *CTPSD =
1272 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
1273 while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) {
1274 if (NewCTPSD->isMemberSpecialization())
1275 break;
1276 CTPSD = NewCTPSD;
1277 }
Richard Smith7a591a42015-07-08 02:22:15 +00001278 return CTPSD->getDefinition();
Reid Klecknere7367d62014-10-14 20:28:40 +00001279 }
1280 }
1281
1282 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1283 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
1284 const CXXRecordDecl *RD = this;
1285 while (auto *NewRD = RD->getInstantiatedFromMemberClass())
1286 RD = NewRD;
Richard Smith7a591a42015-07-08 02:22:15 +00001287 return RD->getDefinition();
Reid Klecknere7367d62014-10-14 20:28:40 +00001288 }
1289 }
1290
1291 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) &&
1292 "couldn't find pattern for class template instantiation");
1293 return nullptr;
1294}
1295
Douglas Gregorbac74902010-07-01 14:13:13 +00001296CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1297 ASTContext &Context = getASTContext();
Anders Carlsson0a637412009-05-29 21:03:38 +00001298 QualType ClassType = Context.getTypeDeclType(this);
Mike Stump11289f42009-09-09 15:08:12 +00001299
1300 DeclarationName Name
Douglas Gregor2211d342009-08-05 05:36:45 +00001301 = Context.DeclarationNames.getCXXDestructorName(
1302 Context.getCanonicalType(ClassType));
Anders Carlsson0a637412009-05-29 21:03:38 +00001303
Richard Smithcf4bdde2015-02-21 02:45:19 +00001304 DeclContext::lookup_result R = lookup(Name);
David Blaikieff7d47a2012-12-19 00:45:41 +00001305 if (R.empty())
Craig Topper36250ad2014-05-12 05:36:57 +00001306 return nullptr;
Mike Stump11289f42009-09-09 15:08:12 +00001307
David Blaikieff7d47a2012-12-19 00:45:41 +00001308 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(R.front());
Anders Carlsson0a637412009-05-29 21:03:38 +00001309 return Dtor;
1310}
1311
Richard Trieu95a192a2015-05-28 00:14:02 +00001312bool CXXRecordDecl::isAnyDestructorNoReturn() const {
1313 // Destructor is noreturn.
1314 if (const CXXDestructorDecl *Destructor = getDestructor())
1315 if (Destructor->isNoReturn())
1316 return true;
1317
1318 // Check base classes destructor for noreturn.
1319 for (const auto &Base : bases())
1320 if (Base.getType()->getAsCXXRecordDecl()->isAnyDestructorNoReturn())
1321 return true;
1322
1323 // Check fields for noreturn.
1324 for (const auto *Field : fields())
1325 if (const CXXRecordDecl *RD =
1326 Field->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl())
1327 if (RD->isAnyDestructorNoReturn())
1328 return true;
1329
1330 // All destructors are not noreturn.
1331 return false;
1332}
1333
Douglas Gregorb11aad82011-02-19 18:51:44 +00001334void CXXRecordDecl::completeDefinition() {
Craig Topper36250ad2014-05-12 05:36:57 +00001335 completeDefinition(nullptr);
Douglas Gregorb11aad82011-02-19 18:51:44 +00001336}
1337
1338void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1339 RecordDecl::completeDefinition();
1340
Douglas Gregor8fb95122010-09-29 00:15:42 +00001341 // If the class may be abstract (but hasn't been marked as such), check for
1342 // any pure final overriders.
1343 if (mayBeAbstract()) {
1344 CXXFinalOverriderMap MyFinalOverriders;
1345 if (!FinalOverriders) {
1346 getFinalOverriders(MyFinalOverriders);
1347 FinalOverriders = &MyFinalOverriders;
1348 }
1349
1350 bool Done = false;
1351 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1352 MEnd = FinalOverriders->end();
1353 M != MEnd && !Done; ++M) {
1354 for (OverridingMethods::iterator SO = M->second.begin(),
1355 SOEnd = M->second.end();
1356 SO != SOEnd && !Done; ++SO) {
1357 assert(SO->second.size() > 0 &&
1358 "All virtual functions have overridding virtual functions");
1359
1360 // C++ [class.abstract]p4:
1361 // A class is abstract if it contains or inherits at least one
1362 // pure virtual function for which the final overrider is pure
1363 // virtual.
1364 if (SO->second.front().Method->isPure()) {
1365 data().Abstract = true;
1366 Done = true;
1367 break;
1368 }
1369 }
1370 }
1371 }
Douglas Gregor457104e2010-09-29 04:25:11 +00001372
1373 // Set access bits correctly on the directly-declared conversions.
Richard Smitha4ba74c2013-08-30 04:46:40 +00001374 for (conversion_iterator I = conversion_begin(), E = conversion_end();
Douglas Gregor457104e2010-09-29 04:25:11 +00001375 I != E; ++I)
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001376 I.setAccess((*I)->getAccess());
Douglas Gregor8fb95122010-09-29 00:15:42 +00001377}
1378
1379bool CXXRecordDecl::mayBeAbstract() const {
1380 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1381 isDependentContext())
1382 return false;
1383
Aaron Ballman574705e2014-03-13 15:41:46 +00001384 for (const auto &B : bases()) {
Douglas Gregor8fb95122010-09-29 00:15:42 +00001385 CXXRecordDecl *BaseDecl
Aaron Ballman574705e2014-03-13 15:41:46 +00001386 = cast<CXXRecordDecl>(B.getType()->getAs<RecordType>()->getDecl());
Douglas Gregor8fb95122010-09-29 00:15:42 +00001387 if (BaseDecl->isAbstract())
1388 return true;
1389 }
1390
1391 return false;
1392}
1393
David Blaikie68e081d2011-12-20 02:48:34 +00001394void CXXMethodDecl::anchor() { }
1395
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001396bool CXXMethodDecl::isStatic() const {
Rafael Espindola29cda592013-04-15 12:38:20 +00001397 const CXXMethodDecl *MD = getCanonicalDecl();
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001398
1399 if (MD->getStorageClass() == SC_Static)
1400 return true;
1401
Reid Kleckner9a7f3e62013-10-08 00:58:57 +00001402 OverloadedOperatorKind OOK = getDeclName().getCXXOverloadedOperator();
1403 return isStaticOverloadedOperator(OOK);
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001404}
1405
Rafael Espindola49e860b2012-06-26 17:45:31 +00001406static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1407 const CXXMethodDecl *BaseMD) {
1408 for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
1409 E = DerivedMD->end_overridden_methods(); I != E; ++I) {
1410 const CXXMethodDecl *MD = *I;
1411 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1412 return true;
1413 if (recursivelyOverrides(MD, BaseMD))
1414 return true;
1415 }
1416 return false;
1417}
1418
1419CXXMethodDecl *
Jordan Rose5fc5da02012-08-15 20:07:17 +00001420CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1421 bool MayBeBase) {
Rafael Espindola49e860b2012-06-26 17:45:31 +00001422 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1423 return this;
1424
1425 // Lookup doesn't work for destructors, so handle them separately.
1426 if (isa<CXXDestructorDecl>(this)) {
1427 CXXMethodDecl *MD = RD->getDestructor();
Jordan Rose5fc5da02012-08-15 20:07:17 +00001428 if (MD) {
1429 if (recursivelyOverrides(MD, this))
1430 return MD;
1431 if (MayBeBase && recursivelyOverrides(this, MD))
1432 return MD;
1433 }
Craig Topper36250ad2014-05-12 05:36:57 +00001434 return nullptr;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001435 }
1436
Richard Smith40c78062015-02-21 02:31:57 +00001437 for (auto *ND : RD->lookup(getDeclName())) {
1438 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND);
Rafael Espindola49e860b2012-06-26 17:45:31 +00001439 if (!MD)
1440 continue;
1441 if (recursivelyOverrides(MD, this))
1442 return MD;
Jordan Rose5fc5da02012-08-15 20:07:17 +00001443 if (MayBeBase && recursivelyOverrides(this, MD))
1444 return MD;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001445 }
1446
Aaron Ballman574705e2014-03-13 15:41:46 +00001447 for (const auto &I : RD->bases()) {
1448 const RecordType *RT = I.getType()->getAs<RecordType>();
Rafael Espindola49e860b2012-06-26 17:45:31 +00001449 if (!RT)
1450 continue;
1451 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1452 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1453 if (T)
1454 return T;
1455 }
1456
Craig Topper36250ad2014-05-12 05:36:57 +00001457 return nullptr;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001458}
1459
Ted Kremenek21475702008-09-05 17:16:31 +00001460CXXMethodDecl *
1461CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001462 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001463 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00001464 QualType T, TypeSourceInfo *TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001465 StorageClass SC, bool isInline,
Richard Smitha77a0a62011-08-15 21:04:07 +00001466 bool isConstexpr, SourceLocation EndLocation) {
Richard Smith053f6c62014-05-16 23:01:30 +00001467 return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
1468 T, TInfo, SC, isInline, isConstexpr,
1469 EndLocation);
Ted Kremenek21475702008-09-05 17:16:31 +00001470}
1471
Douglas Gregor72172e92012-01-05 21:55:30 +00001472CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00001473 return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00001474 DeclarationNameInfo(), QualType(), nullptr,
Richard Smithf7981722013-11-22 09:01:48 +00001475 SC_None, false, false, SourceLocation());
Douglas Gregor72172e92012-01-05 21:55:30 +00001476}
1477
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001478bool CXXMethodDecl::isUsualDeallocationFunction() const {
1479 if (getOverloadedOperator() != OO_Delete &&
1480 getOverloadedOperator() != OO_Array_Delete)
1481 return false;
Douglas Gregor6642ca22010-02-26 05:06:18 +00001482
1483 // C++ [basic.stc.dynamic.deallocation]p2:
1484 // A template instance is never a usual deallocation function,
1485 // regardless of its signature.
1486 if (getPrimaryTemplate())
1487 return false;
1488
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001489 // C++ [basic.stc.dynamic.deallocation]p2:
1490 // If a class T has a member deallocation function named operator delete
1491 // with exactly one parameter, then that function is a usual (non-placement)
1492 // deallocation function. [...]
1493 if (getNumParams() == 1)
1494 return true;
1495
1496 // C++ [basic.stc.dynamic.deallocation]p2:
1497 // [...] If class T does not declare such an operator delete but does
1498 // declare a member deallocation function named operator delete with
1499 // exactly two parameters, the second of which has type std::size_t (18.1),
1500 // then this function is a usual deallocation function.
1501 ASTContext &Context = getASTContext();
1502 if (getNumParams() != 2 ||
Chandler Carruth75cc3592010-02-08 18:54:05 +00001503 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1504 Context.getSizeType()))
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001505 return false;
1506
1507 // This function is a usual deallocation function if there are no
1508 // single-parameter deallocation functions of the same kind.
Richard Smithcf4bdde2015-02-21 02:45:19 +00001509 DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName());
1510 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
David Blaikieff7d47a2012-12-19 00:45:41 +00001511 I != E; ++I) {
1512 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001513 if (FD->getNumParams() == 1)
1514 return false;
1515 }
1516
1517 return true;
1518}
1519
Douglas Gregorb139cd52010-05-01 20:49:11 +00001520bool CXXMethodDecl::isCopyAssignmentOperator() const {
Alexis Huntfcaeae42011-05-25 20:50:04 +00001521 // C++0x [class.copy]p17:
Douglas Gregorb139cd52010-05-01 20:49:11 +00001522 // A user-declared copy assignment operator X::operator= is a non-static
1523 // non-template member function of class X with exactly one parameter of
1524 // type X, X&, const X&, volatile X& or const volatile X&.
1525 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1526 /*non-static*/ isStatic() ||
Eli Friedman84c0143e2013-07-11 23:55:07 +00001527 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1528 getNumParams() != 1)
Douglas Gregorb139cd52010-05-01 20:49:11 +00001529 return false;
1530
1531 QualType ParamType = getParamDecl(0)->getType();
1532 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1533 ParamType = Ref->getPointeeType();
1534
1535 ASTContext &Context = getASTContext();
1536 QualType ClassType
1537 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1538 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1539}
1540
Alexis Huntfcaeae42011-05-25 20:50:04 +00001541bool CXXMethodDecl::isMoveAssignmentOperator() const {
1542 // C++0x [class.copy]p19:
1543 // A user-declared move assignment operator X::operator= is a non-static
1544 // non-template member function of class X with exactly one parameter of type
1545 // X&&, const X&&, volatile X&&, or const volatile X&&.
1546 if (getOverloadedOperator() != OO_Equal || isStatic() ||
Eli Friedman84c0143e2013-07-11 23:55:07 +00001547 getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1548 getNumParams() != 1)
Alexis Huntfcaeae42011-05-25 20:50:04 +00001549 return false;
1550
1551 QualType ParamType = getParamDecl(0)->getType();
1552 if (!isa<RValueReferenceType>(ParamType))
1553 return false;
1554 ParamType = ParamType->getPointeeType();
1555
1556 ASTContext &Context = getASTContext();
1557 QualType ClassType
1558 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1559 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1560}
1561
Anders Carlsson36d87e12009-05-16 23:58:37 +00001562void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
Anders Carlssonf3935b42009-12-04 05:51:56 +00001563 assert(MD->isCanonicalDecl() && "Method is not canonical!");
Anders Carlssonbd32c432010-01-30 17:42:34 +00001564 assert(!MD->getParent()->isDependentContext() &&
1565 "Can't add an overridden method to a class template!");
Eli Friedman91359022012-03-10 01:39:01 +00001566 assert(MD->isVirtual() && "Method is not virtual!");
Anders Carlssonbd32c432010-01-30 17:42:34 +00001567
Douglas Gregor832940b2010-03-02 23:58:15 +00001568 getASTContext().addOverriddenMethod(this, MD);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001569}
1570
1571CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001572 if (isa<CXXConstructorDecl>(this)) return nullptr;
Douglas Gregor832940b2010-03-02 23:58:15 +00001573 return getASTContext().overridden_methods_begin(this);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001574}
1575
1576CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001577 if (isa<CXXConstructorDecl>(this)) return nullptr;
Douglas Gregor832940b2010-03-02 23:58:15 +00001578 return getASTContext().overridden_methods_end(this);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001579}
1580
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001581unsigned CXXMethodDecl::size_overridden_methods() const {
Eli Friedman91359022012-03-10 01:39:01 +00001582 if (isa<CXXConstructorDecl>(this)) return 0;
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001583 return getASTContext().overridden_methods_size(this);
1584}
1585
Ted Kremenek21475702008-09-05 17:16:31 +00001586QualType CXXMethodDecl::getThisType(ASTContext &C) const {
Argyrios Kyrtzidis962c20e2008-10-24 22:28:18 +00001587 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1588 // If the member function is declared const, the type of this is const X*,
1589 // if the member function is declared volatile, the type of this is
1590 // volatile X*, and if the member function is declared const volatile,
1591 // the type of this is const volatile X*.
1592
Ted Kremenek21475702008-09-05 17:16:31 +00001593 assert(isInstance() && "No 'this' for static methods!");
Anders Carlsson20ee0ed2009-06-13 02:59:33 +00001594
John McCalle78aac42010-03-10 03:28:59 +00001595 QualType ClassTy = C.getTypeDeclType(getParent());
John McCall8ccfcb52009-09-24 19:53:00 +00001596 ClassTy = C.getQualifiedType(ClassTy,
1597 Qualifiers::fromCVRMask(getTypeQualifiers()));
Anders Carlsson7ca3f6f2009-07-10 21:35:09 +00001598 return C.getPointerType(ClassTy);
Ted Kremenek21475702008-09-05 17:16:31 +00001599}
1600
Eli Friedman71a26d82009-12-06 20:50:05 +00001601bool CXXMethodDecl::hasInlineBody() const {
Douglas Gregora318efd2010-01-05 19:06:31 +00001602 // If this function is a template instantiation, look at the template from
1603 // which it was instantiated.
1604 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1605 if (!CheckFn)
1606 CheckFn = this;
1607
Eli Friedman71a26d82009-12-06 20:50:05 +00001608 const FunctionDecl *fn;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00001609 return CheckFn->hasBody(fn) && !fn->isOutOfLine();
Eli Friedman71a26d82009-12-06 20:50:05 +00001610}
1611
Douglas Gregor355efbb2012-02-17 03:02:34 +00001612bool CXXMethodDecl::isLambdaStaticInvoker() const {
Faisal Vali571df122013-09-29 08:45:24 +00001613 const CXXRecordDecl *P = getParent();
1614 if (P->isLambda()) {
1615 if (const CXXMethodDecl *StaticInvoker = P->getLambdaStaticInvoker()) {
1616 if (StaticInvoker == this) return true;
1617 if (P->isGenericLambda() && this->isFunctionTemplateSpecialization())
1618 return StaticInvoker == this->getPrimaryTemplate()->getTemplatedDecl();
1619 }
1620 }
1621 return false;
Douglas Gregor355efbb2012-02-17 03:02:34 +00001622}
1623
Alexis Hunt1d792652011-01-08 20:30:50 +00001624CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1625 TypeSourceInfo *TInfo, bool IsVirtual,
1626 SourceLocation L, Expr *Init,
1627 SourceLocation R,
1628 SourceLocation EllipsisLoc)
Alexis Hunta50dd462011-01-08 23:01:16 +00001629 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001630 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
1631 IsWritten(false), SourceOrderOrNumArrayIndices(0)
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001632{
Douglas Gregore8381c02008-11-05 04:29:56 +00001633}
1634
Alexis Hunt1d792652011-01-08 20:30:50 +00001635CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1636 FieldDecl *Member,
1637 SourceLocation MemberLoc,
1638 SourceLocation L, Expr *Init,
1639 SourceLocation R)
Alexis Hunta50dd462011-01-08 23:01:16 +00001640 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001641 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
Francois Pichetd583da02010-12-04 09:14:42 +00001642 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1643{
1644}
1645
Alexis Hunt1d792652011-01-08 20:30:50 +00001646CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1647 IndirectFieldDecl *Member,
1648 SourceLocation MemberLoc,
1649 SourceLocation L, Expr *Init,
1650 SourceLocation R)
Alexis Hunta50dd462011-01-08 23:01:16 +00001651 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001652 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
Abramo Bagnara341d7832010-05-26 18:09:23 +00001653 IsWritten(false), SourceOrderOrNumArrayIndices(0)
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001654{
Douglas Gregore8381c02008-11-05 04:29:56 +00001655}
1656
Alexis Hunt1d792652011-01-08 20:30:50 +00001657CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001658 TypeSourceInfo *TInfo,
1659 SourceLocation L, Expr *Init,
Alexis Huntc5575cc2011-02-26 19:13:13 +00001660 SourceLocation R)
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001661 : Initializee(TInfo), MemberOrEllipsisLocation(), Init(Init),
1662 LParenLoc(L), RParenLoc(R), IsDelegating(true), IsVirtual(false),
Alexis Huntc5575cc2011-02-26 19:13:13 +00001663 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1664{
1665}
1666
1667CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
Alexis Hunt1d792652011-01-08 20:30:50 +00001668 FieldDecl *Member,
1669 SourceLocation MemberLoc,
1670 SourceLocation L, Expr *Init,
1671 SourceLocation R,
1672 VarDecl **Indices,
1673 unsigned NumIndices)
Alexis Hunta50dd462011-01-08 23:01:16 +00001674 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
Richard Smith22fdae92014-07-21 05:27:31 +00001675 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
Abramo Bagnara341d7832010-05-26 18:09:23 +00001676 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices)
Douglas Gregor94f9a482010-05-05 05:51:00 +00001677{
1678 VarDecl **MyIndices = reinterpret_cast<VarDecl **> (this + 1);
1679 memcpy(MyIndices, Indices, NumIndices * sizeof(VarDecl *));
1680}
1681
Alexis Hunt1d792652011-01-08 20:30:50 +00001682CXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context,
1683 FieldDecl *Member,
1684 SourceLocation MemberLoc,
1685 SourceLocation L, Expr *Init,
1686 SourceLocation R,
1687 VarDecl **Indices,
1688 unsigned NumIndices) {
1689 void *Mem = Context.Allocate(sizeof(CXXCtorInitializer) +
Douglas Gregor94f9a482010-05-05 05:51:00 +00001690 sizeof(VarDecl *) * NumIndices,
Alexis Hunt1d792652011-01-08 20:30:50 +00001691 llvm::alignOf<CXXCtorInitializer>());
Alexis Hunta50dd462011-01-08 23:01:16 +00001692 return new (Mem) CXXCtorInitializer(Context, Member, MemberLoc, L, Init, R,
1693 Indices, NumIndices);
Douglas Gregor94f9a482010-05-05 05:51:00 +00001694}
1695
Alexis Hunt1d792652011-01-08 20:30:50 +00001696TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001697 if (isBaseInitializer())
Alexis Hunta50dd462011-01-08 23:01:16 +00001698 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001699 else
1700 return TypeLoc();
1701}
1702
Alexis Hunt1d792652011-01-08 20:30:50 +00001703const Type *CXXCtorInitializer::getBaseClass() const {
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001704 if (isBaseInitializer())
Alexis Hunta50dd462011-01-08 23:01:16 +00001705 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001706 else
Craig Topper36250ad2014-05-12 05:36:57 +00001707 return nullptr;
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001708}
1709
Alexis Hunt1d792652011-01-08 20:30:50 +00001710SourceLocation CXXCtorInitializer::getSourceLocation() const {
Richard Smith938f40b2011-06-11 17:19:42 +00001711 if (isInClassMemberInitializer())
1712 return getAnyMember()->getLocation();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001713
David Blaikiea81d4102015-01-18 00:12:58 +00001714 if (isAnyMemberInitializer())
1715 return getMemberLocation();
1716
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001717 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>())
1718 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
1719
1720 return SourceLocation();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001721}
1722
Alexis Hunt1d792652011-01-08 20:30:50 +00001723SourceRange CXXCtorInitializer::getSourceRange() const {
Richard Smith938f40b2011-06-11 17:19:42 +00001724 if (isInClassMemberInitializer()) {
1725 FieldDecl *D = getAnyMember();
1726 if (Expr *I = D->getInClassInitializer())
1727 return I->getSourceRange();
1728 return SourceRange();
1729 }
1730
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00001731 return SourceRange(getSourceLocation(), getRParenLoc());
Douglas Gregore8381c02008-11-05 04:29:56 +00001732}
1733
David Blaikie68e081d2011-12-20 02:48:34 +00001734void CXXConstructorDecl::anchor() { }
1735
Douglas Gregor61956c42008-10-31 09:07:45 +00001736CXXConstructorDecl *
Douglas Gregor72172e92012-01-05 21:55:30 +00001737CXXConstructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00001738 return new (C, ID) CXXConstructorDecl(C, nullptr, SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00001739 DeclarationNameInfo(), QualType(),
Craig Topper36250ad2014-05-12 05:36:57 +00001740 nullptr, false, false, false, false);
Chris Lattnerca025db2010-05-07 21:43:38 +00001741}
1742
1743CXXConstructorDecl *
Douglas Gregor61956c42008-10-31 09:07:45 +00001744CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001745 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001746 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00001747 QualType T, TypeSourceInfo *TInfo,
Richard Smitha77a0a62011-08-15 21:04:07 +00001748 bool isExplicit, bool isInline,
1749 bool isImplicitlyDeclared, bool isConstexpr) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001750 assert(NameInfo.getName().getNameKind()
1751 == DeclarationName::CXXConstructorName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00001752 "Name must refer to a constructor");
Richard Smith053f6c62014-05-16 23:01:30 +00001753 return new (C, RD) CXXConstructorDecl(C, RD, StartLoc, NameInfo, T, TInfo,
Richard Smithf7981722013-11-22 09:01:48 +00001754 isExplicit, isInline,
1755 isImplicitlyDeclared, isConstexpr);
Douglas Gregor61956c42008-10-31 09:07:45 +00001756}
1757
Richard Smithc2bb8182015-03-24 06:36:48 +00001758CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
1759 return CtorInitializers.get(getASTContext().getExternalSource());
1760}
1761
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001762CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
1763 assert(isDelegatingConstructor() && "Not a delegating constructor!");
1764 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
1765 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E))
1766 return Construct->getConstructor();
Craig Topper36250ad2014-05-12 05:36:57 +00001767
1768 return nullptr;
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001769}
1770
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001771bool CXXConstructorDecl::isDefaultConstructor() const {
1772 // C++ [class.ctor]p5:
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +00001773 // A default constructor for a class X is a constructor of class
1774 // X that can be called without an argument.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001775 return (getNumParams() == 0) ||
Anders Carlsson6eb55572009-08-25 05:12:04 +00001776 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001777}
1778
Mike Stump11289f42009-09-09 15:08:12 +00001779bool
Douglas Gregor507eb872009-12-22 00:34:07 +00001780CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
Douglas Gregorf282a762011-01-21 19:38:21 +00001781 return isCopyOrMoveConstructor(TypeQuals) &&
1782 getParamDecl(0)->getType()->isLValueReferenceType();
1783}
1784
1785bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
1786 return isCopyOrMoveConstructor(TypeQuals) &&
1787 getParamDecl(0)->getType()->isRValueReferenceType();
1788}
1789
1790/// \brief Determine whether this is a copy or move constructor.
1791bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001792 // C++ [class.copy]p2:
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +00001793 // A non-template constructor for class X is a copy constructor
1794 // if its first parameter is of type X&, const X&, volatile X& or
1795 // const volatile X&, and either there are no other parameters
1796 // or else all other parameters have default arguments (8.3.6).
Douglas Gregorf282a762011-01-21 19:38:21 +00001797 // C++0x [class.copy]p3:
1798 // A non-template constructor for class X is a move constructor if its
1799 // first parameter is of type X&&, const X&&, volatile X&&, or
1800 // const volatile X&&, and either there are no other parameters or else
1801 // all other parameters have default arguments.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001802 if ((getNumParams() < 1) ||
Douglas Gregora14b43b2009-10-13 23:45:19 +00001803 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
Craig Topper36250ad2014-05-12 05:36:57 +00001804 (getPrimaryTemplate() != nullptr) ||
1805 (getDescribedFunctionTemplate() != nullptr))
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001806 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00001807
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001808 const ParmVarDecl *Param = getParamDecl(0);
Douglas Gregorf282a762011-01-21 19:38:21 +00001809
1810 // Do we have a reference type?
1811 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
Douglas Gregorff7028a2009-11-13 23:59:09 +00001812 if (!ParamRefType)
1813 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00001814
Douglas Gregorff7028a2009-11-13 23:59:09 +00001815 // Is it a reference to our class type?
Douglas Gregor507eb872009-12-22 00:34:07 +00001816 ASTContext &Context = getASTContext();
1817
Douglas Gregorff7028a2009-11-13 23:59:09 +00001818 CanQualType PointeeType
1819 = Context.getCanonicalType(ParamRefType->getPointeeType());
Douglas Gregorf70b2b42009-09-15 20:50:23 +00001820 CanQualType ClassTy
1821 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001822 if (PointeeType.getUnqualifiedType() != ClassTy)
1823 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00001824
John McCall8ccfcb52009-09-24 19:53:00 +00001825 // FIXME: other qualifiers?
Douglas Gregorf282a762011-01-21 19:38:21 +00001826
1827 // We have a copy or move constructor.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001828 TypeQuals = PointeeType.getCVRQualifiers();
Douglas Gregorf282a762011-01-21 19:38:21 +00001829 return true;
Douglas Gregoreebb5c12008-10-31 20:25:05 +00001830}
1831
Anders Carlssond20e7952009-08-28 16:57:08 +00001832bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001833 // C++ [class.conv.ctor]p1:
1834 // A constructor declared without the function-specifier explicit
1835 // that can be called with a single parameter specifies a
1836 // conversion from the type of its first parameter to the type of
1837 // its class. Such a constructor is called a converting
1838 // constructor.
Anders Carlssond20e7952009-08-28 16:57:08 +00001839 if (isExplicit() && !AllowExplicit)
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001840 return false;
1841
Mike Stump11289f42009-09-09 15:08:12 +00001842 return (getNumParams() == 0 &&
John McCall9dd450b2009-09-21 23:43:11 +00001843 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001844 (getNumParams() == 1) ||
Douglas Gregorc65e1592012-06-05 23:44:51 +00001845 (getNumParams() > 1 &&
1846 (getParamDecl(1)->hasDefaultArg() ||
1847 getParamDecl(1)->isParameterPack()));
Douglas Gregor26bee0b2008-10-31 16:23:19 +00001848}
Douglas Gregor61956c42008-10-31 09:07:45 +00001849
Douglas Gregorbd6b17f2010-11-08 17:16:59 +00001850bool CXXConstructorDecl::isSpecializationCopyingObject() const {
Douglas Gregorffe14e32009-11-14 01:20:54 +00001851 if ((getNumParams() < 1) ||
1852 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
Craig Topper36250ad2014-05-12 05:36:57 +00001853 (getDescribedFunctionTemplate() != nullptr))
Douglas Gregorffe14e32009-11-14 01:20:54 +00001854 return false;
1855
1856 const ParmVarDecl *Param = getParamDecl(0);
1857
1858 ASTContext &Context = getASTContext();
1859 CanQualType ParamType = Context.getCanonicalType(Param->getType());
1860
Douglas Gregorffe14e32009-11-14 01:20:54 +00001861 // Is it the same as our our class type?
1862 CanQualType ClassTy
1863 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1864 if (ParamType.getUnqualifiedType() != ClassTy)
1865 return false;
1866
1867 return true;
1868}
1869
Sebastian Redl08905022011-02-05 19:23:19 +00001870const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
1871 // Hack: we store the inherited constructor in the overridden method table
Eli Friedman91359022012-03-10 01:39:01 +00001872 method_iterator It = getASTContext().overridden_methods_begin(this);
1873 if (It == getASTContext().overridden_methods_end(this))
Craig Topper36250ad2014-05-12 05:36:57 +00001874 return nullptr;
Sebastian Redl08905022011-02-05 19:23:19 +00001875
1876 return cast<CXXConstructorDecl>(*It);
1877}
1878
1879void
1880CXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl *BaseCtor){
1881 // Hack: we store the inherited constructor in the overridden method table
Eli Friedman91359022012-03-10 01:39:01 +00001882 assert(getASTContext().overridden_methods_size(this) == 0 &&
1883 "Base ctor already set.");
1884 getASTContext().addOverriddenMethod(this, BaseCtor);
Sebastian Redl08905022011-02-05 19:23:19 +00001885}
1886
David Blaikie68e081d2011-12-20 02:48:34 +00001887void CXXDestructorDecl::anchor() { }
1888
Douglas Gregor831c93f2008-11-05 20:51:48 +00001889CXXDestructorDecl *
Douglas Gregor72172e92012-01-05 21:55:30 +00001890CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00001891 return new (C, ID)
1892 CXXDestructorDecl(C, nullptr, SourceLocation(), DeclarationNameInfo(),
1893 QualType(), nullptr, false, false);
Chris Lattnerca025db2010-05-07 21:43:38 +00001894}
1895
1896CXXDestructorDecl *
Douglas Gregor831c93f2008-11-05 20:51:48 +00001897CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001898 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001899 const DeclarationNameInfo &NameInfo,
Craig Silversteinaf8808d2010-10-21 00:44:50 +00001900 QualType T, TypeSourceInfo *TInfo,
Richard Smitha77a0a62011-08-15 21:04:07 +00001901 bool isInline, bool isImplicitlyDeclared) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001902 assert(NameInfo.getName().getNameKind()
1903 == DeclarationName::CXXDestructorName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00001904 "Name must refer to a destructor");
Richard Smith053f6c62014-05-16 23:01:30 +00001905 return new (C, RD) CXXDestructorDecl(C, RD, StartLoc, NameInfo, T, TInfo,
Richard Smithf7981722013-11-22 09:01:48 +00001906 isInline, isImplicitlyDeclared);
Douglas Gregor831c93f2008-11-05 20:51:48 +00001907}
1908
Richard Smithf8134002015-03-10 01:41:22 +00001909void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD) {
1910 auto *First = cast<CXXDestructorDecl>(getFirstDecl());
1911 if (OD && !First->OperatorDelete) {
1912 First->OperatorDelete = OD;
1913 if (auto *L = getASTMutationListener())
1914 L->ResolvedOperatorDelete(First, OD);
1915 }
1916}
1917
David Blaikie68e081d2011-12-20 02:48:34 +00001918void CXXConversionDecl::anchor() { }
1919
Douglas Gregordbc5daf2008-11-07 20:08:42 +00001920CXXConversionDecl *
Douglas Gregor72172e92012-01-05 21:55:30 +00001921CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00001922 return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00001923 DeclarationNameInfo(), QualType(),
Craig Topper36250ad2014-05-12 05:36:57 +00001924 nullptr, false, false, false,
Richard Smithf7981722013-11-22 09:01:48 +00001925 SourceLocation());
Chris Lattnerca025db2010-05-07 21:43:38 +00001926}
1927
1928CXXConversionDecl *
Douglas Gregordbc5daf2008-11-07 20:08:42 +00001929CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001930 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001931 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00001932 QualType T, TypeSourceInfo *TInfo,
Douglas Gregorf2f08062011-03-08 17:10:18 +00001933 bool isInline, bool isExplicit,
Richard Smitha77a0a62011-08-15 21:04:07 +00001934 bool isConstexpr, SourceLocation EndLocation) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001935 assert(NameInfo.getName().getNameKind()
1936 == DeclarationName::CXXConversionFunctionName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00001937 "Name must refer to a conversion function");
Richard Smith053f6c62014-05-16 23:01:30 +00001938 return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
Richard Smithf7981722013-11-22 09:01:48 +00001939 isInline, isExplicit, isConstexpr,
1940 EndLocation);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00001941}
1942
Douglas Gregord3b672c2012-02-16 01:06:16 +00001943bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
1944 return isImplicit() && getParent()->isLambda() &&
1945 getConversionType()->isBlockPointerType();
1946}
1947
David Blaikie68e081d2011-12-20 02:48:34 +00001948void LinkageSpecDecl::anchor() { }
1949
Chris Lattnerb8c18fa2008-11-04 16:51:42 +00001950LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
Mike Stump11289f42009-09-09 15:08:12 +00001951 DeclContext *DC,
Abramo Bagnaraea947882011-03-08 16:41:52 +00001952 SourceLocation ExternLoc,
1953 SourceLocation LangLoc,
Abramo Bagnara4a8cda82011-03-03 14:52:38 +00001954 LanguageIDs Lang,
Rafael Espindola327be3c2013-04-26 01:30:23 +00001955 bool HasBraces) {
Richard Smithf7981722013-11-22 09:01:48 +00001956 return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
Douglas Gregor29ff7d02008-12-16 22:23:02 +00001957}
Douglas Gregor889ceb72009-02-03 19:21:40 +00001958
Richard Smithf7981722013-11-22 09:01:48 +00001959LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C,
1960 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00001961 return new (C, ID) LinkageSpecDecl(nullptr, SourceLocation(),
1962 SourceLocation(), lang_c, false);
Douglas Gregor72172e92012-01-05 21:55:30 +00001963}
1964
David Blaikie68e081d2011-12-20 02:48:34 +00001965void UsingDirectiveDecl::anchor() { }
1966
Douglas Gregor889ceb72009-02-03 19:21:40 +00001967UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
1968 SourceLocation L,
1969 SourceLocation NamespaceLoc,
Douglas Gregor12441b32011-02-25 16:33:46 +00001970 NestedNameSpecifierLoc QualifierLoc,
Douglas Gregor889ceb72009-02-03 19:21:40 +00001971 SourceLocation IdentLoc,
Sebastian Redla6602e92009-11-23 15:34:23 +00001972 NamedDecl *Used,
Douglas Gregor889ceb72009-02-03 19:21:40 +00001973 DeclContext *CommonAncestor) {
Sebastian Redla6602e92009-11-23 15:34:23 +00001974 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used))
1975 Used = NS->getOriginalNamespace();
Richard Smithf7981722013-11-22 09:01:48 +00001976 return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
1977 IdentLoc, Used, CommonAncestor);
Douglas Gregor889ceb72009-02-03 19:21:40 +00001978}
1979
Richard Smithf7981722013-11-22 09:01:48 +00001980UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C,
1981 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00001982 return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
1983 SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00001984 NestedNameSpecifierLoc(),
Craig Topper36250ad2014-05-12 05:36:57 +00001985 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00001986}
1987
Sebastian Redla6602e92009-11-23 15:34:23 +00001988NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
1989 if (NamespaceAliasDecl *NA =
1990 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
1991 return NA->getNamespace();
1992 return cast_or_null<NamespaceDecl>(NominatedNamespace);
1993}
1994
Richard Smith053f6c62014-05-16 23:01:30 +00001995NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
1996 SourceLocation StartLoc, SourceLocation IdLoc,
1997 IdentifierInfo *Id, NamespaceDecl *PrevDecl)
1998 : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace),
1999 redeclarable_base(C), LocStart(StartLoc), RBraceLoc(),
2000 AnonOrFirstNamespaceAndInline(nullptr, Inline) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002001 setPreviousDecl(PrevDecl);
Richard Smith053f6c62014-05-16 23:01:30 +00002002
Douglas Gregore57e7522012-01-07 09:11:48 +00002003 if (PrevDecl)
2004 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
2005}
2006
Douglas Gregor72172e92012-01-05 21:55:30 +00002007NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregore57e7522012-01-07 09:11:48 +00002008 bool Inline, SourceLocation StartLoc,
2009 SourceLocation IdLoc, IdentifierInfo *Id,
2010 NamespaceDecl *PrevDecl) {
Richard Smith053f6c62014-05-16 23:01:30 +00002011 return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id,
2012 PrevDecl);
Douglas Gregor72172e92012-01-05 21:55:30 +00002013}
2014
2015NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00002016 return new (C, ID) NamespaceDecl(C, nullptr, false, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00002017 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002018}
2019
Richard Smithd7af8a32014-05-10 01:17:36 +00002020NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() {
2021 return getNextRedeclaration();
Rafael Espindola8ef7f682013-11-26 15:12:20 +00002022}
2023NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() {
2024 return getPreviousDecl();
2025}
2026NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() {
2027 return getMostRecentDecl();
2028}
2029
David Blaikie68e081d2011-12-20 02:48:34 +00002030void NamespaceAliasDecl::anchor() { }
2031
Richard Smithf4634362014-09-03 23:11:22 +00002032NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() {
2033 return getNextRedeclaration();
2034}
2035NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() {
2036 return getPreviousDecl();
2037}
2038NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() {
2039 return getMostRecentDecl();
2040}
2041
Mike Stump11289f42009-09-09 15:08:12 +00002042NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregor01a430132010-09-01 03:07:18 +00002043 SourceLocation UsingLoc,
Mike Stump11289f42009-09-09 15:08:12 +00002044 SourceLocation AliasLoc,
2045 IdentifierInfo *Alias,
Douglas Gregorc05ba2e2011-02-25 17:08:07 +00002046 NestedNameSpecifierLoc QualifierLoc,
Mike Stump11289f42009-09-09 15:08:12 +00002047 SourceLocation IdentLoc,
Anders Carlssonff25fdf2009-03-28 22:58:02 +00002048 NamedDecl *Namespace) {
Richard Smithf4634362014-09-03 23:11:22 +00002049 // FIXME: Preserve the aliased namespace as written.
Sebastian Redla6602e92009-11-23 15:34:23 +00002050 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
2051 Namespace = NS->getOriginalNamespace();
Richard Smithf4634362014-09-03 23:11:22 +00002052 return new (C, DC) NamespaceAliasDecl(C, DC, UsingLoc, AliasLoc, Alias,
Richard Smithf7981722013-11-22 09:01:48 +00002053 QualifierLoc, IdentLoc, Namespace);
Anders Carlssonff25fdf2009-03-28 22:58:02 +00002054}
2055
Douglas Gregor72172e92012-01-05 21:55:30 +00002056NamespaceAliasDecl *
2057NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf4634362014-09-03 23:11:22 +00002058 return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00002059 SourceLocation(), nullptr,
2060 NestedNameSpecifierLoc(),
2061 SourceLocation(), nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002062}
2063
David Blaikie68e081d2011-12-20 02:48:34 +00002064void UsingShadowDecl::anchor() { }
2065
Douglas Gregor72172e92012-01-05 21:55:30 +00002066UsingShadowDecl *
2067UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00002068 return new (C, ID) UsingShadowDecl(C, nullptr, SourceLocation(),
2069 nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002070}
2071
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002072UsingDecl *UsingShadowDecl::getUsingDecl() const {
2073 const UsingShadowDecl *Shadow = this;
2074 while (const UsingShadowDecl *NextShadow =
2075 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
2076 Shadow = NextShadow;
2077 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
2078}
2079
David Blaikie68e081d2011-12-20 02:48:34 +00002080void UsingDecl::anchor() { }
2081
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002082void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
2083 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
2084 "declaration already in set");
2085 assert(S->getUsingDecl() == this);
2086
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002087 if (FirstUsingShadow.getPointer())
2088 S->UsingOrNextShadow = FirstUsingShadow.getPointer();
2089 FirstUsingShadow.setPointer(S);
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002090}
2091
2092void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
2093 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
2094 "declaration not in set");
2095 assert(S->getUsingDecl() == this);
2096
2097 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
2098
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002099 if (FirstUsingShadow.getPointer() == S) {
2100 FirstUsingShadow.setPointer(
2101 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002102 S->UsingOrNextShadow = this;
2103 return;
2104 }
2105
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002106 UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002107 while (Prev->UsingOrNextShadow != S)
2108 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
2109 Prev->UsingOrNextShadow = S->UsingOrNextShadow;
2110 S->UsingOrNextShadow = this;
2111}
2112
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002113UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
2114 NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002115 const DeclarationNameInfo &NameInfo,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00002116 bool HasTypename) {
Richard Smithf7981722013-11-22 09:01:48 +00002117 return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
Douglas Gregorfec52632009-06-20 00:51:54 +00002118}
2119
Douglas Gregor72172e92012-01-05 21:55:30 +00002120UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002121 return new (C, ID) UsingDecl(nullptr, SourceLocation(),
2122 NestedNameSpecifierLoc(), DeclarationNameInfo(),
2123 false);
Douglas Gregor72172e92012-01-05 21:55:30 +00002124}
2125
Enea Zaffanellac70b2512013-07-17 17:28:56 +00002126SourceRange UsingDecl::getSourceRange() const {
2127 SourceLocation Begin = isAccessDeclaration()
2128 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2129 return SourceRange(Begin, getNameInfo().getEndLoc());
2130}
2131
David Blaikie68e081d2011-12-20 02:48:34 +00002132void UnresolvedUsingValueDecl::anchor() { }
2133
John McCalle61f2ba2009-11-18 02:36:19 +00002134UnresolvedUsingValueDecl *
2135UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
2136 SourceLocation UsingLoc,
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002137 NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002138 const DeclarationNameInfo &NameInfo) {
Richard Smithf7981722013-11-22 09:01:48 +00002139 return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
2140 QualifierLoc, NameInfo);
John McCalle61f2ba2009-11-18 02:36:19 +00002141}
2142
Douglas Gregor72172e92012-01-05 21:55:30 +00002143UnresolvedUsingValueDecl *
2144UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002145 return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(),
2146 SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00002147 NestedNameSpecifierLoc(),
Craig Topper36250ad2014-05-12 05:36:57 +00002148 DeclarationNameInfo());
Douglas Gregor72172e92012-01-05 21:55:30 +00002149}
2150
Enea Zaffanellac70b2512013-07-17 17:28:56 +00002151SourceRange UnresolvedUsingValueDecl::getSourceRange() const {
2152 SourceLocation Begin = isAccessDeclaration()
2153 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2154 return SourceRange(Begin, getNameInfo().getEndLoc());
2155}
2156
David Blaikie68e081d2011-12-20 02:48:34 +00002157void UnresolvedUsingTypenameDecl::anchor() { }
2158
John McCalle61f2ba2009-11-18 02:36:19 +00002159UnresolvedUsingTypenameDecl *
2160UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
2161 SourceLocation UsingLoc,
2162 SourceLocation TypenameLoc,
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002163 NestedNameSpecifierLoc QualifierLoc,
John McCalle61f2ba2009-11-18 02:36:19 +00002164 SourceLocation TargetNameLoc,
2165 DeclarationName TargetName) {
Richard Smithf7981722013-11-22 09:01:48 +00002166 return new (C, DC) UnresolvedUsingTypenameDecl(
2167 DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc,
2168 TargetName.getAsIdentifierInfo());
Anders Carlsson8305c1f2009-08-28 05:30:28 +00002169}
2170
Douglas Gregor72172e92012-01-05 21:55:30 +00002171UnresolvedUsingTypenameDecl *
2172UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00002173 return new (C, ID) UnresolvedUsingTypenameDecl(
Craig Topper36250ad2014-05-12 05:36:57 +00002174 nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
2175 SourceLocation(), nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002176}
2177
David Blaikie68e081d2011-12-20 02:48:34 +00002178void StaticAssertDecl::anchor() { }
2179
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00002180StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnaraea947882011-03-08 16:41:52 +00002181 SourceLocation StaticAssertLoc,
2182 Expr *AssertExpr,
2183 StringLiteral *Message,
Richard Smithded9c2e2012-07-11 22:37:56 +00002184 SourceLocation RParenLoc,
2185 bool Failed) {
Richard Smithf7981722013-11-22 09:01:48 +00002186 return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2187 RParenLoc, Failed);
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00002188}
2189
Richard Smithf7981722013-11-22 09:01:48 +00002190StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
Douglas Gregor72172e92012-01-05 21:55:30 +00002191 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002192 return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
2193 nullptr, SourceLocation(), false);
Richard Smithf7981722013-11-22 09:01:48 +00002194}
2195
2196MSPropertyDecl *MSPropertyDecl::Create(ASTContext &C, DeclContext *DC,
2197 SourceLocation L, DeclarationName N,
2198 QualType T, TypeSourceInfo *TInfo,
2199 SourceLocation StartL,
2200 IdentifierInfo *Getter,
2201 IdentifierInfo *Setter) {
2202 return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter);
2203}
2204
2205MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C,
2206 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002207 return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
2208 DeclarationName(), QualType(), nullptr,
2209 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002210}
2211
Anders Carlsson6750d162009-03-26 23:46:50 +00002212static const char *getAccessName(AccessSpecifier AS) {
2213 switch (AS) {
Anders Carlsson6750d162009-03-26 23:46:50 +00002214 case AS_none:
David Blaikie83d382b2011-09-23 05:06:16 +00002215 llvm_unreachable("Invalid access specifier!");
Anders Carlsson6750d162009-03-26 23:46:50 +00002216 case AS_public:
2217 return "public";
2218 case AS_private:
2219 return "private";
2220 case AS_protected:
2221 return "protected";
2222 }
David Blaikief47fa302012-01-17 02:30:50 +00002223 llvm_unreachable("Invalid access specifier!");
Anders Carlsson6750d162009-03-26 23:46:50 +00002224}
2225
2226const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2227 AccessSpecifier AS) {
2228 return DB << getAccessName(AS);
2229}
Richard Smith84f6dcf2012-02-02 01:16:57 +00002230
2231const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2232 AccessSpecifier AS) {
2233 return DB << getAccessName(AS);
2234}