blob: 41f2449a9d6a09722764c07d5c5ed8c26326af0f [file] [log] [blame]
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001//===- DeclCXX.cpp - C++ Declaration AST Node Implementation --------------===//
Ted Kremenek21475702008-09-05 17:16:31 +00002//
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//===----------------------------------------------------------------------===//
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000013
Ted Kremenek21475702008-09-05 17:16:31 +000014#include "clang/AST/DeclCXX.h"
15#include "clang/AST/ASTContext.h"
Faisal Vali2b391ab2013-09-26 19:54:12 +000016#include "clang/AST/ASTLambda.h"
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +000017#include "clang/AST/ASTMutationListener.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000018#include "clang/AST/ASTUnresolvedSet.h"
Douglas Gregor8fb95122010-09-29 00:15:42 +000019#include "clang/AST/CXXInheritance.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000020#include "clang/AST/DeclBase.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "clang/AST/DeclTemplate.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000022#include "clang/AST/DeclarationName.h"
Anders Carlsson5bbe1d72009-03-14 00:25:26 +000023#include "clang/AST/Expr.h"
Douglas Gregord73f3dd2011-11-01 01:16:03 +000024#include "clang/AST/ExprCXX.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000025#include "clang/AST/LambdaCapture.h"
26#include "clang/AST/NestedNameSpecifier.h"
Richard Trieue7f7ed22017-02-22 01:11:25 +000027#include "clang/AST/ODRHash.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000028#include "clang/AST/Type.h"
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +000029#include "clang/AST/TypeLoc.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000030#include "clang/AST/UnresolvedSet.h"
31#include "clang/Basic/Diagnostic.h"
Douglas Gregorb6acda02008-11-12 23:21:09 +000032#include "clang/Basic/IdentifierTable.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000033#include "clang/Basic/LLVM.h"
34#include "clang/Basic/LangOptions.h"
35#include "clang/Basic/OperatorKinds.h"
36#include "clang/Basic/PartialDiagnostic.h"
37#include "clang/Basic/SourceLocation.h"
38#include "clang/Basic/Specifiers.h"
39#include "llvm/ADT/None.h"
Fariborz Jahaniana9540492009-09-12 19:52:10 +000040#include "llvm/ADT/SmallPtrSet.h"
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000041#include "llvm/ADT/SmallVector.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/raw_ostream.h"
46#include <algorithm>
47#include <cassert>
48#include <cstddef>
49#include <cstdint>
50
Ted Kremenek21475702008-09-05 17:16:31 +000051using namespace clang;
52
53//===----------------------------------------------------------------------===//
54// Decl Allocation/Deallocation Method Implementations
55//===----------------------------------------------------------------------===//
Douglas Gregor5101c242008-12-05 18:15:24 +000056
Eugene Zelenko4a5354f2017-11-14 23:13:32 +000057void AccessSpecDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +000058
Douglas Gregor72172e92012-01-05 21:55:30 +000059AccessSpecDecl *AccessSpecDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +000060 return new (C, ID) AccessSpecDecl(EmptyShell());
Douglas Gregor72172e92012-01-05 21:55:30 +000061}
62
Richard Smitha4ba74c2013-08-30 04:46:40 +000063void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const {
64 ExternalASTSource *Source = C.getExternalSource();
65 assert(Impl.Decls.isLazy() && "getFromExternalSource for non-lazy set");
66 assert(Source && "getFromExternalSource with no external source");
67
68 for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); ++I)
69 I.setDecl(cast<NamedDecl>(Source->GetExternalDecl(
70 reinterpret_cast<uintptr_t>(I.getDecl()) >> 2)));
71 Impl.Decls.setLazy(false);
72}
73
John McCall67da35c2010-02-04 22:26:26 +000074CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
Nico Weber6a6376b2016-02-19 01:52:46 +000075 : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
76 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
77 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
78 HasPrivateFields(false), HasProtectedFields(false),
79 HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),
80 HasOnlyCMembers(true), HasInClassInitializer(false),
81 HasUninitializedReferenceMember(false), HasUninitializedFields(false),
Richard Smith12e79312016-05-13 06:47:56 +000082 HasInheritedConstructor(false), HasInheritedAssignment(false),
Richard Smith96cd6712017-08-16 01:49:53 +000083 NeedOverloadResolutionForCopyConstructor(false),
Nico Weber6a6376b2016-02-19 01:52:46 +000084 NeedOverloadResolutionForMoveConstructor(false),
85 NeedOverloadResolutionForMoveAssignment(false),
86 NeedOverloadResolutionForDestructor(false),
Richard Smith96cd6712017-08-16 01:49:53 +000087 DefaultedCopyConstructorIsDeleted(false),
Nico Weber6a6376b2016-02-19 01:52:46 +000088 DefaultedMoveConstructorIsDeleted(false),
89 DefaultedMoveAssignmentIsDeleted(false),
90 DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All),
91 DeclaredNonTrivialSpecialMembers(0), HasIrrelevantDestructor(true),
92 HasConstexprNonCopyMoveConstructor(false),
Nico Weber72c57f42016-02-24 20:58:14 +000093 HasDefaultedDefaultConstructor(false),
Richard Smith96cd6712017-08-16 01:49:53 +000094 CanPassInRegisters(true),
Nico Weber6a6376b2016-02-19 01:52:46 +000095 DefaultedDefaultConstructorIsConstexpr(true),
96 HasConstexprDefaultConstructor(false),
97 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
98 UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
Richard Smithdf054d32017-02-25 23:53:05 +000099 ImplicitCopyConstructorCanHaveConstParamForVBase(true),
100 ImplicitCopyConstructorCanHaveConstParamForNonVBase(true),
Nico Weber6a6376b2016-02-19 01:52:46 +0000101 ImplicitCopyAssignmentHasConstParam(true),
102 HasDeclaredCopyConstructorWithConstParam(false),
103 HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false),
Eugene Zelenko4a5354f2017-11-14 23:13:32 +0000104 IsParsingBaseSpecifiers(false), HasODRHash(false), Definition(D) {}
John McCall67da35c2010-02-04 22:26:26 +0000105
Benjamin Kramer300c0632012-07-04 17:03:33 +0000106CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
107 return Bases.get(Definition->getASTContext().getExternalSource());
108}
109
110CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
111 return VBases.get(Definition->getASTContext().getExternalSource());
112}
113
Richard Smith053f6c62014-05-16 23:01:30 +0000114CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C,
115 DeclContext *DC, SourceLocation StartLoc,
116 SourceLocation IdLoc, IdentifierInfo *Id,
117 CXXRecordDecl *PrevDecl)
118 : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl),
119 DefinitionData(PrevDecl ? PrevDecl->DefinitionData
Eugene Zelenko4a5354f2017-11-14 23:13:32 +0000120 : nullptr) {}
Douglas Gregorb6acda02008-11-12 23:21:09 +0000121
Jay Foad39c79802011-01-12 09:06:06 +0000122CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
Abramo Bagnara29c2d462011-03-09 14:09:51 +0000123 DeclContext *DC, SourceLocation StartLoc,
124 SourceLocation IdLoc, IdentifierInfo *Id,
Richard Smithbecb92d2017-10-10 22:33:17 +0000125 CXXRecordDecl *PrevDecl,
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +0000126 bool DelayTypeCreation) {
Richard Smith053f6c62014-05-16 23:01:30 +0000127 CXXRecordDecl *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc,
Richard Smithf7981722013-11-22 09:01:48 +0000128 IdLoc, Id, PrevDecl);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000129 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
Mike Stump11289f42009-09-09 15:08:12 +0000130
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +0000131 // FIXME: DelayTypeCreation seems like such a hack
Douglas Gregor1ec5e9f2009-05-15 19:11:46 +0000132 if (!DelayTypeCreation)
Mike Stump11289f42009-09-09 15:08:12 +0000133 C.getTypeDeclType(R, PrevDecl);
Ted Kremenek21475702008-09-05 17:16:31 +0000134 return R;
135}
136
Richard Smith053f6c62014-05-16 23:01:30 +0000137CXXRecordDecl *
138CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
139 TypeSourceInfo *Info, SourceLocation Loc,
140 bool Dependent, bool IsGeneric,
141 LambdaCaptureDefault CaptureDefault) {
Richard Smithf7981722013-11-22 09:01:48 +0000142 CXXRecordDecl *R =
Richard Smith053f6c62014-05-16 23:01:30 +0000143 new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
144 nullptr, nullptr);
Douglas Gregorc8a73492012-02-13 15:44:47 +0000145 R->IsBeingDefined = true;
Richard Smith64c06302014-05-22 23:19:02 +0000146 R->DefinitionData =
Richard Smith053f6c62014-05-16 23:01:30 +0000147 new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
Richard Smith64c06302014-05-22 23:19:02 +0000148 CaptureDefault);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000149 R->MayHaveOutOfDateDef = false;
James Dennett8f60cdd2013-09-05 17:46:21 +0000150 R->setImplicit(true);
Craig Topper36250ad2014-05-12 05:36:57 +0000151 C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
Douglas Gregorc8a73492012-02-13 15:44:47 +0000152 return R;
153}
154
Douglas Gregor72172e92012-01-05 21:55:30 +0000155CXXRecordDecl *
156CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +0000157 CXXRecordDecl *R = new (C, ID) CXXRecordDecl(
Richard Smith053f6c62014-05-16 23:01:30 +0000158 CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +0000159 nullptr, nullptr);
Douglas Gregor7dab26b2013-02-09 01:35:03 +0000160 R->MayHaveOutOfDateDef = false;
161 return R;
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +0000162}
163
Mike Stump11289f42009-09-09 15:08:12 +0000164void
Craig Toppere6337e12015-12-25 00:36:02 +0000165CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
166 unsigned NumBases) {
Douglas Gregor4a62bdf2010-02-11 01:30:34 +0000167 ASTContext &C = getASTContext();
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +0000168
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000169 if (!data().Bases.isOffset() && data().NumBases > 0)
170 C.Deallocate(data().getBases());
Mike Stump11289f42009-09-09 15:08:12 +0000171
Craig Toppere6337e12015-12-25 00:36:02 +0000172 if (NumBases) {
Aaron Ballmanc351fba2017-12-04 20:27:34 +0000173 if (!C.getLangOpts().CPlusPlus17) {
Richard Smith872307e2016-03-08 22:17:41 +0000174 // C++ [dcl.init.aggr]p1:
175 // An aggregate is [...] a class with [...] no base classes [...].
176 data().Aggregate = false;
177 }
Richard Smithaed32b42011-10-18 20:08:55 +0000178
179 // C++ [class]p4:
180 // A POD-struct is an aggregate class...
181 data().PlainOldData = false;
182 }
183
Anders Carlssonabb20e62010-03-29 05:13:12 +0000184 // The set of seen virtual base types.
Anders Carlssone47380f2010-03-29 19:49:09 +0000185 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000186
187 // The virtual bases of this class.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000188 SmallVector<const CXXBaseSpecifier *, 8> VBases;
Mike Stump11289f42009-09-09 15:08:12 +0000189
Craig Toppere6337e12015-12-25 00:36:02 +0000190 data().Bases = new(C) CXXBaseSpecifier [NumBases];
191 data().NumBases = NumBases;
192 for (unsigned i = 0; i < NumBases; ++i) {
Douglas Gregord4c5ed02010-10-29 22:39:52 +0000193 data().getBases()[i] = *Bases[i];
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000194 // Keep track of inherited vbases for this base class.
195 const CXXBaseSpecifier *Base = Bases[i];
196 QualType BaseType = Base->getType();
Douglas Gregorbeab56e2010-02-27 00:25:28 +0000197 // Skip dependent types; we can't do any checking on them now.
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000198 if (BaseType->isDependentType())
199 continue;
200 CXXRecordDecl *BaseClassDecl
Ted Kremenekc23c7e62009-07-29 21:53:49 +0000201 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
Anders Carlssonabb20e62010-03-29 05:13:12 +0000202
Chandler Carruthb1963742011-04-30 09:17:45 +0000203 if (!BaseClassDecl->isEmpty()) {
204 if (!data().Empty) {
205 // C++0x [class]p7:
206 // A standard-layout class is a class that:
207 // [...]
208 // -- either has no non-static data members in the most derived
209 // class and at most one base class with non-static data members,
210 // or has no base classes with non-static data members, and
211 // If this is the second non-empty base, then neither of these two
212 // clauses can be true.
Chandler Carruth583edf82011-04-30 10:07:30 +0000213 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000214 }
215
David Majnemer5cfda6f2016-05-22 05:34:26 +0000216 // C++14 [meta.unary.prop]p4:
217 // T is a class type [...] with [...] no base class B for which
218 // is_empty<B>::value is false.
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000219 data().Empty = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000220 data().HasNoNonEmptyBases = false;
221 }
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000222
Richard Smith872307e2016-03-08 22:17:41 +0000223 // C++1z [dcl.init.agg]p1:
224 // An aggregate is a class with [...] no private or protected base classes
225 if (Base->getAccessSpecifier() != AS_public)
226 data().Aggregate = false;
227
Douglas Gregor11c024b2010-09-28 20:50:54 +0000228 // C++ [class.virtual]p1:
229 // A class that declares or inherits a virtual function is called a
230 // polymorphic class.
231 if (BaseClassDecl->isPolymorphic())
232 data().Polymorphic = true;
Chandler Carruthe71d0622011-04-24 02:49:34 +0000233
Chandler Carruthb1963742011-04-30 09:17:45 +0000234 // C++0x [class]p7:
235 // A standard-layout class is a class that: [...]
236 // -- has no non-standard-layout base classes
Chandler Carruth583edf82011-04-30 10:07:30 +0000237 if (!BaseClassDecl->isStandardLayout())
238 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000239
Chandler Carruthe71d0622011-04-24 02:49:34 +0000240 // Record if this base is the first non-literal field or base.
Richard Smithd9f663b2013-04-22 15:31:51 +0000241 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C))
Chandler Carruthe71d0622011-04-24 02:49:34 +0000242 data().HasNonLiteralTypeFieldsOrBases = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000243
Anders Carlssonabb20e62010-03-29 05:13:12 +0000244 // Now go through all virtual bases of this base and add them.
Aaron Ballman445a9392014-03-13 16:15:17 +0000245 for (const auto &VBase : BaseClassDecl->vbases()) {
Anders Carlssonabb20e62010-03-29 05:13:12 +0000246 // Add this base if it's not already in the list.
David Blaikie82e95a32014-11-19 07:49:47 +0000247 if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
Aaron Ballman445a9392014-03-13 16:15:17 +0000248 VBases.push_back(&VBase);
Richard Smith1c33fe82012-11-28 06:23:12 +0000249
250 // C++11 [class.copy]p8:
251 // The implicitly-declared copy constructor for a class X will have
252 // the form 'X::X(const X&)' if each [...] virtual base class B of X
253 // has a copy constructor whose first parameter is of type
254 // 'const B&' or 'const volatile B&' [...]
Aaron Ballman445a9392014-03-13 16:15:17 +0000255 if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())
Richard Smith1c33fe82012-11-28 06:23:12 +0000256 if (!VBaseDecl->hasCopyConstructorWithConstParam())
Richard Smithdf054d32017-02-25 23:53:05 +0000257 data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;
Richard Smith872307e2016-03-08 22:17:41 +0000258
259 // C++1z [dcl.init.agg]p1:
260 // An aggregate is a class with [...] no virtual base classes
261 data().Aggregate = false;
Richard Smith1c33fe82012-11-28 06:23:12 +0000262 }
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000263 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000264
265 if (Base->isVirtual()) {
266 // Add this base if it's not already in the list.
David Blaikie82e95a32014-11-19 07:49:47 +0000267 if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
Richard Smith1c33fe82012-11-28 06:23:12 +0000268 VBases.push_back(Base);
269
David Majnemer5cfda6f2016-05-22 05:34:26 +0000270 // C++14 [meta.unary.prop] is_empty:
271 // T is a class type, but not a union type, with ... no virtual base
272 // classes
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000273 data().Empty = false;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000274
Richard Smith872307e2016-03-08 22:17:41 +0000275 // C++1z [dcl.init.agg]p1:
276 // An aggregate is a class with [...] no virtual base classes
277 data().Aggregate = false;
278
Richard Smith328aae52012-11-30 05:11:39 +0000279 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
280 // A [default constructor, copy/move constructor, or copy/move assignment
281 // operator for a class X] is trivial [...] if:
282 // -- class X has [...] no virtual base classes
283 data().HasTrivialSpecialMembers &= SMF_Destructor;
Chandler Carruthb1963742011-04-30 09:17:45 +0000284
285 // C++0x [class]p7:
286 // A standard-layout class is a class that: [...]
287 // -- has [...] no virtual base classes
Chandler Carruth583edf82011-04-30 10:07:30 +0000288 data().IsStandardLayout = false;
Richard Smithcc36f692011-12-22 02:22:31 +0000289
290 // C++11 [dcl.constexpr]p4:
291 // In the definition of a constexpr constructor [...]
292 // -- the class shall not have any virtual base classes
293 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smithdf054d32017-02-25 23:53:05 +0000294
295 // C++1z [class.copy]p8:
296 // The implicitly-declared copy constructor for a class X will have
297 // the form 'X::X(const X&)' if each potentially constructed subobject
298 // has a copy constructor whose first parameter is of type
299 // 'const B&' or 'const volatile B&' [...]
300 if (!BaseClassDecl->hasCopyConstructorWithConstParam())
301 data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000302 } else {
303 // C++ [class.ctor]p5:
Alexis Huntf479f1b2011-05-09 18:22:59 +0000304 // A default constructor is trivial [...] if:
305 // -- all the direct base classes of its class have trivial default
306 // constructors.
307 if (!BaseClassDecl->hasTrivialDefaultConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000308 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
309
Chandler Carruthad7d4042011-04-23 23:10:33 +0000310 // C++0x [class.copy]p13:
311 // A copy/move constructor for class X is trivial if [...]
312 // [...]
313 // -- the constructor selected to copy/move each direct base class
314 // subobject is trivial, and
Douglas Gregor11c024b2010-09-28 20:50:54 +0000315 if (!BaseClassDecl->hasTrivialCopyConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000316 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
Richard Smith6b02d462012-12-08 08:32:28 +0000317 // If the base class doesn't have a simple move constructor, we'll eagerly
318 // declare it and perform overload resolution to determine which function
319 // it actually calls. If it does have a simple move constructor, this
320 // check is correct.
Richard Smith16488472012-11-16 00:53:38 +0000321 if (!BaseClassDecl->hasTrivialMoveConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000322 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000323
324 // C++0x [class.copy]p27:
325 // A copy/move assignment operator for class X is trivial if [...]
326 // [...]
327 // -- the assignment operator selected to copy/move each direct base
328 // class subobject is trivial, and
Douglas Gregor11c024b2010-09-28 20:50:54 +0000329 if (!BaseClassDecl->hasTrivialCopyAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000330 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
Richard Smith6b02d462012-12-08 08:32:28 +0000331 // If the base class doesn't have a simple move assignment, we'll eagerly
332 // declare it and perform overload resolution to determine which function
333 // it actually calls. If it does have a simple move assignment, this
334 // check is correct.
Richard Smith16488472012-11-16 00:53:38 +0000335 if (!BaseClassDecl->hasTrivialMoveAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000336 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
Richard Smithcc36f692011-12-22 02:22:31 +0000337
338 // C++11 [class.ctor]p6:
Richard Smithc101e612012-01-11 18:26:05 +0000339 // If that user-written default constructor would satisfy the
Richard Smithcc36f692011-12-22 02:22:31 +0000340 // requirements of a constexpr constructor, the implicitly-defined
341 // default constructor is constexpr.
342 if (!BaseClassDecl->hasConstexprDefaultConstructor())
343 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smithdf054d32017-02-25 23:53:05 +0000344
345 // C++1z [class.copy]p8:
346 // The implicitly-declared copy constructor for a class X will have
347 // the form 'X::X(const X&)' if each potentially constructed subobject
348 // has a copy constructor whose first parameter is of type
349 // 'const B&' or 'const volatile B&' [...]
350 if (!BaseClassDecl->hasCopyConstructorWithConstParam())
351 data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000352 }
Richard Smith92f241f2012-12-08 02:53:02 +0000353
Douglas Gregor11c024b2010-09-28 20:50:54 +0000354 // C++ [class.ctor]p3:
355 // A destructor is trivial if all the direct base classes of its class
356 // have trivial destructors.
357 if (!BaseClassDecl->hasTrivialDestructor())
Richard Smith328aae52012-11-30 05:11:39 +0000358 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000359
360 if (!BaseClassDecl->hasIrrelevantDestructor())
361 data().HasIrrelevantDestructor = false;
362
Richard Smith1c33fe82012-11-28 06:23:12 +0000363 // C++11 [class.copy]p18:
364 // The implicitly-declared copy assignment oeprator for a class X will
365 // have the form 'X& X::operator=(const X&)' if each direct base class B
366 // of X has a copy assignment operator whose parameter is of type 'const
367 // B&', 'const volatile B&', or 'B' [...]
368 if (!BaseClassDecl->hasCopyAssignmentWithConstParam())
369 data().ImplicitCopyAssignmentHasConstParam = false;
370
John McCall31168b02011-06-15 23:02:42 +0000371 // A class has an Objective-C object member if... or any of its bases
372 // has an Objective-C object member.
373 if (BaseClassDecl->hasObjectMember())
374 setHasObjectMember(true);
Fariborz Jahanian78652202013-01-25 23:57:05 +0000375
376 if (BaseClassDecl->hasVolatileMember())
377 setHasVolatileMember(true);
John McCall31168b02011-06-15 23:02:42 +0000378
Douglas Gregor61226d32011-05-13 01:05:07 +0000379 // Keep track of the presence of mutable fields.
Richard Smith96cd6712017-08-16 01:49:53 +0000380 if (BaseClassDecl->hasMutableFields()) {
Douglas Gregor61226d32011-05-13 01:05:07 +0000381 data().HasMutableFields = true;
Richard Smith96cd6712017-08-16 01:49:53 +0000382 data().NeedOverloadResolutionForCopyConstructor = true;
383 }
Richard Smith593f9932012-12-08 02:01:17 +0000384
385 if (BaseClassDecl->hasUninitializedReferenceMember())
386 data().HasUninitializedReferenceMember = true;
Richard Smith6b02d462012-12-08 08:32:28 +0000387
Nico Weber6a6376b2016-02-19 01:52:46 +0000388 if (!BaseClassDecl->allowConstDefaultInit())
389 data().HasUninitializedFields = true;
390
Richard Smith6b02d462012-12-08 08:32:28 +0000391 addedClassSubobject(BaseClassDecl);
Fariborz Jahanian3554b5a2009-07-10 20:13:23 +0000392 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000393
David Majnemer5ef4fe72014-06-13 06:43:46 +0000394 if (VBases.empty()) {
395 data().IsParsingBaseSpecifiers = false;
Anders Carlssonabb20e62010-03-29 05:13:12 +0000396 return;
David Majnemer5ef4fe72014-06-13 06:43:46 +0000397 }
Anders Carlssonabb20e62010-03-29 05:13:12 +0000398
399 // Create base specifier for any direct or indirect virtual bases.
400 data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
401 data().NumVBases = VBases.size();
Richard Smith6b02d462012-12-08 08:32:28 +0000402 for (int I = 0, E = VBases.size(); I != E; ++I) {
403 QualType Type = VBases[I]->getType();
404 if (!Type->isDependentType())
405 addedClassSubobject(Type->getAsCXXRecordDecl());
Richard Smith26935e62011-07-12 23:49:11 +0000406 data().getVBases()[I] = *VBases[I];
Richard Smith6b02d462012-12-08 08:32:28 +0000407 }
David Majnemer5ef4fe72014-06-13 06:43:46 +0000408
409 data().IsParsingBaseSpecifiers = false;
Richard Smith6b02d462012-12-08 08:32:28 +0000410}
411
Richard Trieufd1acbb2017-04-11 21:31:00 +0000412unsigned CXXRecordDecl::getODRHash() const {
413 assert(hasDefinition() && "ODRHash only for records with definitions");
Richard Trieue7f7ed22017-02-22 01:11:25 +0000414
Richard Trieufd1acbb2017-04-11 21:31:00 +0000415 // Previously calculated hash is stored in DefinitionData.
416 if (DefinitionData->HasODRHash)
417 return DefinitionData->ODRHash;
418
419 // Only calculate hash on first call of getODRHash per record.
Richard Trieue7f7ed22017-02-22 01:11:25 +0000420 ODRHash Hash;
Richard Trieufd1acbb2017-04-11 21:31:00 +0000421 Hash.AddCXXRecordDecl(getDefinition());
422 DefinitionData->HasODRHash = true;
Richard Trieue7f7ed22017-02-22 01:11:25 +0000423 DefinitionData->ODRHash = Hash.CalculateHash();
Richard Trieufd1acbb2017-04-11 21:31:00 +0000424
425 return DefinitionData->ODRHash;
Richard Trieue7f7ed22017-02-22 01:11:25 +0000426}
Richard Trieub6adf542017-02-18 02:09:28 +0000427
Richard Smith6b02d462012-12-08 08:32:28 +0000428void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) {
429 // C++11 [class.copy]p11:
430 // A defaulted copy/move constructor for a class X is defined as
431 // deleted if X has:
432 // -- a direct or virtual base class B that cannot be copied/moved [...]
433 // -- a non-static data member of class type M (or array thereof)
434 // that cannot be copied or moved [...]
Richard Smith96cd6712017-08-16 01:49:53 +0000435 if (!Subobj->hasSimpleCopyConstructor())
436 data().NeedOverloadResolutionForCopyConstructor = true;
Richard Smith6b02d462012-12-08 08:32:28 +0000437 if (!Subobj->hasSimpleMoveConstructor())
438 data().NeedOverloadResolutionForMoveConstructor = true;
439
440 // C++11 [class.copy]p23:
441 // A defaulted copy/move assignment operator for a class X is defined as
442 // deleted if X has:
443 // -- a direct or virtual base class B that cannot be copied/moved [...]
444 // -- a non-static data member of class type M (or array thereof)
445 // that cannot be copied or moved [...]
446 if (!Subobj->hasSimpleMoveAssignment())
447 data().NeedOverloadResolutionForMoveAssignment = true;
448
449 // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5:
450 // A defaulted [ctor or dtor] for a class X is defined as
451 // deleted if X has:
452 // -- any direct or virtual base class [...] has a type with a destructor
453 // that is deleted or inaccessible from the defaulted [ctor or dtor].
454 // -- any non-static data member has a type with a destructor
455 // that is deleted or inaccessible from the defaulted [ctor or dtor].
456 if (!Subobj->hasSimpleDestructor()) {
Richard Smith96cd6712017-08-16 01:49:53 +0000457 data().NeedOverloadResolutionForCopyConstructor = true;
Richard Smith6b02d462012-12-08 08:32:28 +0000458 data().NeedOverloadResolutionForMoveConstructor = true;
459 data().NeedOverloadResolutionForDestructor = true;
460 }
Douglas Gregor9d6290b2008-10-23 18:13:27 +0000461}
462
Douglas Gregord2e6a452010-01-14 17:47:39 +0000463bool CXXRecordDecl::hasAnyDependentBases() const {
464 if (!isDependentContext())
465 return false;
466
Benjamin Kramer6e4f6e12015-07-25 15:07:25 +0000467 return !forallBases([](const CXXRecordDecl *) { return true; });
Douglas Gregord2e6a452010-01-14 17:47:39 +0000468}
469
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000470bool CXXRecordDecl::isTriviallyCopyable() const {
471 // C++0x [class]p5:
472 // A trivially copyable class is a class that:
473 // -- has no non-trivial copy constructors,
Richard Smith16488472012-11-16 00:53:38 +0000474 if (hasNonTrivialCopyConstructor()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000475 // -- has no non-trivial move constructors,
Richard Smith16488472012-11-16 00:53:38 +0000476 if (hasNonTrivialMoveConstructor()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000477 // -- has no non-trivial copy assignment operators,
Richard Smith16488472012-11-16 00:53:38 +0000478 if (hasNonTrivialCopyAssignment()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000479 // -- has no non-trivial move assignment operators, and
Richard Smith16488472012-11-16 00:53:38 +0000480 if (hasNonTrivialMoveAssignment()) return false;
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000481 // -- has a trivial destructor.
482 if (!hasTrivialDestructor()) return false;
483
484 return true;
485}
486
Douglas Gregor7d9120c2010-09-28 21:55:22 +0000487void CXXRecordDecl::markedVirtualFunctionPure() {
488 // C++ [class.abstract]p2:
489 // A class is abstract if it has at least one pure virtual function.
490 data().Abstract = true;
491}
492
493void CXXRecordDecl::addedMember(Decl *D) {
Joao Matose9a3ed42012-08-31 22:18:20 +0000494 if (!D->isImplicit() &&
495 !isa<FieldDecl>(D) &&
496 !isa<IndirectFieldDecl>(D) &&
497 (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
498 cast<TagDecl>(D)->getTagKind() == TTK_Interface))
499 data().HasOnlyCMembers = false;
500
501 // Ignore friends and invalid declarations.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000502 if (D->getFriendObjectKind() || D->isInvalidDecl())
Douglas Gregord30e79f2010-09-27 21:17:54 +0000503 return;
504
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000505 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
506 if (FunTmpl)
507 D = FunTmpl->getTemplatedDecl();
Richard Smith5179eb72016-06-28 19:03:57 +0000508
509 // FIXME: Pass NamedDecl* to addedMember?
510 Decl *DUnderlying = D;
511 if (auto *ND = dyn_cast<NamedDecl>(DUnderlying)) {
512 DUnderlying = ND->getUnderlyingDecl();
513 if (FunctionTemplateDecl *UnderlyingFunTmpl =
514 dyn_cast<FunctionTemplateDecl>(DUnderlying))
515 DUnderlying = UnderlyingFunTmpl->getTemplatedDecl();
516 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000517
Douglas Gregora832d3e2010-09-28 19:45:33 +0000518 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
519 if (Method->isVirtual()) {
520 // C++ [dcl.init.aggr]p1:
521 // An aggregate is an array or a class with [...] no virtual functions.
522 data().Aggregate = false;
523
524 // C++ [class]p4:
525 // A POD-struct is an aggregate class...
526 data().PlainOldData = false;
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000527
David Majnemer5cfda6f2016-05-22 05:34:26 +0000528 // C++14 [meta.unary.prop]p4:
529 // T is a class type [...] with [...] no virtual member functions...
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000530 data().Empty = false;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000531
532 // C++ [class.virtual]p1:
533 // A class that declares or inherits a virtual function is called a
534 // polymorphic class.
535 data().Polymorphic = true;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000536
Richard Smith328aae52012-11-30 05:11:39 +0000537 // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
538 // A [default constructor, copy/move constructor, or copy/move
539 // assignment operator for a class X] is trivial [...] if:
Chandler Carruthad7d4042011-04-23 23:10:33 +0000540 // -- class X has no virtual functions [...]
Richard Smith328aae52012-11-30 05:11:39 +0000541 data().HasTrivialSpecialMembers &= SMF_Destructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000542
Chandler Carruthb1963742011-04-30 09:17:45 +0000543 // C++0x [class]p7:
544 // A standard-layout class is a class that: [...]
545 // -- has no virtual functions
Chandler Carruth583edf82011-04-30 10:07:30 +0000546 data().IsStandardLayout = false;
Douglas Gregora832d3e2010-09-28 19:45:33 +0000547 }
548 }
Argyrios Kyrtzidis00f52662010-10-20 23:48:42 +0000549
Richard Smith1c33fe82012-11-28 06:23:12 +0000550 // Notify the listener if an implicit member was added after the definition
551 // was completed.
552 if (!isBeingDefined() && D->isImplicit())
553 if (ASTMutationListener *L = getASTMutationListener())
554 L->AddedCXXImplicitMember(data().Definition, D);
Douglas Gregor9d5938a2010-09-28 20:38:10 +0000555
Richard Smith328aae52012-11-30 05:11:39 +0000556 // The kind of special member this declaration is, if any.
557 unsigned SMKind = 0;
558
Richard Smith1c33fe82012-11-28 06:23:12 +0000559 // Handle constructors.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000560 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
Richard Smith1c33fe82012-11-28 06:23:12 +0000561 if (!Constructor->isImplicit()) {
562 // Note that we have a user-declared constructor.
563 data().UserDeclaredConstructor = true;
564
565 // C++ [class]p4:
566 // A POD-struct is an aggregate class [...]
567 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
568 // type is technically an aggregate in C++0x since it wouldn't be in 03.
569 data().PlainOldData = false;
570 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000571
Alexis Hunt88c75c32011-05-09 21:45:35 +0000572 if (Constructor->isDefaultConstructor()) {
Richard Smith328aae52012-11-30 05:11:39 +0000573 SMKind |= SMF_DefaultConstructor;
574
Richard Smith5179eb72016-06-28 19:03:57 +0000575 if (Constructor->isUserProvided())
Alexis Huntea6f0322011-05-11 22:34:38 +0000576 data().UserProvidedDefaultConstructor = true;
Richard Smith1c33fe82012-11-28 06:23:12 +0000577 if (Constructor->isConstexpr())
Richard Smithcc36f692011-12-22 02:22:31 +0000578 data().HasConstexprDefaultConstructor = true;
Nico Weber72c57f42016-02-24 20:58:14 +0000579 if (Constructor->isDefaulted())
580 data().HasDefaultedDefaultConstructor = true;
Alexis Hunt88c75c32011-05-09 21:45:35 +0000581 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000582
Chandler Carruthad7d4042011-04-23 23:10:33 +0000583 if (!FunTmpl) {
Richard Smith1c33fe82012-11-28 06:23:12 +0000584 unsigned Quals;
585 if (Constructor->isCopyConstructor(Quals)) {
Richard Smith328aae52012-11-30 05:11:39 +0000586 SMKind |= SMF_CopyConstructor;
Richard Smith1c33fe82012-11-28 06:23:12 +0000587
588 if (Quals & Qualifiers::Const)
589 data().HasDeclaredCopyConstructorWithConstParam = true;
Richard Smith328aae52012-11-30 05:11:39 +0000590 } else if (Constructor->isMoveConstructor())
591 SMKind |= SMF_MoveConstructor;
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000592 }
Eric Fiselier283d8d42016-12-03 01:26:47 +0000593
Eric Fiselier283d8d42016-12-03 01:26:47 +0000594 // C++11 [dcl.init.aggr]p1: DR1518
Richard Smith505ef812016-12-21 01:57:02 +0000595 // An aggregate is an array or a class with no user-provided, explicit, or
596 // inherited constructors
597 if (Constructor->isUserProvided() || Constructor->isExplicit())
Eric Fiselier283d8d42016-12-03 01:26:47 +0000598 data().Aggregate = false;
Richard Smith5179eb72016-06-28 19:03:57 +0000599 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000600
Richard Smith5179eb72016-06-28 19:03:57 +0000601 // Handle constructors, including those inherited from base classes.
602 if (CXXConstructorDecl *Constructor =
603 dyn_cast<CXXConstructorDecl>(DUnderlying)) {
Richard Smith1c33fe82012-11-28 06:23:12 +0000604 // Record if we see any constexpr constructors which are neither copy
605 // nor move constructors.
Richard Smith5179eb72016-06-28 19:03:57 +0000606 // C++1z [basic.types]p10:
607 // [...] has at least one constexpr constructor or constructor template
608 // (possibly inherited from a base class) that is not a copy or move
609 // constructor [...]
Richard Smith1c33fe82012-11-28 06:23:12 +0000610 if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
Richard Smith111af8d2011-08-10 18:11:37 +0000611 data().HasConstexprNonCopyMoveConstructor = true;
Douglas Gregord30e79f2010-09-27 21:17:54 +0000612 }
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000613
Richard Smith1c33fe82012-11-28 06:23:12 +0000614 // Handle destructors.
Alexis Hunt97ab5542011-05-16 22:41:40 +0000615 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
Richard Smith328aae52012-11-30 05:11:39 +0000616 SMKind |= SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000617
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000618 if (DD->isUserProvided())
Richard Smith1c33fe82012-11-28 06:23:12 +0000619 data().HasIrrelevantDestructor = false;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +0000620 // If the destructor is explicitly defaulted and not trivial or not public
621 // or if the destructor is deleted, we clear HasIrrelevantDestructor in
622 // finishedDefaultedOrDeletedMember.
Richard Smith1c33fe82012-11-28 06:23:12 +0000623
Richard Smith1c33fe82012-11-28 06:23:12 +0000624 // C++11 [class.dtor]p5:
Richard Smith328aae52012-11-30 05:11:39 +0000625 // A destructor is trivial if [...] the destructor is not virtual.
626 if (DD->isVirtual())
627 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Douglas Gregor8f9ebe52010-09-27 22:48:58 +0000628 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000629
630 // Handle member functions.
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000631 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Alexis Huntfcaeae42011-05-25 20:50:04 +0000632 if (Method->isCopyAssignmentOperator()) {
Richard Smith328aae52012-11-30 05:11:39 +0000633 SMKind |= SMF_CopyAssignment;
Richard Smith1c33fe82012-11-28 06:23:12 +0000634
635 const ReferenceType *ParamTy =
636 Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
637 if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
638 data().HasDeclaredCopyAssignmentWithConstParam = true;
Alexis Huntfcaeae42011-05-25 20:50:04 +0000639 }
Alexis Huntfcaeae42011-05-25 20:50:04 +0000640
Richard Smith328aae52012-11-30 05:11:39 +0000641 if (Method->isMoveAssignmentOperator())
642 SMKind |= SMF_MoveAssignment;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000643
Douglas Gregor457104e2010-09-29 04:25:11 +0000644 // Keep the list of conversion functions up-to-date.
645 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
Douglas Gregor92fde2f2013-04-08 17:12:58 +0000646 // FIXME: We use the 'unsafe' accessor for the access specifier here,
647 // because Sema may not have set it yet. That's really just a misdesign
648 // in Sema. However, LLDB *will* have set the access specifier correctly,
649 // and adds declarations after the class is technically completed,
650 // so completeDefinition()'s overriding of the access specifiers doesn't
651 // work.
652 AccessSpecifier AS = Conversion->getAccessUnsafe();
653
Richard Smith328aae52012-11-30 05:11:39 +0000654 if (Conversion->getPrimaryTemplate()) {
655 // We don't record specializations.
Douglas Gregor457104e2010-09-29 04:25:11 +0000656 } else {
Richard Smitha4ba74c2013-08-30 04:46:40 +0000657 ASTContext &Ctx = getASTContext();
658 ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);
659 NamedDecl *Primary =
660 FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion);
661 if (Primary->getPreviousDecl())
662 Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),
663 Primary, AS);
Douglas Gregor457104e2010-09-29 04:25:11 +0000664 else
Richard Smitha4ba74c2013-08-30 04:46:40 +0000665 Conversions.addDecl(Ctx, Primary, AS);
Douglas Gregor457104e2010-09-29 04:25:11 +0000666 }
667 }
Richard Smith1c33fe82012-11-28 06:23:12 +0000668
Richard Smith328aae52012-11-30 05:11:39 +0000669 if (SMKind) {
Richard Smith92f241f2012-12-08 02:53:02 +0000670 // If this is the first declaration of a special member, we no longer have
671 // an implicit trivial special member.
672 data().HasTrivialSpecialMembers &=
673 data().DeclaredSpecialMembers | ~SMKind;
674
675 if (!Method->isImplicit() && !Method->isUserProvided()) {
676 // This method is user-declared but not user-provided. We can't work out
677 // whether it's trivial yet (not until we get to the end of the class).
678 // We'll handle this method in finishedDefaultedOrDeletedMember.
679 } else if (Method->isTrivial())
680 data().HasTrivialSpecialMembers |= SMKind;
681 else
682 data().DeclaredNonTrivialSpecialMembers |= SMKind;
683
Richard Smith328aae52012-11-30 05:11:39 +0000684 // Note when we have declared a declared special member, and suppress the
685 // implicit declaration of this special member.
686 data().DeclaredSpecialMembers |= SMKind;
687
688 if (!Method->isImplicit()) {
689 data().UserDeclaredSpecialMembers |= SMKind;
690
691 // C++03 [class]p4:
692 // A POD-struct is an aggregate class that has [...] no user-defined
693 // copy assignment operator and no user-defined destructor.
694 //
695 // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
696 // aggregates could not have any constructors, clear it even for an
697 // explicitly defaulted or deleted constructor.
698 // type is technically an aggregate in C++0x since it wouldn't be in 03.
699 //
700 // Also, a user-declared move assignment operator makes a class non-POD.
701 // This is an extension in C++03.
702 data().PlainOldData = false;
703 }
Richard Smith328aae52012-11-30 05:11:39 +0000704 }
705
Douglas Gregora1ce1f82010-09-27 22:06:20 +0000706 return;
Douglas Gregor8a273912009-07-22 18:25:24 +0000707 }
Richard Smith328aae52012-11-30 05:11:39 +0000708
Douglas Gregora832d3e2010-09-28 19:45:33 +0000709 // Handle non-static data members.
710 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
Douglas Gregor556e5862011-10-10 17:22:13 +0000711 // C++ [class.bit]p2:
712 // A declaration for a bit-field that omits the identifier declares an
713 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
714 // initialized.
715 if (Field->isUnnamedBitfield())
716 return;
717
Douglas Gregora832d3e2010-09-28 19:45:33 +0000718 // C++ [dcl.init.aggr]p1:
719 // An aggregate is an array or a class (clause 9) with [...] no
720 // private or protected non-static data members (clause 11).
721 //
722 // A POD must be an aggregate.
723 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
724 data().Aggregate = false;
725 data().PlainOldData = false;
726 }
Chandler Carruthb1963742011-04-30 09:17:45 +0000727
728 // C++0x [class]p7:
729 // A standard-layout class is a class that:
730 // [...]
731 // -- has the same access control for all non-static data members,
732 switch (D->getAccess()) {
733 case AS_private: data().HasPrivateFields = true; break;
734 case AS_protected: data().HasProtectedFields = true; break;
735 case AS_public: data().HasPublicFields = true; break;
David Blaikie83d382b2011-09-23 05:06:16 +0000736 case AS_none: llvm_unreachable("Invalid access specifier");
Chandler Carruthb1963742011-04-30 09:17:45 +0000737 };
738 if ((data().HasPrivateFields + data().HasProtectedFields +
739 data().HasPublicFields) > 1)
Chandler Carruth583edf82011-04-30 10:07:30 +0000740 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000741
Douglas Gregor61226d32011-05-13 01:05:07 +0000742 // Keep track of the presence of mutable fields.
Richard Smith96cd6712017-08-16 01:49:53 +0000743 if (Field->isMutable()) {
Douglas Gregor61226d32011-05-13 01:05:07 +0000744 data().HasMutableFields = true;
Richard Smith96cd6712017-08-16 01:49:53 +0000745 data().NeedOverloadResolutionForCopyConstructor = true;
746 }
Richard Smithab44d5b2013-12-10 08:25:00 +0000747
748 // C++11 [class.union]p8, DR1460:
749 // If X is a union, a non-static data member of X that is not an anonymous
750 // union is a variant member of X.
751 if (isUnion() && !Field->isAnonymousStructOrUnion())
752 data().HasVariantMembers = true;
753
Chandler Carruthad7d4042011-04-23 23:10:33 +0000754 // C++0x [class]p9:
Douglas Gregora832d3e2010-09-28 19:45:33 +0000755 // A POD struct is a class that is both a trivial class and a
756 // standard-layout class, and has no non-static data members of type
757 // non-POD struct, non-POD union (or array of such types).
John McCall31168b02011-06-15 23:02:42 +0000758 //
759 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
760 // that does not explicitly have no lifetime makes the class a non-POD.
Douglas Gregora832d3e2010-09-28 19:45:33 +0000761 ASTContext &Context = getASTContext();
762 QualType T = Context.getBaseElementType(Field->getType());
John McCall31168b02011-06-15 23:02:42 +0000763 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
Brian Kelley036603a2017-03-29 17:31:42 +0000764 if (T.hasNonTrivialObjCLifetime()) {
Ben Langmuir11eab612014-09-26 15:27:29 +0000765 // Objective-C Automatic Reference Counting:
766 // If a class has a non-static data member of Objective-C pointer
767 // type (or array thereof), it is a non-POD type and its
768 // default constructor (if any), copy constructor, move constructor,
769 // copy assignment operator, move assignment operator, and destructor are
770 // non-trivial.
771 setHasObjectMember(true);
772 struct DefinitionData &Data = data();
773 Data.PlainOldData = false;
774 Data.HasTrivialSpecialMembers = 0;
775 Data.HasIrrelevantDestructor = false;
Brian Kelley036603a2017-03-29 17:31:42 +0000776 } else if (!Context.getLangOpts().ObjCAutoRefCount) {
777 setHasObjectMember(true);
Ben Langmuir11eab612014-09-26 15:27:29 +0000778 }
Eli Friedmana5433322013-07-20 01:06:31 +0000779 } else if (!T.isCXX98PODType(Context))
Douglas Gregora832d3e2010-09-28 19:45:33 +0000780 data().PlainOldData = false;
John McCall31168b02011-06-15 23:02:42 +0000781
Chandler Carruthb1963742011-04-30 09:17:45 +0000782 if (T->isReferenceType()) {
Richard Smith593f9932012-12-08 02:01:17 +0000783 if (!Field->hasInClassInitializer())
784 data().HasUninitializedReferenceMember = true;
Chandler Carruthe71d0622011-04-24 02:49:34 +0000785
Chandler Carruthb1963742011-04-30 09:17:45 +0000786 // C++0x [class]p7:
787 // A standard-layout class is a class that:
788 // -- has no non-static data members of type [...] reference,
Chandler Carruth583edf82011-04-30 10:07:30 +0000789 data().IsStandardLayout = false;
Richard Smith96cd6712017-08-16 01:49:53 +0000790
791 // C++1z [class.copy.ctor]p10:
792 // A defaulted copy constructor for a class X is defined as deleted if X has:
793 // -- a non-static data member of rvalue reference type
794 if (T->isRValueReferenceType())
795 data().DefaultedCopyConstructorIsDeleted = true;
Chandler Carruthb1963742011-04-30 09:17:45 +0000796 }
797
Nico Weber6a6376b2016-02-19 01:52:46 +0000798 if (!Field->hasInClassInitializer() && !Field->isMutable()) {
Richard Smith9b182172016-10-28 19:11:18 +0000799 if (CXXRecordDecl *FieldType = T->getAsCXXRecordDecl()) {
Nico Weber344abaa2016-02-19 02:51:07 +0000800 if (FieldType->hasDefinition() && !FieldType->allowConstDefaultInit())
Nico Weber6a6376b2016-02-19 01:52:46 +0000801 data().HasUninitializedFields = true;
802 } else {
803 data().HasUninitializedFields = true;
804 }
805 }
806
Richard Smith3607ffe2012-02-13 03:54:03 +0000807 // Record if this field is the first non-literal or volatile field or base.
Richard Smithd9f663b2013-04-22 15:31:51 +0000808 if (!T->isLiteralType(Context) || T.isVolatileQualified())
Chandler Carruthe71d0622011-04-24 02:49:34 +0000809 data().HasNonLiteralTypeFieldsOrBases = true;
810
Richard Smithab44d5b2013-12-10 08:25:00 +0000811 if (Field->hasInClassInitializer() ||
812 (Field->isAnonymousStructOrUnion() &&
813 Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
Richard Smithe2648ba2012-05-07 01:07:30 +0000814 data().HasInClassInitializer = true;
815
816 // C++11 [class]p5:
Richard Smith938f40b2011-06-11 17:19:42 +0000817 // A default constructor is trivial if [...] no non-static data member
818 // of its class has a brace-or-equal-initializer.
Richard Smith328aae52012-11-30 05:11:39 +0000819 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
Richard Smith938f40b2011-06-11 17:19:42 +0000820
Richard Smithe2648ba2012-05-07 01:07:30 +0000821 // C++11 [dcl.init.aggr]p1:
Richard Smith938f40b2011-06-11 17:19:42 +0000822 // An aggregate is a [...] class with [...] no
823 // brace-or-equal-initializers for non-static data members.
Richard Smith852c9db2013-04-20 22:23:05 +0000824 //
Richard Smith872307e2016-03-08 22:17:41 +0000825 // This rule was removed in C++14.
Aaron Ballmandd69ef32014-08-19 15:55:55 +0000826 if (!getASTContext().getLangOpts().CPlusPlus14)
Richard Smith852c9db2013-04-20 22:23:05 +0000827 data().Aggregate = false;
Richard Smith938f40b2011-06-11 17:19:42 +0000828
Richard Smithe2648ba2012-05-07 01:07:30 +0000829 // C++11 [class]p10:
Richard Smith938f40b2011-06-11 17:19:42 +0000830 // A POD struct is [...] a trivial class.
831 data().PlainOldData = false;
832 }
833
Richard Smith6b02d462012-12-08 08:32:28 +0000834 // C++11 [class.copy]p23:
835 // A defaulted copy/move assignment operator for a class X is defined
836 // as deleted if X has:
837 // -- a non-static data member of reference type
838 if (T->isReferenceType())
839 data().DefaultedMoveAssignmentIsDeleted = true;
840
Douglas Gregor11c024b2010-09-28 20:50:54 +0000841 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
842 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
843 if (FieldRec->getDefinition()) {
Richard Smith6b02d462012-12-08 08:32:28 +0000844 addedClassSubobject(FieldRec);
845
Richard Smithc91d12c2013-11-25 07:07:05 +0000846 // We may need to perform overload resolution to determine whether a
847 // field can be moved if it's const or volatile qualified.
848 if (T.getCVRQualifiers() & (Qualifiers::Const | Qualifiers::Volatile)) {
Richard Smith96cd6712017-08-16 01:49:53 +0000849 // We need to care about 'const' for the copy constructor because an
850 // implicit copy constructor might be declared with a non-const
851 // parameter.
852 data().NeedOverloadResolutionForCopyConstructor = true;
Richard Smithc91d12c2013-11-25 07:07:05 +0000853 data().NeedOverloadResolutionForMoveConstructor = true;
854 data().NeedOverloadResolutionForMoveAssignment = true;
855 }
856
Richard Smith6b02d462012-12-08 08:32:28 +0000857 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
858 // A defaulted [special member] for a class X is defined as
859 // deleted if:
860 // -- X is a union-like class that has a variant member with a
861 // non-trivial [corresponding special member]
862 if (isUnion()) {
Richard Smith96cd6712017-08-16 01:49:53 +0000863 if (FieldRec->hasNonTrivialCopyConstructor())
864 data().DefaultedCopyConstructorIsDeleted = true;
Richard Smith6b02d462012-12-08 08:32:28 +0000865 if (FieldRec->hasNonTrivialMoveConstructor())
866 data().DefaultedMoveConstructorIsDeleted = true;
867 if (FieldRec->hasNonTrivialMoveAssignment())
868 data().DefaultedMoveAssignmentIsDeleted = true;
869 if (FieldRec->hasNonTrivialDestructor())
870 data().DefaultedDestructorIsDeleted = true;
871 }
872
Richard Smithdd5619f2016-08-16 00:13:47 +0000873 // For an anonymous union member, our overload resolution will perform
874 // overload resolution for its members.
875 if (Field->isAnonymousStructOrUnion()) {
Richard Smith96cd6712017-08-16 01:49:53 +0000876 data().NeedOverloadResolutionForCopyConstructor |=
877 FieldRec->data().NeedOverloadResolutionForCopyConstructor;
Richard Smithdd5619f2016-08-16 00:13:47 +0000878 data().NeedOverloadResolutionForMoveConstructor |=
879 FieldRec->data().NeedOverloadResolutionForMoveConstructor;
880 data().NeedOverloadResolutionForMoveAssignment |=
881 FieldRec->data().NeedOverloadResolutionForMoveAssignment;
882 data().NeedOverloadResolutionForDestructor |=
883 FieldRec->data().NeedOverloadResolutionForDestructor;
884 }
885
Alexis Huntf479f1b2011-05-09 18:22:59 +0000886 // C++0x [class.ctor]p5:
Richard Smithcc36f692011-12-22 02:22:31 +0000887 // A default constructor is trivial [...] if:
Alexis Huntf479f1b2011-05-09 18:22:59 +0000888 // -- for all the non-static data members of its class that are of
889 // class type (or array thereof), each such class has a trivial
890 // default constructor.
891 if (!FieldRec->hasTrivialDefaultConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000892 data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000893
894 // C++0x [class.copy]p13:
895 // A copy/move constructor for class X is trivial if [...]
896 // [...]
897 // -- for each non-static data member of X that is of class type (or
898 // an array thereof), the constructor selected to copy/move that
899 // member is trivial;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000900 if (!FieldRec->hasTrivialCopyConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000901 data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
Richard Smith6b02d462012-12-08 08:32:28 +0000902 // If the field doesn't have a simple move constructor, we'll eagerly
903 // declare the move constructor for this class and we'll decide whether
904 // it's trivial then.
Richard Smith16488472012-11-16 00:53:38 +0000905 if (!FieldRec->hasTrivialMoveConstructor())
Richard Smith328aae52012-11-30 05:11:39 +0000906 data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000907
908 // C++0x [class.copy]p27:
909 // A copy/move assignment operator for class X is trivial if [...]
910 // [...]
911 // -- for each non-static data member of X that is of class type (or
912 // an array thereof), the assignment operator selected to
913 // copy/move that member is trivial;
Douglas Gregor11c024b2010-09-28 20:50:54 +0000914 if (!FieldRec->hasTrivialCopyAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000915 data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
Richard Smith6b02d462012-12-08 08:32:28 +0000916 // If the field doesn't have a simple move assignment, we'll eagerly
917 // declare the move assignment for this class and we'll decide whether
918 // it's trivial then.
Richard Smith16488472012-11-16 00:53:38 +0000919 if (!FieldRec->hasTrivialMoveAssignment())
Richard Smith328aae52012-11-30 05:11:39 +0000920 data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
Chandler Carruthad7d4042011-04-23 23:10:33 +0000921
Douglas Gregor11c024b2010-09-28 20:50:54 +0000922 if (!FieldRec->hasTrivialDestructor())
Richard Smith328aae52012-11-30 05:11:39 +0000923 data().HasTrivialSpecialMembers &= ~SMF_Destructor;
Richard Smith561fb152012-02-25 07:33:38 +0000924 if (!FieldRec->hasIrrelevantDestructor())
925 data().HasIrrelevantDestructor = false;
John McCall31168b02011-06-15 23:02:42 +0000926 if (FieldRec->hasObjectMember())
927 setHasObjectMember(true);
Fariborz Jahanian78652202013-01-25 23:57:05 +0000928 if (FieldRec->hasVolatileMember())
929 setHasVolatileMember(true);
Chandler Carruthb1963742011-04-30 09:17:45 +0000930
931 // C++0x [class]p7:
932 // A standard-layout class is a class that:
933 // -- has no non-static data members of type non-standard-layout
934 // class (or array of such types) [...]
Chandler Carruth583edf82011-04-30 10:07:30 +0000935 if (!FieldRec->isStandardLayout())
936 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000937
938 // C++0x [class]p7:
939 // A standard-layout class is a class that:
940 // [...]
941 // -- has no base classes of the same type as the first non-static
942 // data member.
943 // We don't want to expend bits in the state of the record decl
944 // tracking whether this is the first non-static data member so we
945 // cheat a bit and use some of the existing state: the empty bit.
946 // Virtual bases and virtual methods make a class non-empty, but they
947 // also make it non-standard-layout so we needn't check here.
948 // A non-empty base class may leave the class standard-layout, but not
Richard Smithab44d5b2013-12-10 08:25:00 +0000949 // if we have arrived here, and have at least one non-static data
Chandler Carruth583edf82011-04-30 10:07:30 +0000950 // member. If IsStandardLayout remains true, then the first non-static
Chandler Carruthb1963742011-04-30 09:17:45 +0000951 // data member must come through here with Empty still true, and Empty
952 // will subsequently be set to false below.
Chandler Carruth583edf82011-04-30 10:07:30 +0000953 if (data().IsStandardLayout && data().Empty) {
Aaron Ballman574705e2014-03-13 15:41:46 +0000954 for (const auto &BI : bases()) {
955 if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
Chandler Carruth583edf82011-04-30 10:07:30 +0000956 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +0000957 break;
958 }
959 }
960 }
Douglas Gregor61226d32011-05-13 01:05:07 +0000961
962 // Keep track of the presence of mutable fields.
Richard Smith96cd6712017-08-16 01:49:53 +0000963 if (FieldRec->hasMutableFields()) {
Douglas Gregor61226d32011-05-13 01:05:07 +0000964 data().HasMutableFields = true;
Richard Smith96cd6712017-08-16 01:49:53 +0000965 data().NeedOverloadResolutionForCopyConstructor = true;
966 }
Richard Smithcc36f692011-12-22 02:22:31 +0000967
968 // C++11 [class.copy]p13:
969 // If the implicitly-defined constructor would satisfy the
970 // requirements of a constexpr constructor, the implicitly-defined
971 // constructor is constexpr.
972 // C++11 [dcl.constexpr]p4:
973 // -- every constructor involved in initializing non-static data
974 // members [...] shall be a constexpr constructor
975 if (!Field->hasInClassInitializer() &&
Richard Smithe2648ba2012-05-07 01:07:30 +0000976 !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
Richard Smithcc36f692011-12-22 02:22:31 +0000977 // The standard requires any in-class initializer to be a constant
978 // expression. We consider this to be a defect.
979 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smith1c33fe82012-11-28 06:23:12 +0000980
981 // C++11 [class.copy]p8:
982 // The implicitly-declared copy constructor for a class X will have
Richard Smithdf054d32017-02-25 23:53:05 +0000983 // the form 'X::X(const X&)' if each potentially constructed subobject
984 // of a class type M (or array thereof) has a copy constructor whose
985 // first parameter is of type 'const M&' or 'const volatile M&'.
Richard Smith1c33fe82012-11-28 06:23:12 +0000986 if (!FieldRec->hasCopyConstructorWithConstParam())
Richard Smithdf054d32017-02-25 23:53:05 +0000987 data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;
Richard Smith1c33fe82012-11-28 06:23:12 +0000988
989 // C++11 [class.copy]p18:
990 // The implicitly-declared copy assignment oeprator for a class X will
991 // have the form 'X& X::operator=(const X&)' if [...] for all the
992 // non-static data members of X that are of a class type M (or array
993 // thereof), each such class type has a copy assignment operator whose
994 // parameter is of type 'const M&', 'const volatile M&' or 'M'.
995 if (!FieldRec->hasCopyAssignmentWithConstParam())
996 data().ImplicitCopyAssignmentHasConstParam = false;
Richard Smith593f9932012-12-08 02:01:17 +0000997
998 if (FieldRec->hasUninitializedReferenceMember() &&
999 !Field->hasInClassInitializer())
1000 data().HasUninitializedReferenceMember = true;
Richard Smithab44d5b2013-12-10 08:25:00 +00001001
1002 // C++11 [class.union]p8, DR1460:
1003 // a non-static data member of an anonymous union that is a member of
1004 // X is also a variant member of X.
1005 if (FieldRec->hasVariantMembers() &&
1006 Field->isAnonymousStructOrUnion())
1007 data().HasVariantMembers = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +00001008 }
Richard Smithcc36f692011-12-22 02:22:31 +00001009 } else {
1010 // Base element type of field is a non-class type.
Richard Smithd9f663b2013-04-22 15:31:51 +00001011 if (!T->isLiteralType(Context) ||
Richard Smith4086a132012-06-10 07:07:24 +00001012 (!Field->hasInClassInitializer() && !isUnion()))
Richard Smithcc36f692011-12-22 02:22:31 +00001013 data().DefaultedDefaultConstructorIsConstexpr = false;
Richard Smith6b02d462012-12-08 08:32:28 +00001014
1015 // C++11 [class.copy]p23:
1016 // A defaulted copy/move assignment operator for a class X is defined
1017 // as deleted if X has:
1018 // -- a non-static data member of const non-class type (or array
1019 // thereof)
1020 if (T.isConstQualified())
1021 data().DefaultedMoveAssignmentIsDeleted = true;
Douglas Gregor11c024b2010-09-28 20:50:54 +00001022 }
Chandler Carruthb1963742011-04-30 09:17:45 +00001023
1024 // C++0x [class]p7:
1025 // A standard-layout class is a class that:
1026 // [...]
1027 // -- either has no non-static data members in the most derived
1028 // class and at most one base class with non-static data members,
1029 // or has no base classes with non-static data members, and
1030 // At this point we know that we have a non-static data member, so the last
1031 // clause holds.
1032 if (!data().HasNoNonEmptyBases)
Chandler Carruth583edf82011-04-30 10:07:30 +00001033 data().IsStandardLayout = false;
Chandler Carruthb1963742011-04-30 09:17:45 +00001034
David Majnemer5cfda6f2016-05-22 05:34:26 +00001035 // C++14 [meta.unary.prop]p4:
1036 // T is a class type [...] with [...] no non-static data members other
1037 // than bit-fields of length 0...
Douglas Gregor9d5938a2010-09-28 20:38:10 +00001038 if (data().Empty) {
Richard Smithcaf33902011-10-10 18:28:20 +00001039 if (!Field->isBitField() ||
1040 (!Field->getBitWidth()->isTypeDependent() &&
1041 !Field->getBitWidth()->isValueDependent() &&
1042 Field->getBitWidthValue(Context) != 0))
Douglas Gregor9d5938a2010-09-28 20:38:10 +00001043 data().Empty = false;
Douglas Gregor9d5938a2010-09-28 20:38:10 +00001044 }
Douglas Gregora832d3e2010-09-28 19:45:33 +00001045 }
Douglas Gregor457104e2010-09-29 04:25:11 +00001046
1047 // Handle using declarations of conversion functions.
Richard Smitha4ba74c2013-08-30 04:46:40 +00001048 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) {
Douglas Gregor457104e2010-09-29 04:25:11 +00001049 if (Shadow->getDeclName().getNameKind()
Richard Smitha4ba74c2013-08-30 04:46:40 +00001050 == DeclarationName::CXXConversionFunctionName) {
1051 ASTContext &Ctx = getASTContext();
1052 data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
1053 }
1054 }
Richard Smith12e79312016-05-13 06:47:56 +00001055
1056 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
1057 if (Using->getDeclName().getNameKind() ==
Eric Fiselier283d8d42016-12-03 01:26:47 +00001058 DeclarationName::CXXConstructorName) {
Richard Smith12e79312016-05-13 06:47:56 +00001059 data().HasInheritedConstructor = true;
Eric Fiselier283d8d42016-12-03 01:26:47 +00001060 // C++1z [dcl.init.aggr]p1:
1061 // An aggregate is [...] a class [...] with no inherited constructors
1062 data().Aggregate = false;
1063 }
Richard Smith12e79312016-05-13 06:47:56 +00001064
1065 if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal)
1066 data().HasInheritedAssignment = true;
1067 }
Joao Matose9a3ed42012-08-31 22:18:20 +00001068}
1069
Richard Smith92f241f2012-12-08 02:53:02 +00001070void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
1071 assert(!D->isImplicit() && !D->isUserProvided());
1072
1073 // The kind of special member this declaration is, if any.
1074 unsigned SMKind = 0;
1075
1076 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1077 if (Constructor->isDefaultConstructor()) {
1078 SMKind |= SMF_DefaultConstructor;
1079 if (Constructor->isConstexpr())
1080 data().HasConstexprDefaultConstructor = true;
1081 }
1082 if (Constructor->isCopyConstructor())
1083 SMKind |= SMF_CopyConstructor;
1084 else if (Constructor->isMoveConstructor())
1085 SMKind |= SMF_MoveConstructor;
1086 else if (Constructor->isConstexpr())
1087 // We may now know that the constructor is constexpr.
1088 data().HasConstexprNonCopyMoveConstructor = true;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +00001089 } else if (isa<CXXDestructorDecl>(D)) {
Richard Smith92f241f2012-12-08 02:53:02 +00001090 SMKind |= SMF_Destructor;
Stephan Tolksdorfd85fa232014-03-27 20:23:12 +00001091 if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
1092 data().HasIrrelevantDestructor = false;
1093 } else if (D->isCopyAssignmentOperator())
Richard Smith92f241f2012-12-08 02:53:02 +00001094 SMKind |= SMF_CopyAssignment;
1095 else if (D->isMoveAssignmentOperator())
1096 SMKind |= SMF_MoveAssignment;
1097
1098 // Update which trivial / non-trivial special members we have.
1099 // addedMember will have skipped this step for this member.
1100 if (D->isTrivial())
1101 data().HasTrivialSpecialMembers |= SMKind;
1102 else
1103 data().DeclaredNonTrivialSpecialMembers |= SMKind;
1104}
1105
Joao Matose9a3ed42012-08-31 22:18:20 +00001106bool CXXRecordDecl::isCLike() const {
1107 if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
1108 !TemplateOrInstantiation.isNull())
1109 return false;
1110 if (!hasDefinition())
1111 return true;
Argyrios Kyrtzidis5c4e0652012-01-23 16:58:45 +00001112
Argyrios Kyrtzidisc3c9ee52012-02-01 06:36:44 +00001113 return isPOD() && data().HasOnlyCMembers;
Argyrios Kyrtzidis5c4e0652012-01-23 16:58:45 +00001114}
Faisal Valic1a6dc42013-10-23 16:10:50 +00001115
Faisal Vali2b391ab2013-09-26 19:54:12 +00001116bool CXXRecordDecl::isGenericLambda() const {
Faisal Valic1a6dc42013-10-23 16:10:50 +00001117 if (!isLambda()) return false;
1118 return getLambdaData().IsGenericLambda;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001119}
1120
1121CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001122 if (!isLambda()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +00001123 DeclarationName Name =
1124 getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
Richard Smithcf4bdde2015-02-21 02:45:19 +00001125 DeclContext::lookup_result Calls = lookup(Name);
Faisal Vali850da1a2013-09-29 17:08:32 +00001126
1127 assert(!Calls.empty() && "Missing lambda call operator!");
1128 assert(Calls.size() == 1 && "More than one lambda call operator!");
1129
1130 NamedDecl *CallOp = Calls.front();
1131 if (FunctionTemplateDecl *CallOpTmpl =
1132 dyn_cast<FunctionTemplateDecl>(CallOp))
1133 return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
Faisal Vali2b391ab2013-09-26 19:54:12 +00001134
1135 return cast<CXXMethodDecl>(CallOp);
1136}
1137
1138CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001139 if (!isLambda()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +00001140 DeclarationName Name =
1141 &getASTContext().Idents.get(getLambdaStaticInvokerName());
Richard Smithcf4bdde2015-02-21 02:45:19 +00001142 DeclContext::lookup_result Invoker = lookup(Name);
Craig Topper36250ad2014-05-12 05:36:57 +00001143 if (Invoker.empty()) return nullptr;
Faisal Vali850da1a2013-09-29 17:08:32 +00001144 assert(Invoker.size() == 1 && "More than one static invoker operator!");
1145 NamedDecl *InvokerFun = Invoker.front();
1146 if (FunctionTemplateDecl *InvokerTemplate =
1147 dyn_cast<FunctionTemplateDecl>(InvokerFun))
1148 return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
1149
Faisal Vali571df122013-09-29 08:45:24 +00001150 return cast<CXXMethodDecl>(InvokerFun);
Faisal Vali2b391ab2013-09-26 19:54:12 +00001151}
1152
Douglas Gregor9c702202012-02-10 07:45:31 +00001153void CXXRecordDecl::getCaptureFields(
1154 llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
Eli Friedman7e7da2d2012-02-11 00:18:00 +00001155 FieldDecl *&ThisCapture) const {
Douglas Gregor9c702202012-02-10 07:45:31 +00001156 Captures.clear();
Craig Topper36250ad2014-05-12 05:36:57 +00001157 ThisCapture = nullptr;
Douglas Gregor9c702202012-02-10 07:45:31 +00001158
Douglas Gregorc8a73492012-02-13 15:44:47 +00001159 LambdaDefinitionData &Lambda = getLambdaData();
Douglas Gregor9c702202012-02-10 07:45:31 +00001160 RecordDecl::field_iterator Field = field_begin();
Benjamin Kramerf3ca26982014-05-10 16:31:55 +00001161 for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
Douglas Gregor9c702202012-02-10 07:45:31 +00001162 C != CEnd; ++C, ++Field) {
Richard Smithba71c082013-05-16 06:20:58 +00001163 if (C->capturesThis())
David Blaikie40ed2972012-06-06 20:45:41 +00001164 ThisCapture = *Field;
Richard Smithba71c082013-05-16 06:20:58 +00001165 else if (C->capturesVariable())
1166 Captures[C->getCapturedVar()] = *Field;
Douglas Gregor9c702202012-02-10 07:45:31 +00001167 }
Richard Smithbb13c9a2013-09-28 04:02:39 +00001168 assert(Field == field_end());
Douglas Gregor9c702202012-02-10 07:45:31 +00001169}
1170
Faisal Vali2b391ab2013-09-26 19:54:12 +00001171TemplateParameterList *
1172CXXRecordDecl::getGenericLambdaTemplateParameterList() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001173 if (!isLambda()) return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001174 CXXMethodDecl *CallOp = getLambdaCallOperator();
1175 if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate())
1176 return Tmpl->getTemplateParameters();
Craig Topper36250ad2014-05-12 05:36:57 +00001177 return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001178}
Douglas Gregor9c702202012-02-10 07:45:31 +00001179
Richard Smith0bae6242016-08-25 00:34:00 +00001180Decl *CXXRecordDecl::getLambdaContextDecl() const {
1181 assert(isLambda() && "Not a lambda closure type!");
1182 ExternalASTSource *Source = getParentASTContext().getExternalSource();
1183 return getLambdaData().ContextDecl.get(Source);
1184}
1185
John McCall1e3a1a72010-03-15 09:07:48 +00001186static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
Alp Tokera2794f92014-01-22 07:29:52 +00001187 QualType T =
1188 cast<CXXConversionDecl>(Conv->getUnderlyingDecl()->getAsFunction())
1189 ->getConversionType();
John McCall1e3a1a72010-03-15 09:07:48 +00001190 return Context.getCanonicalType(T);
Fariborz Jahanian3ee21f12009-10-07 20:43:36 +00001191}
1192
John McCall1e3a1a72010-03-15 09:07:48 +00001193/// Collect the visible conversions of a base class.
1194///
James Dennettb5d5f812012-06-15 22:28:09 +00001195/// \param Record a base class of the class we're considering
John McCall1e3a1a72010-03-15 09:07:48 +00001196/// \param InVirtual whether this base class is a virtual base (or a base
1197/// of a virtual base)
1198/// \param Access the access along the inheritance path to this base
1199/// \param ParentHiddenTypes the conversions provided by the inheritors
1200/// of this base
1201/// \param Output the set to which to add conversions from non-virtual bases
1202/// \param VOutput the set to which to add conversions from virtual bases
1203/// \param HiddenVBaseCs the set of conversions which were hidden in a
1204/// virtual base along some inheritance path
1205static void CollectVisibleConversions(ASTContext &Context,
1206 CXXRecordDecl *Record,
1207 bool InVirtual,
1208 AccessSpecifier Access,
1209 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001210 ASTUnresolvedSet &Output,
John McCall1e3a1a72010-03-15 09:07:48 +00001211 UnresolvedSetImpl &VOutput,
1212 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
1213 // The set of types which have conversions in this class or its
1214 // subclasses. As an optimization, we don't copy the derived set
1215 // unless it might change.
1216 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
1217 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
1218
1219 // Collect the direct conversions and figure out which conversions
1220 // will be hidden in the subclasses.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001221 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1222 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
1223 if (ConvI != ConvE) {
John McCall1e3a1a72010-03-15 09:07:48 +00001224 HiddenTypesBuffer = ParentHiddenTypes;
1225 HiddenTypes = &HiddenTypesBuffer;
1226
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001227 for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
Richard Smith99fdf8d2012-05-06 00:04:32 +00001228 CanQualType ConvType(GetConversionType(Context, I.getDecl()));
1229 bool Hidden = ParentHiddenTypes.count(ConvType);
1230 if (!Hidden)
1231 HiddenTypesBuffer.insert(ConvType);
John McCall1e3a1a72010-03-15 09:07:48 +00001232
1233 // If this conversion is hidden and we're in a virtual base,
1234 // remember that it's hidden along some inheritance path.
1235 if (Hidden && InVirtual)
1236 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1237
1238 // If this conversion isn't hidden, add it to the appropriate output.
1239 else if (!Hidden) {
1240 AccessSpecifier IAccess
1241 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1242
1243 if (InVirtual)
1244 VOutput.addDecl(I.getDecl(), IAccess);
Fariborz Jahanianb394f502009-09-12 18:26:03 +00001245 else
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001246 Output.addDecl(Context, I.getDecl(), IAccess);
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001247 }
1248 }
1249 }
Sebastian Redl1054fae2009-10-25 17:03:50 +00001250
John McCall1e3a1a72010-03-15 09:07:48 +00001251 // Collect information recursively from any base classes.
Aaron Ballman574705e2014-03-13 15:41:46 +00001252 for (const auto &I : Record->bases()) {
1253 const RecordType *RT = I.getType()->getAs<RecordType>();
John McCall1e3a1a72010-03-15 09:07:48 +00001254 if (!RT) continue;
Sebastian Redl1054fae2009-10-25 17:03:50 +00001255
John McCall1e3a1a72010-03-15 09:07:48 +00001256 AccessSpecifier BaseAccess
Aaron Ballman574705e2014-03-13 15:41:46 +00001257 = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
1258 bool BaseInVirtual = InVirtual || I.isVirtual();
Sebastian Redl1054fae2009-10-25 17:03:50 +00001259
John McCall1e3a1a72010-03-15 09:07:48 +00001260 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1261 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1262 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001263 }
John McCall1e3a1a72010-03-15 09:07:48 +00001264}
Sebastian Redl1054fae2009-10-25 17:03:50 +00001265
John McCall1e3a1a72010-03-15 09:07:48 +00001266/// Collect the visible conversions of a class.
1267///
1268/// This would be extremely straightforward if it weren't for virtual
1269/// bases. It might be worth special-casing that, really.
1270static void CollectVisibleConversions(ASTContext &Context,
1271 CXXRecordDecl *Record,
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001272 ASTUnresolvedSet &Output) {
John McCall1e3a1a72010-03-15 09:07:48 +00001273 // The collection of all conversions in virtual bases that we've
1274 // found. These will be added to the output as long as they don't
1275 // appear in the hidden-conversions set.
1276 UnresolvedSet<8> VBaseCs;
1277
1278 // The set of conversions in virtual bases that we've determined to
1279 // be hidden.
1280 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1281
1282 // The set of types hidden by classes derived from this one.
1283 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
1284
1285 // Go ahead and collect the direct conversions and add them to the
1286 // hidden-types set.
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001287 CXXRecordDecl::conversion_iterator ConvI = Record->conversion_begin();
1288 CXXRecordDecl::conversion_iterator ConvE = Record->conversion_end();
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001289 Output.append(Context, ConvI, ConvE);
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001290 for (; ConvI != ConvE; ++ConvI)
1291 HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
John McCall1e3a1a72010-03-15 09:07:48 +00001292
1293 // Recursively collect conversions from base classes.
Aaron Ballman574705e2014-03-13 15:41:46 +00001294 for (const auto &I : Record->bases()) {
1295 const RecordType *RT = I.getType()->getAs<RecordType>();
John McCall1e3a1a72010-03-15 09:07:48 +00001296 if (!RT) continue;
1297
1298 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
Aaron Ballman574705e2014-03-13 15:41:46 +00001299 I.isVirtual(), I.getAccessSpecifier(),
John McCall1e3a1a72010-03-15 09:07:48 +00001300 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1301 }
1302
1303 // Add any unhidden conversions provided by virtual bases.
1304 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1305 I != E; ++I) {
1306 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001307 Output.addDecl(Context, I.getDecl(), I.getAccess());
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001308 }
Fariborz Jahanianb394f502009-09-12 18:26:03 +00001309}
1310
1311/// getVisibleConversionFunctions - get all conversion functions visible
1312/// in current class; including conversion function templates.
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00001313llvm::iterator_range<CXXRecordDecl::conversion_iterator>
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001314CXXRecordDecl::getVisibleConversionFunctions() {
Richard Smitha4ba74c2013-08-30 04:46:40 +00001315 ASTContext &Ctx = getASTContext();
1316
1317 ASTUnresolvedSet *Set;
1318 if (bases_begin() == bases_end()) {
1319 // If root class, all conversions are visible.
1320 Set = &data().Conversions.get(Ctx);
1321 } else {
1322 Set = &data().VisibleConversions.get(Ctx);
1323 // If visible conversion list is not evaluated, evaluate it.
1324 if (!data().ComputedVisibleConversions) {
1325 CollectVisibleConversions(Ctx, this, *Set);
1326 data().ComputedVisibleConversions = true;
1327 }
Argyrios Kyrtzidisa6567c42012-11-28 03:56:09 +00001328 }
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00001329 return llvm::make_range(Set->begin(), Set->end());
Fariborz Jahanianb54ccb22009-09-11 21:44:33 +00001330}
1331
John McCallda4458e2010-03-31 01:36:47 +00001332void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
1333 // This operation is O(N) but extremely rare. Sema only uses it to
1334 // remove UsingShadowDecls in a class that were followed by a direct
1335 // declaration, e.g.:
1336 // class A : B {
1337 // using B::operator int;
1338 // operator int();
1339 // };
1340 // This is uncommon by itself and even more uncommon in conjunction
1341 // with sufficiently large numbers of directly-declared conversions
1342 // that asymptotic behavior matters.
1343
Richard Smitha4ba74c2013-08-30 04:46:40 +00001344 ASTUnresolvedSet &Convs = data().Conversions.get(getASTContext());
John McCallda4458e2010-03-31 01:36:47 +00001345 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1346 if (Convs[I].getDecl() == ConvDecl) {
1347 Convs.erase(I);
1348 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1349 && "conversion was found multiple times in unresolved set");
1350 return;
1351 }
1352 }
1353
1354 llvm_unreachable("conversion not found in set!");
Douglas Gregor05155d82009-08-21 23:19:43 +00001355}
Fariborz Jahanian423a81f2009-06-19 19:55:27 +00001356
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001357CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
Douglas Gregor06db9f52009-10-12 20:18:28 +00001358 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001359 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
Craig Topper36250ad2014-05-12 05:36:57 +00001360
1361 return nullptr;
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001362}
1363
Chandler Carruth21c90602015-12-30 03:24:14 +00001364MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const {
1365 return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>();
1366}
1367
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001368void
1369CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1370 TemplateSpecializationKind TSK) {
1371 assert(TemplateOrInstantiation.isNull() &&
1372 "Previous template or instantiation?");
Richard Smith8a0dde72013-12-14 01:04:22 +00001373 assert(!isa<ClassTemplatePartialSpecializationDecl>(this));
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001374 TemplateOrInstantiation
1375 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1376}
1377
Chandler Carruth21c90602015-12-30 03:24:14 +00001378ClassTemplateDecl *CXXRecordDecl::getDescribedClassTemplate() const {
1379 return TemplateOrInstantiation.dyn_cast<ClassTemplateDecl *>();
1380}
1381
1382void CXXRecordDecl::setDescribedClassTemplate(ClassTemplateDecl *Template) {
1383 TemplateOrInstantiation = Template;
1384}
1385
Anders Carlsson27cfc6e2009-12-07 06:33:48 +00001386TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1387 if (const ClassTemplateSpecializationDecl *Spec
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001388 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1389 return Spec->getSpecializationKind();
1390
Douglas Gregor06db9f52009-10-12 20:18:28 +00001391 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001392 return MSInfo->getTemplateSpecializationKind();
1393
1394 return TSK_Undeclared;
1395}
1396
1397void
1398CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1399 if (ClassTemplateSpecializationDecl *Spec
1400 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1401 Spec->setSpecializationKind(TSK);
1402 return;
1403 }
1404
Douglas Gregor06db9f52009-10-12 20:18:28 +00001405 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001406 MSInfo->setTemplateSpecializationKind(TSK);
1407 return;
1408 }
1409
David Blaikie83d382b2011-09-23 05:06:16 +00001410 llvm_unreachable("Not a class template or member class specialization");
Douglas Gregorbbe8f462009-10-08 15:14:33 +00001411}
1412
Reid Klecknere7367d62014-10-14 20:28:40 +00001413const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {
Richard Smith2195ec92017-04-21 01:15:13 +00001414 auto GetDefinitionOrSelf =
1415 [](const CXXRecordDecl *D) -> const CXXRecordDecl * {
1416 if (auto *Def = D->getDefinition())
1417 return Def;
1418 return D;
1419 };
1420
Reid Klecknere7367d62014-10-14 20:28:40 +00001421 // If it's a class template specialization, find the template or partial
1422 // specialization from which it was instantiated.
1423 if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1424 auto From = TD->getInstantiatedFrom();
1425 if (auto *CTD = From.dyn_cast<ClassTemplateDecl *>()) {
1426 while (auto *NewCTD = CTD->getInstantiatedFromMemberTemplate()) {
1427 if (NewCTD->isMemberSpecialization())
1428 break;
1429 CTD = NewCTD;
1430 }
Richard Smith2195ec92017-04-21 01:15:13 +00001431 return GetDefinitionOrSelf(CTD->getTemplatedDecl());
Reid Klecknere7367d62014-10-14 20:28:40 +00001432 }
1433 if (auto *CTPSD =
1434 From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
1435 while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) {
1436 if (NewCTPSD->isMemberSpecialization())
1437 break;
1438 CTPSD = NewCTPSD;
1439 }
Richard Smith2195ec92017-04-21 01:15:13 +00001440 return GetDefinitionOrSelf(CTPSD);
Reid Klecknere7367d62014-10-14 20:28:40 +00001441 }
1442 }
1443
1444 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1445 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
1446 const CXXRecordDecl *RD = this;
1447 while (auto *NewRD = RD->getInstantiatedFromMemberClass())
1448 RD = NewRD;
Richard Smith2195ec92017-04-21 01:15:13 +00001449 return GetDefinitionOrSelf(RD);
Reid Klecknere7367d62014-10-14 20:28:40 +00001450 }
1451 }
1452
1453 assert(!isTemplateInstantiation(this->getTemplateSpecializationKind()) &&
1454 "couldn't find pattern for class template instantiation");
1455 return nullptr;
1456}
1457
Douglas Gregorbac74902010-07-01 14:13:13 +00001458CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1459 ASTContext &Context = getASTContext();
Anders Carlsson0a637412009-05-29 21:03:38 +00001460 QualType ClassType = Context.getTypeDeclType(this);
Mike Stump11289f42009-09-09 15:08:12 +00001461
1462 DeclarationName Name
Douglas Gregor2211d342009-08-05 05:36:45 +00001463 = Context.DeclarationNames.getCXXDestructorName(
1464 Context.getCanonicalType(ClassType));
Anders Carlsson0a637412009-05-29 21:03:38 +00001465
Richard Smithcf4bdde2015-02-21 02:45:19 +00001466 DeclContext::lookup_result R = lookup(Name);
Mike Stump11289f42009-09-09 15:08:12 +00001467
Hubert Tong3cede512017-06-30 22:43:54 +00001468 return R.empty() ? nullptr : dyn_cast<CXXDestructorDecl>(R.front());
Anders Carlsson0a637412009-05-29 21:03:38 +00001469}
1470
Richard Trieu95a192a2015-05-28 00:14:02 +00001471bool CXXRecordDecl::isAnyDestructorNoReturn() const {
1472 // Destructor is noreturn.
1473 if (const CXXDestructorDecl *Destructor = getDestructor())
1474 if (Destructor->isNoReturn())
1475 return true;
1476
1477 // Check base classes destructor for noreturn.
1478 for (const auto &Base : bases())
Alexander Kornienko29333342017-05-12 11:24:25 +00001479 if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl())
1480 if (RD->isAnyDestructorNoReturn())
1481 return true;
Richard Trieu95a192a2015-05-28 00:14:02 +00001482
1483 // Check fields for noreturn.
1484 for (const auto *Field : fields())
1485 if (const CXXRecordDecl *RD =
1486 Field->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl())
1487 if (RD->isAnyDestructorNoReturn())
1488 return true;
1489
1490 // All destructors are not noreturn.
1491 return false;
1492}
1493
Erich Keane3e08f662017-09-29 21:06:00 +00001494static bool isDeclContextInNamespace(const DeclContext *DC) {
1495 while (!DC->isTranslationUnit()) {
1496 if (DC->isNamespace())
1497 return true;
1498 DC = DC->getParent();
1499 }
1500 return false;
1501}
1502
Erich Keane58bd6032017-09-15 16:03:35 +00001503bool CXXRecordDecl::isInterfaceLike() const {
1504 assert(hasDefinition() && "checking for interface-like without a definition");
1505 // All __interfaces are inheritently interface-like.
1506 if (isInterface())
1507 return true;
1508
1509 // Interface-like types cannot have a user declared constructor, destructor,
1510 // friends, VBases, conversion functions, or fields. Additionally, lambdas
1511 // cannot be interface types.
1512 if (isLambda() || hasUserDeclaredConstructor() ||
1513 hasUserDeclaredDestructor() || !field_empty() || hasFriends() ||
1514 getNumVBases() > 0 || conversion_end() - conversion_begin() > 0)
1515 return false;
1516
1517 // No interface-like type can have a method with a definition.
1518 for (const auto *const Method : methods())
Erich Keane3e08f662017-09-29 21:06:00 +00001519 if (Method->isDefined() && !Method->isImplicit())
Erich Keane58bd6032017-09-15 16:03:35 +00001520 return false;
1521
1522 // Check "Special" types.
1523 const auto *Uuid = getAttr<UuidAttr>();
Erich Keane3e08f662017-09-29 21:06:00 +00001524 // MS SDK declares IUnknown/IDispatch both in the root of a TU, or in an
1525 // extern C++ block directly in the TU. These are only valid if in one
1526 // of these two situations.
1527 if (Uuid && isStruct() && !getDeclContext()->isExternCContext() &&
1528 !isDeclContextInNamespace(getDeclContext()) &&
Erich Keane58bd6032017-09-15 16:03:35 +00001529 ((getName() == "IUnknown" &&
1530 Uuid->getGuid() == "00000000-0000-0000-C000-000000000046") ||
1531 (getName() == "IDispatch" &&
1532 Uuid->getGuid() == "00020400-0000-0000-C000-000000000046"))) {
1533 if (getNumBases() > 0)
1534 return false;
1535 return true;
1536 }
1537
1538 // FIXME: Any access specifiers is supposed to make this no longer interface
1539 // like.
1540
1541 // If this isn't a 'special' type, it must have a single interface-like base.
1542 if (getNumBases() != 1)
1543 return false;
1544
1545 const auto BaseSpec = *bases_begin();
1546 if (BaseSpec.isVirtual() || BaseSpec.getAccessSpecifier() != AS_public)
1547 return false;
1548 const auto *Base = BaseSpec.getType()->getAsCXXRecordDecl();
1549 if (Base->isInterface() || !Base->isInterfaceLike())
1550 return false;
1551 return true;
1552}
1553
Douglas Gregorb11aad82011-02-19 18:51:44 +00001554void CXXRecordDecl::completeDefinition() {
Craig Topper36250ad2014-05-12 05:36:57 +00001555 completeDefinition(nullptr);
Douglas Gregorb11aad82011-02-19 18:51:44 +00001556}
1557
1558void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1559 RecordDecl::completeDefinition();
Richard Smith96cd6712017-08-16 01:49:53 +00001560
Douglas Gregor8fb95122010-09-29 00:15:42 +00001561 // If the class may be abstract (but hasn't been marked as such), check for
1562 // any pure final overriders.
1563 if (mayBeAbstract()) {
1564 CXXFinalOverriderMap MyFinalOverriders;
1565 if (!FinalOverriders) {
1566 getFinalOverriders(MyFinalOverriders);
1567 FinalOverriders = &MyFinalOverriders;
1568 }
1569
1570 bool Done = false;
1571 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1572 MEnd = FinalOverriders->end();
1573 M != MEnd && !Done; ++M) {
1574 for (OverridingMethods::iterator SO = M->second.begin(),
1575 SOEnd = M->second.end();
1576 SO != SOEnd && !Done; ++SO) {
1577 assert(SO->second.size() > 0 &&
1578 "All virtual functions have overridding virtual functions");
1579
1580 // C++ [class.abstract]p4:
1581 // A class is abstract if it contains or inherits at least one
1582 // pure virtual function for which the final overrider is pure
1583 // virtual.
1584 if (SO->second.front().Method->isPure()) {
1585 data().Abstract = true;
1586 Done = true;
1587 break;
1588 }
1589 }
1590 }
1591 }
Douglas Gregor457104e2010-09-29 04:25:11 +00001592
1593 // Set access bits correctly on the directly-declared conversions.
Richard Smitha4ba74c2013-08-30 04:46:40 +00001594 for (conversion_iterator I = conversion_begin(), E = conversion_end();
Douglas Gregor457104e2010-09-29 04:25:11 +00001595 I != E; ++I)
Argyrios Kyrtzidis0f05fb92012-11-28 03:56:16 +00001596 I.setAccess((*I)->getAccess());
Douglas Gregor8fb95122010-09-29 00:15:42 +00001597}
1598
1599bool CXXRecordDecl::mayBeAbstract() const {
1600 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1601 isDependentContext())
1602 return false;
1603
Aaron Ballman574705e2014-03-13 15:41:46 +00001604 for (const auto &B : bases()) {
Douglas Gregor8fb95122010-09-29 00:15:42 +00001605 CXXRecordDecl *BaseDecl
Aaron Ballman574705e2014-03-13 15:41:46 +00001606 = cast<CXXRecordDecl>(B.getType()->getAs<RecordType>()->getDecl());
Douglas Gregor8fb95122010-09-29 00:15:42 +00001607 if (BaseDecl->isAbstract())
1608 return true;
1609 }
1610
1611 return false;
1612}
1613
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001614void CXXDeductionGuideDecl::anchor() {}
Richard Smithbc491202017-02-17 20:05:37 +00001615
1616CXXDeductionGuideDecl *CXXDeductionGuideDecl::Create(
1617 ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit,
1618 const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
1619 SourceLocation EndLocation) {
1620 return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, IsExplicit,
1621 NameInfo, T, TInfo, EndLocation);
1622}
1623
1624CXXDeductionGuideDecl *CXXDeductionGuideDecl::CreateDeserialized(ASTContext &C,
1625 unsigned ID) {
1626 return new (C, ID) CXXDeductionGuideDecl(C, nullptr, SourceLocation(), false,
1627 DeclarationNameInfo(), QualType(),
1628 nullptr, SourceLocation());
1629}
1630
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001631void CXXMethodDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00001632
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001633bool CXXMethodDecl::isStatic() const {
Rafael Espindola29cda592013-04-15 12:38:20 +00001634 const CXXMethodDecl *MD = getCanonicalDecl();
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001635
1636 if (MD->getStorageClass() == SC_Static)
1637 return true;
1638
Reid Kleckner9a7f3e62013-10-08 00:58:57 +00001639 OverloadedOperatorKind OOK = getDeclName().getCXXOverloadedOperator();
1640 return isStaticOverloadedOperator(OOK);
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001641}
1642
Rafael Espindola49e860b2012-06-26 17:45:31 +00001643static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
1644 const CXXMethodDecl *BaseMD) {
Benjamin Krameracfa3392017-12-17 23:52:45 +00001645 for (const CXXMethodDecl *MD : DerivedMD->overridden_methods()) {
Rafael Espindola49e860b2012-06-26 17:45:31 +00001646 if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
1647 return true;
1648 if (recursivelyOverrides(MD, BaseMD))
1649 return true;
1650 }
1651 return false;
1652}
1653
1654CXXMethodDecl *
Jordan Rose5fc5da02012-08-15 20:07:17 +00001655CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
1656 bool MayBeBase) {
Rafael Espindola49e860b2012-06-26 17:45:31 +00001657 if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
1658 return this;
1659
1660 // Lookup doesn't work for destructors, so handle them separately.
1661 if (isa<CXXDestructorDecl>(this)) {
1662 CXXMethodDecl *MD = RD->getDestructor();
Jordan Rose5fc5da02012-08-15 20:07:17 +00001663 if (MD) {
1664 if (recursivelyOverrides(MD, this))
1665 return MD;
1666 if (MayBeBase && recursivelyOverrides(this, MD))
1667 return MD;
1668 }
Craig Topper36250ad2014-05-12 05:36:57 +00001669 return nullptr;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001670 }
1671
Richard Smith40c78062015-02-21 02:31:57 +00001672 for (auto *ND : RD->lookup(getDeclName())) {
1673 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND);
Rafael Espindola49e860b2012-06-26 17:45:31 +00001674 if (!MD)
1675 continue;
1676 if (recursivelyOverrides(MD, this))
1677 return MD;
Jordan Rose5fc5da02012-08-15 20:07:17 +00001678 if (MayBeBase && recursivelyOverrides(this, MD))
1679 return MD;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001680 }
1681
Aaron Ballman574705e2014-03-13 15:41:46 +00001682 for (const auto &I : RD->bases()) {
1683 const RecordType *RT = I.getType()->getAs<RecordType>();
Rafael Espindola49e860b2012-06-26 17:45:31 +00001684 if (!RT)
1685 continue;
1686 const CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
1687 CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
1688 if (T)
1689 return T;
1690 }
1691
Craig Topper36250ad2014-05-12 05:36:57 +00001692 return nullptr;
Rafael Espindola49e860b2012-06-26 17:45:31 +00001693}
1694
Ted Kremenek21475702008-09-05 17:16:31 +00001695CXXMethodDecl *
1696CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00001697 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001698 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00001699 QualType T, TypeSourceInfo *TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001700 StorageClass SC, bool isInline,
Richard Smitha77a0a62011-08-15 21:04:07 +00001701 bool isConstexpr, SourceLocation EndLocation) {
Richard Smith053f6c62014-05-16 23:01:30 +00001702 return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
1703 T, TInfo, SC, isInline, isConstexpr,
1704 EndLocation);
Ted Kremenek21475702008-09-05 17:16:31 +00001705}
1706
Douglas Gregor72172e92012-01-05 21:55:30 +00001707CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00001708 return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00001709 DeclarationNameInfo(), QualType(), nullptr,
Richard Smithf7981722013-11-22 09:01:48 +00001710 SC_None, false, false, SourceLocation());
Douglas Gregor72172e92012-01-05 21:55:30 +00001711}
1712
Akira Hatanaka22461672017-07-13 06:08:27 +00001713CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
1714 bool IsAppleKext) {
1715 assert(isVirtual() && "this method is expected to be virtual");
1716
1717 // When building with -fapple-kext, all calls must go through the vtable since
1718 // the kernel linker can do runtime patching of vtables.
1719 if (IsAppleKext)
1720 return nullptr;
1721
1722 // If the member function is marked 'final', we know that it can't be
1723 // overridden and can therefore devirtualize it unless it's pure virtual.
1724 if (hasAttr<FinalAttr>())
1725 return isPure() ? nullptr : this;
1726
1727 // If Base is unknown, we cannot devirtualize.
1728 if (!Base)
1729 return nullptr;
1730
1731 // If the base expression (after skipping derived-to-base conversions) is a
1732 // class prvalue, then we can devirtualize.
1733 Base = Base->getBestDynamicClassTypeExpr();
1734 if (Base->isRValue() && Base->getType()->isRecordType())
1735 return this;
1736
1737 // If we don't even know what we would call, we can't devirtualize.
1738 const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
1739 if (!BestDynamicDecl)
1740 return nullptr;
1741
1742 // There may be a method corresponding to MD in a derived class.
1743 CXXMethodDecl *DevirtualizedMethod =
1744 getCorrespondingMethodInClass(BestDynamicDecl);
1745
1746 // If that method is pure virtual, we can't devirtualize. If this code is
1747 // reached, the result would be UB, not a direct call to the derived class
1748 // function, and we can't assume the derived class function is defined.
1749 if (DevirtualizedMethod->isPure())
1750 return nullptr;
1751
1752 // If that method is marked final, we can devirtualize it.
1753 if (DevirtualizedMethod->hasAttr<FinalAttr>())
1754 return DevirtualizedMethod;
1755
1756 // Similarly, if the class itself is marked 'final' it can't be overridden
1757 // and we can therefore devirtualize the member function call.
1758 if (BestDynamicDecl->hasAttr<FinalAttr>())
1759 return DevirtualizedMethod;
1760
1761 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
1762 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
1763 if (VD->getType()->isRecordType())
1764 // This is a record decl. We know the type and can devirtualize it.
1765 return DevirtualizedMethod;
1766
1767 return nullptr;
1768 }
1769
1770 // We can devirtualize calls on an object accessed by a class member access
1771 // expression, since by C++11 [basic.life]p6 we know that it can't refer to
1772 // a derived class object constructed in the same location.
1773 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Base))
1774 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ME->getMemberDecl()))
1775 return VD->getType()->isRecordType() ? DevirtualizedMethod : nullptr;
1776
1777 // Likewise for calls on an object accessed by a (non-reference) pointer to
1778 // member access.
1779 if (auto *BO = dyn_cast<BinaryOperator>(Base)) {
1780 if (BO->isPtrMemOp()) {
1781 auto *MPT = BO->getRHS()->getType()->castAs<MemberPointerType>();
1782 if (MPT->getPointeeType()->isRecordType())
1783 return DevirtualizedMethod;
1784 }
1785 }
1786
1787 // We can't devirtualize the call.
1788 return nullptr;
1789}
1790
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001791bool CXXMethodDecl::isUsualDeallocationFunction() const {
1792 if (getOverloadedOperator() != OO_Delete &&
1793 getOverloadedOperator() != OO_Array_Delete)
1794 return false;
Douglas Gregor6642ca22010-02-26 05:06:18 +00001795
1796 // C++ [basic.stc.dynamic.deallocation]p2:
1797 // A template instance is never a usual deallocation function,
1798 // regardless of its signature.
1799 if (getPrimaryTemplate())
1800 return false;
1801
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001802 // C++ [basic.stc.dynamic.deallocation]p2:
1803 // If a class T has a member deallocation function named operator delete
1804 // with exactly one parameter, then that function is a usual (non-placement)
1805 // deallocation function. [...]
1806 if (getNumParams() == 1)
1807 return true;
Richard Smithb2f0f052016-10-10 18:54:32 +00001808 unsigned UsualParams = 1;
Richard Smith96269c52016-09-29 22:49:46 +00001809
Richard Smith5b349582017-10-13 01:55:36 +00001810 // C++ P0722:
1811 // A destroying operator delete is a usual deallocation function if
1812 // removing the std::destroying_delete_t parameter and changing the
1813 // first parameter type from T* to void* results in the signature of
1814 // a usual deallocation function.
1815 if (isDestroyingOperatorDelete())
1816 ++UsualParams;
1817
Richard Smithb2f0f052016-10-10 18:54:32 +00001818 // C++ <=14 [basic.stc.dynamic.deallocation]p2:
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001819 // [...] If class T does not declare such an operator delete but does
1820 // declare a member deallocation function named operator delete with
1821 // exactly two parameters, the second of which has type std::size_t (18.1),
1822 // then this function is a usual deallocation function.
Richard Smithb2f0f052016-10-10 18:54:32 +00001823 //
1824 // C++17 says a usual deallocation function is one with the signature
1825 // (void* [, size_t] [, std::align_val_t] [, ...])
1826 // and all such functions are usual deallocation functions. It's not clear
1827 // that allowing varargs functions was intentional.
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001828 ASTContext &Context = getASTContext();
Richard Smithb2f0f052016-10-10 18:54:32 +00001829 if (UsualParams < getNumParams() &&
1830 Context.hasSameUnqualifiedType(getParamDecl(UsualParams)->getType(),
1831 Context.getSizeType()))
1832 ++UsualParams;
1833
1834 if (UsualParams < getNumParams() &&
1835 getParamDecl(UsualParams)->getType()->isAlignValT())
1836 ++UsualParams;
1837
1838 if (UsualParams != getNumParams())
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001839 return false;
Richard Smithb2f0f052016-10-10 18:54:32 +00001840
1841 // In C++17 onwards, all potential usual deallocation functions are actual
1842 // usual deallocation functions.
1843 if (Context.getLangOpts().AlignedAllocation)
1844 return true;
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001845
1846 // This function is a usual deallocation function if there are no
1847 // single-parameter deallocation functions of the same kind.
Richard Smithcf4bdde2015-02-21 02:45:19 +00001848 DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName());
1849 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
David Blaikieff7d47a2012-12-19 00:45:41 +00001850 I != E; ++I) {
1851 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
Douglas Gregorbb3e12f2009-09-29 18:16:17 +00001852 if (FD->getNumParams() == 1)
1853 return false;
1854 }
1855
1856 return true;
1857}
1858
Douglas Gregorb139cd52010-05-01 20:49:11 +00001859bool CXXMethodDecl::isCopyAssignmentOperator() const {
Alexis Huntfcaeae42011-05-25 20:50:04 +00001860 // C++0x [class.copy]p17:
Douglas Gregorb139cd52010-05-01 20:49:11 +00001861 // A user-declared copy assignment operator X::operator= is a non-static
1862 // non-template member function of class X with exactly one parameter of
1863 // type X, X&, const X&, volatile X& or const volatile X&.
1864 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1865 /*non-static*/ isStatic() ||
Eli Friedman84c0143e2013-07-11 23:55:07 +00001866 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1867 getNumParams() != 1)
Douglas Gregorb139cd52010-05-01 20:49:11 +00001868 return false;
1869
1870 QualType ParamType = getParamDecl(0)->getType();
1871 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1872 ParamType = Ref->getPointeeType();
1873
1874 ASTContext &Context = getASTContext();
1875 QualType ClassType
1876 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1877 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1878}
1879
Alexis Huntfcaeae42011-05-25 20:50:04 +00001880bool CXXMethodDecl::isMoveAssignmentOperator() const {
1881 // C++0x [class.copy]p19:
1882 // A user-declared move assignment operator X::operator= is a non-static
1883 // non-template member function of class X with exactly one parameter of type
1884 // X&&, const X&&, volatile X&&, or const volatile X&&.
1885 if (getOverloadedOperator() != OO_Equal || isStatic() ||
Eli Friedman84c0143e2013-07-11 23:55:07 +00001886 getPrimaryTemplate() || getDescribedFunctionTemplate() ||
1887 getNumParams() != 1)
Alexis Huntfcaeae42011-05-25 20:50:04 +00001888 return false;
1889
1890 QualType ParamType = getParamDecl(0)->getType();
1891 if (!isa<RValueReferenceType>(ParamType))
1892 return false;
1893 ParamType = ParamType->getPointeeType();
1894
1895 ASTContext &Context = getASTContext();
1896 QualType ClassType
1897 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1898 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1899}
1900
Anders Carlsson36d87e12009-05-16 23:58:37 +00001901void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
Anders Carlssonf3935b42009-12-04 05:51:56 +00001902 assert(MD->isCanonicalDecl() && "Method is not canonical!");
Anders Carlssonbd32c432010-01-30 17:42:34 +00001903 assert(!MD->getParent()->isDependentContext() &&
1904 "Can't add an overridden method to a class template!");
Eli Friedman91359022012-03-10 01:39:01 +00001905 assert(MD->isVirtual() && "Method is not virtual!");
Anders Carlssonbd32c432010-01-30 17:42:34 +00001906
Douglas Gregor832940b2010-03-02 23:58:15 +00001907 getASTContext().addOverriddenMethod(this, MD);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001908}
1909
1910CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001911 if (isa<CXXConstructorDecl>(this)) return nullptr;
Douglas Gregor832940b2010-03-02 23:58:15 +00001912 return getASTContext().overridden_methods_begin(this);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001913}
1914
1915CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
Craig Topper36250ad2014-05-12 05:36:57 +00001916 if (isa<CXXConstructorDecl>(this)) return nullptr;
Douglas Gregor832940b2010-03-02 23:58:15 +00001917 return getASTContext().overridden_methods_end(this);
Anders Carlsson36d87e12009-05-16 23:58:37 +00001918}
1919
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001920unsigned CXXMethodDecl::size_overridden_methods() const {
Eli Friedman91359022012-03-10 01:39:01 +00001921 if (isa<CXXConstructorDecl>(this)) return 0;
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001922 return getASTContext().overridden_methods_size(this);
1923}
1924
Clement Courbet6ecaec82016-07-05 07:49:31 +00001925CXXMethodDecl::overridden_method_range
1926CXXMethodDecl::overridden_methods() const {
1927 if (isa<CXXConstructorDecl>(this))
1928 return overridden_method_range(nullptr, nullptr);
1929 return getASTContext().overridden_methods(this);
1930}
1931
Ted Kremenek21475702008-09-05 17:16:31 +00001932QualType CXXMethodDecl::getThisType(ASTContext &C) const {
Argyrios Kyrtzidis962c20e2008-10-24 22:28:18 +00001933 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1934 // If the member function is declared const, the type of this is const X*,
1935 // if the member function is declared volatile, the type of this is
1936 // volatile X*, and if the member function is declared const volatile,
1937 // the type of this is const volatile X*.
1938
Ted Kremenek21475702008-09-05 17:16:31 +00001939 assert(isInstance() && "No 'this' for static methods!");
Anders Carlsson20ee0ed2009-06-13 02:59:33 +00001940
John McCalle78aac42010-03-10 03:28:59 +00001941 QualType ClassTy = C.getTypeDeclType(getParent());
John McCall8ccfcb52009-09-24 19:53:00 +00001942 ClassTy = C.getQualifiedType(ClassTy,
Andrey Bokhanko67a41862016-05-26 10:06:01 +00001943 Qualifiers::fromCVRUMask(getTypeQualifiers()));
Anders Carlsson7ca3f6f2009-07-10 21:35:09 +00001944 return C.getPointerType(ClassTy);
Ted Kremenek21475702008-09-05 17:16:31 +00001945}
1946
Eli Friedman71a26d82009-12-06 20:50:05 +00001947bool CXXMethodDecl::hasInlineBody() const {
Douglas Gregora318efd2010-01-05 19:06:31 +00001948 // If this function is a template instantiation, look at the template from
1949 // which it was instantiated.
1950 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1951 if (!CheckFn)
1952 CheckFn = this;
Richard Smith6c7161162017-08-12 01:46:03 +00001953
Eli Friedman71a26d82009-12-06 20:50:05 +00001954 const FunctionDecl *fn;
Richard Smith6c7161162017-08-12 01:46:03 +00001955 return CheckFn->isDefined(fn) && !fn->isOutOfLine() &&
1956 (fn->doesThisDeclarationHaveABody() || fn->willHaveBody());
Eli Friedman71a26d82009-12-06 20:50:05 +00001957}
1958
Douglas Gregor355efbb2012-02-17 03:02:34 +00001959bool CXXMethodDecl::isLambdaStaticInvoker() const {
Faisal Vali571df122013-09-29 08:45:24 +00001960 const CXXRecordDecl *P = getParent();
1961 if (P->isLambda()) {
1962 if (const CXXMethodDecl *StaticInvoker = P->getLambdaStaticInvoker()) {
1963 if (StaticInvoker == this) return true;
1964 if (P->isGenericLambda() && this->isFunctionTemplateSpecialization())
1965 return StaticInvoker == this->getPrimaryTemplate()->getTemplatedDecl();
1966 }
1967 }
1968 return false;
Douglas Gregor355efbb2012-02-17 03:02:34 +00001969}
1970
Alexis Hunt1d792652011-01-08 20:30:50 +00001971CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1972 TypeSourceInfo *TInfo, bool IsVirtual,
1973 SourceLocation L, Expr *Init,
1974 SourceLocation R,
1975 SourceLocation EllipsisLoc)
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001976 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
1977 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
1978 IsWritten(false), SourceOrder(0) {}
Douglas Gregore8381c02008-11-05 04:29:56 +00001979
Alexis Hunt1d792652011-01-08 20:30:50 +00001980CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1981 FieldDecl *Member,
1982 SourceLocation MemberLoc,
1983 SourceLocation L, Expr *Init,
1984 SourceLocation R)
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001985 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1986 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1987 IsWritten(false), SourceOrder(0) {}
Francois Pichetd583da02010-12-04 09:14:42 +00001988
Alexis Hunt1d792652011-01-08 20:30:50 +00001989CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1990 IndirectFieldDecl *Member,
1991 SourceLocation MemberLoc,
1992 SourceLocation L, Expr *Init,
1993 SourceLocation R)
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00001994 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1995 LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
1996 IsWritten(false), SourceOrder(0) {}
Douglas Gregore8381c02008-11-05 04:29:56 +00001997
Alexis Hunt1d792652011-01-08 20:30:50 +00001998CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
Douglas Gregord73f3dd2011-11-01 01:16:03 +00001999 TypeSourceInfo *TInfo,
2000 SourceLocation L, Expr *Init,
Alexis Huntc5575cc2011-02-26 19:13:13 +00002001 SourceLocation R)
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002002 : Initializee(TInfo), Init(Init), LParenLoc(L), RParenLoc(R),
2003 IsDelegating(true), IsVirtual(false), IsWritten(false), SourceOrder(0) {}
Alexis Huntc5575cc2011-02-26 19:13:13 +00002004
Alexis Hunt1d792652011-01-08 20:30:50 +00002005TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002006 if (isBaseInitializer())
Alexis Hunta50dd462011-01-08 23:01:16 +00002007 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002008 else
2009 return TypeLoc();
2010}
2011
Alexis Hunt1d792652011-01-08 20:30:50 +00002012const Type *CXXCtorInitializer::getBaseClass() const {
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002013 if (isBaseInitializer())
Alexis Hunta50dd462011-01-08 23:01:16 +00002014 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002015 else
Craig Topper36250ad2014-05-12 05:36:57 +00002016 return nullptr;
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002017}
2018
Alexis Hunt1d792652011-01-08 20:30:50 +00002019SourceLocation CXXCtorInitializer::getSourceLocation() const {
Richard Smith938f40b2011-06-11 17:19:42 +00002020 if (isInClassMemberInitializer())
2021 return getAnyMember()->getLocation();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002022
David Blaikiea81d4102015-01-18 00:12:58 +00002023 if (isAnyMemberInitializer())
2024 return getMemberLocation();
2025
Douglas Gregord73f3dd2011-11-01 01:16:03 +00002026 if (TypeSourceInfo *TSInfo = Initializee.get<TypeSourceInfo*>())
2027 return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
2028
2029 return SourceLocation();
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002030}
2031
Alexis Hunt1d792652011-01-08 20:30:50 +00002032SourceRange CXXCtorInitializer::getSourceRange() const {
Richard Smith938f40b2011-06-11 17:19:42 +00002033 if (isInClassMemberInitializer()) {
2034 FieldDecl *D = getAnyMember();
2035 if (Expr *I = D->getInClassInitializer())
2036 return I->getSourceRange();
2037 return SourceRange();
2038 }
2039
Douglas Gregorc8c44b5d2009-12-02 22:36:29 +00002040 return SourceRange(getSourceLocation(), getRParenLoc());
Douglas Gregore8381c02008-11-05 04:29:56 +00002041}
2042
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002043void CXXConstructorDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002044
Richard Smith5179eb72016-06-28 19:03:57 +00002045CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C,
2046 unsigned ID,
2047 bool Inherited) {
2048 unsigned Extra = additionalSizeToAlloc<InheritedConstructor>(Inherited);
2049 auto *Result = new (C, ID, Extra) CXXConstructorDecl(
2050 C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
2051 false, false, false, false, InheritedConstructor());
2052 Result->IsInheritingConstructor = Inherited;
2053 return Result;
Chris Lattnerca025db2010-05-07 21:43:38 +00002054}
2055
2056CXXConstructorDecl *
Douglas Gregor61956c42008-10-31 09:07:45 +00002057CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00002058 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002059 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00002060 QualType T, TypeSourceInfo *TInfo,
Richard Smitha77a0a62011-08-15 21:04:07 +00002061 bool isExplicit, bool isInline,
Richard Smith5179eb72016-06-28 19:03:57 +00002062 bool isImplicitlyDeclared, bool isConstexpr,
2063 InheritedConstructor Inherited) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002064 assert(NameInfo.getName().getNameKind()
2065 == DeclarationName::CXXConstructorName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00002066 "Name must refer to a constructor");
Richard Smith5179eb72016-06-28 19:03:57 +00002067 unsigned Extra =
2068 additionalSizeToAlloc<InheritedConstructor>(Inherited ? 1 : 0);
2069 return new (C, RD, Extra) CXXConstructorDecl(
2070 C, RD, StartLoc, NameInfo, T, TInfo, isExplicit, isInline,
2071 isImplicitlyDeclared, isConstexpr, Inherited);
Douglas Gregor61956c42008-10-31 09:07:45 +00002072}
2073
Richard Smithc2bb8182015-03-24 06:36:48 +00002074CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
2075 return CtorInitializers.get(getASTContext().getExternalSource());
2076}
2077
Douglas Gregord73f3dd2011-11-01 01:16:03 +00002078CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
2079 assert(isDelegatingConstructor() && "Not a delegating constructor!");
2080 Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
2081 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(E))
2082 return Construct->getConstructor();
Craig Topper36250ad2014-05-12 05:36:57 +00002083
2084 return nullptr;
Douglas Gregord73f3dd2011-11-01 01:16:03 +00002085}
2086
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002087bool CXXConstructorDecl::isDefaultConstructor() const {
2088 // C++ [class.ctor]p5:
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +00002089 // A default constructor for a class X is a constructor of class
2090 // X that can be called without an argument.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002091 return (getNumParams() == 0) ||
Anders Carlsson6eb55572009-08-25 05:12:04 +00002092 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002093}
2094
Mike Stump11289f42009-09-09 15:08:12 +00002095bool
Douglas Gregor507eb872009-12-22 00:34:07 +00002096CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
Douglas Gregorf282a762011-01-21 19:38:21 +00002097 return isCopyOrMoveConstructor(TypeQuals) &&
2098 getParamDecl(0)->getType()->isLValueReferenceType();
2099}
2100
2101bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
2102 return isCopyOrMoveConstructor(TypeQuals) &&
2103 getParamDecl(0)->getType()->isRValueReferenceType();
2104}
2105
2106/// \brief Determine whether this is a copy or move constructor.
2107bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002108 // C++ [class.copy]p2:
Douglas Gregorcfd8ddc2008-11-05 16:20:31 +00002109 // A non-template constructor for class X is a copy constructor
2110 // if its first parameter is of type X&, const X&, volatile X& or
2111 // const volatile X&, and either there are no other parameters
2112 // or else all other parameters have default arguments (8.3.6).
Douglas Gregorf282a762011-01-21 19:38:21 +00002113 // C++0x [class.copy]p3:
2114 // A non-template constructor for class X is a move constructor if its
2115 // first parameter is of type X&&, const X&&, volatile X&&, or
2116 // const volatile X&&, and either there are no other parameters or else
2117 // all other parameters have default arguments.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002118 if ((getNumParams() < 1) ||
Douglas Gregora14b43b2009-10-13 23:45:19 +00002119 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
Craig Topper36250ad2014-05-12 05:36:57 +00002120 (getPrimaryTemplate() != nullptr) ||
2121 (getDescribedFunctionTemplate() != nullptr))
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002122 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00002123
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002124 const ParmVarDecl *Param = getParamDecl(0);
Douglas Gregorf282a762011-01-21 19:38:21 +00002125
2126 // Do we have a reference type?
2127 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
Douglas Gregorff7028a2009-11-13 23:59:09 +00002128 if (!ParamRefType)
2129 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00002130
Douglas Gregorff7028a2009-11-13 23:59:09 +00002131 // Is it a reference to our class type?
Douglas Gregor507eb872009-12-22 00:34:07 +00002132 ASTContext &Context = getASTContext();
2133
Douglas Gregorff7028a2009-11-13 23:59:09 +00002134 CanQualType PointeeType
2135 = Context.getCanonicalType(ParamRefType->getPointeeType());
Douglas Gregorf70b2b42009-09-15 20:50:23 +00002136 CanQualType ClassTy
2137 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002138 if (PointeeType.getUnqualifiedType() != ClassTy)
2139 return false;
Douglas Gregorf282a762011-01-21 19:38:21 +00002140
John McCall8ccfcb52009-09-24 19:53:00 +00002141 // FIXME: other qualifiers?
Douglas Gregorf282a762011-01-21 19:38:21 +00002142
2143 // We have a copy or move constructor.
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002144 TypeQuals = PointeeType.getCVRQualifiers();
Douglas Gregorf282a762011-01-21 19:38:21 +00002145 return true;
Douglas Gregoreebb5c12008-10-31 20:25:05 +00002146}
2147
Anders Carlssond20e7952009-08-28 16:57:08 +00002148bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
Douglas Gregor26bee0b2008-10-31 16:23:19 +00002149 // C++ [class.conv.ctor]p1:
2150 // A constructor declared without the function-specifier explicit
2151 // that can be called with a single parameter specifies a
2152 // conversion from the type of its first parameter to the type of
2153 // its class. Such a constructor is called a converting
2154 // constructor.
Anders Carlssond20e7952009-08-28 16:57:08 +00002155 if (isExplicit() && !AllowExplicit)
Douglas Gregor26bee0b2008-10-31 16:23:19 +00002156 return false;
2157
Mike Stump11289f42009-09-09 15:08:12 +00002158 return (getNumParams() == 0 &&
John McCall9dd450b2009-09-21 23:43:11 +00002159 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
Douglas Gregor26bee0b2008-10-31 16:23:19 +00002160 (getNumParams() == 1) ||
Douglas Gregorc65e1592012-06-05 23:44:51 +00002161 (getNumParams() > 1 &&
2162 (getParamDecl(1)->hasDefaultArg() ||
2163 getParamDecl(1)->isParameterPack()));
Douglas Gregor26bee0b2008-10-31 16:23:19 +00002164}
Douglas Gregor61956c42008-10-31 09:07:45 +00002165
Douglas Gregorbd6b17f2010-11-08 17:16:59 +00002166bool CXXConstructorDecl::isSpecializationCopyingObject() const {
Douglas Gregorffe14e32009-11-14 01:20:54 +00002167 if ((getNumParams() < 1) ||
2168 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
Craig Topper36250ad2014-05-12 05:36:57 +00002169 (getDescribedFunctionTemplate() != nullptr))
Douglas Gregorffe14e32009-11-14 01:20:54 +00002170 return false;
2171
2172 const ParmVarDecl *Param = getParamDecl(0);
2173
2174 ASTContext &Context = getASTContext();
2175 CanQualType ParamType = Context.getCanonicalType(Param->getType());
2176
Douglas Gregorffe14e32009-11-14 01:20:54 +00002177 // Is it the same as our our class type?
2178 CanQualType ClassTy
2179 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
2180 if (ParamType.getUnqualifiedType() != ClassTy)
2181 return false;
2182
2183 return true;
2184}
2185
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002186void CXXDestructorDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002187
Douglas Gregor831c93f2008-11-05 20:51:48 +00002188CXXDestructorDecl *
Douglas Gregor72172e92012-01-05 21:55:30 +00002189CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00002190 return new (C, ID)
2191 CXXDestructorDecl(C, nullptr, SourceLocation(), DeclarationNameInfo(),
2192 QualType(), nullptr, false, false);
Chris Lattnerca025db2010-05-07 21:43:38 +00002193}
2194
2195CXXDestructorDecl *
Douglas Gregor831c93f2008-11-05 20:51:48 +00002196CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00002197 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002198 const DeclarationNameInfo &NameInfo,
Craig Silversteinaf8808d2010-10-21 00:44:50 +00002199 QualType T, TypeSourceInfo *TInfo,
Richard Smitha77a0a62011-08-15 21:04:07 +00002200 bool isInline, bool isImplicitlyDeclared) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002201 assert(NameInfo.getName().getNameKind()
2202 == DeclarationName::CXXDestructorName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00002203 "Name must refer to a destructor");
Richard Smith053f6c62014-05-16 23:01:30 +00002204 return new (C, RD) CXXDestructorDecl(C, RD, StartLoc, NameInfo, T, TInfo,
Richard Smithf7981722013-11-22 09:01:48 +00002205 isInline, isImplicitlyDeclared);
Douglas Gregor831c93f2008-11-05 20:51:48 +00002206}
2207
Richard Smith5b349582017-10-13 01:55:36 +00002208void CXXDestructorDecl::setOperatorDelete(FunctionDecl *OD, Expr *ThisArg) {
Richard Smithf8134002015-03-10 01:41:22 +00002209 auto *First = cast<CXXDestructorDecl>(getFirstDecl());
2210 if (OD && !First->OperatorDelete) {
2211 First->OperatorDelete = OD;
Richard Smith5b349582017-10-13 01:55:36 +00002212 First->OperatorDeleteThisArg = ThisArg;
Richard Smithf8134002015-03-10 01:41:22 +00002213 if (auto *L = getASTMutationListener())
Richard Smith5b349582017-10-13 01:55:36 +00002214 L->ResolvedOperatorDelete(First, OD, ThisArg);
Richard Smithf8134002015-03-10 01:41:22 +00002215 }
2216}
2217
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002218void CXXConversionDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002219
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002220CXXConversionDecl *
Douglas Gregor72172e92012-01-05 21:55:30 +00002221CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00002222 return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00002223 DeclarationNameInfo(), QualType(),
Craig Topper36250ad2014-05-12 05:36:57 +00002224 nullptr, false, false, false,
Richard Smithf7981722013-11-22 09:01:48 +00002225 SourceLocation());
Chris Lattnerca025db2010-05-07 21:43:38 +00002226}
2227
2228CXXConversionDecl *
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002229CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Abramo Bagnaradff19302011-03-08 08:55:46 +00002230 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002231 const DeclarationNameInfo &NameInfo,
John McCallbcd03502009-12-07 02:54:59 +00002232 QualType T, TypeSourceInfo *TInfo,
Douglas Gregorf2f08062011-03-08 17:10:18 +00002233 bool isInline, bool isExplicit,
Richard Smitha77a0a62011-08-15 21:04:07 +00002234 bool isConstexpr, SourceLocation EndLocation) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002235 assert(NameInfo.getName().getNameKind()
2236 == DeclarationName::CXXConversionFunctionName &&
Douglas Gregor77324f32008-11-17 14:58:09 +00002237 "Name must refer to a conversion function");
Richard Smith053f6c62014-05-16 23:01:30 +00002238 return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
Richard Smithf7981722013-11-22 09:01:48 +00002239 isInline, isExplicit, isConstexpr,
2240 EndLocation);
Douglas Gregordbc5daf2008-11-07 20:08:42 +00002241}
2242
Douglas Gregord3b672c2012-02-16 01:06:16 +00002243bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
2244 return isImplicit() && getParent()->isLambda() &&
2245 getConversionType()->isBlockPointerType();
2246}
2247
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002248void LinkageSpecDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002249
Chris Lattnerb8c18fa2008-11-04 16:51:42 +00002250LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
Mike Stump11289f42009-09-09 15:08:12 +00002251 DeclContext *DC,
Abramo Bagnaraea947882011-03-08 16:41:52 +00002252 SourceLocation ExternLoc,
2253 SourceLocation LangLoc,
Abramo Bagnara4a8cda82011-03-03 14:52:38 +00002254 LanguageIDs Lang,
Rafael Espindola327be3c2013-04-26 01:30:23 +00002255 bool HasBraces) {
Richard Smithf7981722013-11-22 09:01:48 +00002256 return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
Douglas Gregor29ff7d02008-12-16 22:23:02 +00002257}
Douglas Gregor889ceb72009-02-03 19:21:40 +00002258
Richard Smithf7981722013-11-22 09:01:48 +00002259LinkageSpecDecl *LinkageSpecDecl::CreateDeserialized(ASTContext &C,
2260 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002261 return new (C, ID) LinkageSpecDecl(nullptr, SourceLocation(),
2262 SourceLocation(), lang_c, false);
Douglas Gregor72172e92012-01-05 21:55:30 +00002263}
2264
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002265void UsingDirectiveDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002266
Douglas Gregor889ceb72009-02-03 19:21:40 +00002267UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
2268 SourceLocation L,
2269 SourceLocation NamespaceLoc,
Douglas Gregor12441b32011-02-25 16:33:46 +00002270 NestedNameSpecifierLoc QualifierLoc,
Douglas Gregor889ceb72009-02-03 19:21:40 +00002271 SourceLocation IdentLoc,
Sebastian Redla6602e92009-11-23 15:34:23 +00002272 NamedDecl *Used,
Douglas Gregor889ceb72009-02-03 19:21:40 +00002273 DeclContext *CommonAncestor) {
Sebastian Redla6602e92009-11-23 15:34:23 +00002274 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used))
2275 Used = NS->getOriginalNamespace();
Richard Smithf7981722013-11-22 09:01:48 +00002276 return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
2277 IdentLoc, Used, CommonAncestor);
Douglas Gregor889ceb72009-02-03 19:21:40 +00002278}
2279
Richard Smithf7981722013-11-22 09:01:48 +00002280UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C,
2281 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002282 return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
2283 SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00002284 NestedNameSpecifierLoc(),
Craig Topper36250ad2014-05-12 05:36:57 +00002285 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002286}
2287
Sebastian Redla6602e92009-11-23 15:34:23 +00002288NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
2289 if (NamespaceAliasDecl *NA =
2290 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
2291 return NA->getNamespace();
2292 return cast_or_null<NamespaceDecl>(NominatedNamespace);
2293}
2294
Richard Smith053f6c62014-05-16 23:01:30 +00002295NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
2296 SourceLocation StartLoc, SourceLocation IdLoc,
2297 IdentifierInfo *Id, NamespaceDecl *PrevDecl)
2298 : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace),
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002299 redeclarable_base(C), LocStart(StartLoc),
Richard Smith053f6c62014-05-16 23:01:30 +00002300 AnonOrFirstNamespaceAndInline(nullptr, Inline) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002301 setPreviousDecl(PrevDecl);
Richard Smith053f6c62014-05-16 23:01:30 +00002302
Douglas Gregore57e7522012-01-07 09:11:48 +00002303 if (PrevDecl)
2304 AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
2305}
2306
Douglas Gregor72172e92012-01-05 21:55:30 +00002307NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregore57e7522012-01-07 09:11:48 +00002308 bool Inline, SourceLocation StartLoc,
2309 SourceLocation IdLoc, IdentifierInfo *Id,
2310 NamespaceDecl *PrevDecl) {
Richard Smith053f6c62014-05-16 23:01:30 +00002311 return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id,
2312 PrevDecl);
Douglas Gregor72172e92012-01-05 21:55:30 +00002313}
2314
2315NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith053f6c62014-05-16 23:01:30 +00002316 return new (C, ID) NamespaceDecl(C, nullptr, false, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00002317 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002318}
2319
Chandler Carruth21c90602015-12-30 03:24:14 +00002320NamespaceDecl *NamespaceDecl::getOriginalNamespace() {
2321 if (isFirstDecl())
2322 return this;
2323
2324 return AnonOrFirstNamespaceAndInline.getPointer();
2325}
2326
2327const NamespaceDecl *NamespaceDecl::getOriginalNamespace() const {
2328 if (isFirstDecl())
2329 return this;
2330
2331 return AnonOrFirstNamespaceAndInline.getPointer();
2332}
2333
2334bool NamespaceDecl::isOriginalNamespace() const { return isFirstDecl(); }
2335
Richard Smithd7af8a32014-05-10 01:17:36 +00002336NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() {
2337 return getNextRedeclaration();
Rafael Espindola8ef7f682013-11-26 15:12:20 +00002338}
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002339
Rafael Espindola8ef7f682013-11-26 15:12:20 +00002340NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() {
2341 return getPreviousDecl();
2342}
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002343
Rafael Espindola8ef7f682013-11-26 15:12:20 +00002344NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() {
2345 return getMostRecentDecl();
2346}
2347
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002348void NamespaceAliasDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002349
Richard Smithf4634362014-09-03 23:11:22 +00002350NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() {
2351 return getNextRedeclaration();
2352}
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002353
Richard Smithf4634362014-09-03 23:11:22 +00002354NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() {
2355 return getPreviousDecl();
2356}
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002357
Richard Smithf4634362014-09-03 23:11:22 +00002358NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() {
2359 return getMostRecentDecl();
2360}
2361
Mike Stump11289f42009-09-09 15:08:12 +00002362NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregor01a430132010-09-01 03:07:18 +00002363 SourceLocation UsingLoc,
Mike Stump11289f42009-09-09 15:08:12 +00002364 SourceLocation AliasLoc,
2365 IdentifierInfo *Alias,
Douglas Gregorc05ba2e2011-02-25 17:08:07 +00002366 NestedNameSpecifierLoc QualifierLoc,
Mike Stump11289f42009-09-09 15:08:12 +00002367 SourceLocation IdentLoc,
Anders Carlssonff25fdf2009-03-28 22:58:02 +00002368 NamedDecl *Namespace) {
Richard Smithf4634362014-09-03 23:11:22 +00002369 // FIXME: Preserve the aliased namespace as written.
Sebastian Redla6602e92009-11-23 15:34:23 +00002370 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
2371 Namespace = NS->getOriginalNamespace();
Richard Smithf4634362014-09-03 23:11:22 +00002372 return new (C, DC) NamespaceAliasDecl(C, DC, UsingLoc, AliasLoc, Alias,
Richard Smithf7981722013-11-22 09:01:48 +00002373 QualifierLoc, IdentLoc, Namespace);
Anders Carlssonff25fdf2009-03-28 22:58:02 +00002374}
2375
Douglas Gregor72172e92012-01-05 21:55:30 +00002376NamespaceAliasDecl *
2377NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf4634362014-09-03 23:11:22 +00002378 return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(),
Craig Topper36250ad2014-05-12 05:36:57 +00002379 SourceLocation(), nullptr,
2380 NestedNameSpecifierLoc(),
2381 SourceLocation(), nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002382}
2383
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002384void UsingShadowDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002385
Richard Smith5179eb72016-06-28 19:03:57 +00002386UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC,
2387 SourceLocation Loc, UsingDecl *Using,
2388 NamedDecl *Target)
2389 : NamedDecl(K, DC, Loc, Using ? Using->getDeclName() : DeclarationName()),
2390 redeclarable_base(C), Underlying(Target),
2391 UsingOrNextShadow(cast<NamedDecl>(Using)) {
2392 if (Target)
2393 IdentifierNamespace = Target->getIdentifierNamespace();
2394 setImplicit();
2395}
2396
2397UsingShadowDecl::UsingShadowDecl(Kind K, ASTContext &C, EmptyShell Empty)
2398 : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()),
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002399 redeclarable_base(C) {}
Richard Smith5179eb72016-06-28 19:03:57 +00002400
Douglas Gregor72172e92012-01-05 21:55:30 +00002401UsingShadowDecl *
2402UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith5179eb72016-06-28 19:03:57 +00002403 return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell());
Douglas Gregor72172e92012-01-05 21:55:30 +00002404}
2405
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002406UsingDecl *UsingShadowDecl::getUsingDecl() const {
2407 const UsingShadowDecl *Shadow = this;
2408 while (const UsingShadowDecl *NextShadow =
2409 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
2410 Shadow = NextShadow;
2411 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
2412}
2413
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002414void ConstructorUsingShadowDecl::anchor() {}
Richard Smith5179eb72016-06-28 19:03:57 +00002415
2416ConstructorUsingShadowDecl *
2417ConstructorUsingShadowDecl::Create(ASTContext &C, DeclContext *DC,
2418 SourceLocation Loc, UsingDecl *Using,
2419 NamedDecl *Target, bool IsVirtual) {
2420 return new (C, DC) ConstructorUsingShadowDecl(C, DC, Loc, Using, Target,
2421 IsVirtual);
2422}
2423
2424ConstructorUsingShadowDecl *
2425ConstructorUsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2426 return new (C, ID) ConstructorUsingShadowDecl(C, EmptyShell());
2427}
2428
2429CXXRecordDecl *ConstructorUsingShadowDecl::getNominatedBaseClass() const {
2430 return getUsingDecl()->getQualifier()->getAsRecordDecl();
2431}
2432
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002433void UsingDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002434
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002435void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
2436 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
2437 "declaration already in set");
2438 assert(S->getUsingDecl() == this);
2439
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002440 if (FirstUsingShadow.getPointer())
2441 S->UsingOrNextShadow = FirstUsingShadow.getPointer();
2442 FirstUsingShadow.setPointer(S);
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002443}
2444
2445void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
2446 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
2447 "declaration not in set");
2448 assert(S->getUsingDecl() == this);
2449
2450 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
2451
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002452 if (FirstUsingShadow.getPointer() == S) {
2453 FirstUsingShadow.setPointer(
2454 dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002455 S->UsingOrNextShadow = this;
2456 return;
2457 }
2458
Benjamin Kramere78f8ee2012-01-07 19:09:05 +00002459 UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
Argyrios Kyrtzidis2703beb2010-11-10 05:40:41 +00002460 while (Prev->UsingOrNextShadow != S)
2461 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
2462 Prev->UsingOrNextShadow = S->UsingOrNextShadow;
2463 S->UsingOrNextShadow = this;
2464}
2465
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002466UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
2467 NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara8de74e92010-08-12 11:46:03 +00002468 const DeclarationNameInfo &NameInfo,
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00002469 bool HasTypename) {
Richard Smithf7981722013-11-22 09:01:48 +00002470 return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
Douglas Gregorfec52632009-06-20 00:51:54 +00002471}
2472
Douglas Gregor72172e92012-01-05 21:55:30 +00002473UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002474 return new (C, ID) UsingDecl(nullptr, SourceLocation(),
2475 NestedNameSpecifierLoc(), DeclarationNameInfo(),
2476 false);
Douglas Gregor72172e92012-01-05 21:55:30 +00002477}
2478
Enea Zaffanellac70b2512013-07-17 17:28:56 +00002479SourceRange UsingDecl::getSourceRange() const {
2480 SourceLocation Begin = isAccessDeclaration()
2481 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2482 return SourceRange(Begin, getNameInfo().getEndLoc());
2483}
2484
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002485void UsingPackDecl::anchor() {}
Richard Smith151c4562016-12-20 21:35:28 +00002486
2487UsingPackDecl *UsingPackDecl::Create(ASTContext &C, DeclContext *DC,
2488 NamedDecl *InstantiatedFrom,
2489 ArrayRef<NamedDecl *> UsingDecls) {
2490 size_t Extra = additionalSizeToAlloc<NamedDecl *>(UsingDecls.size());
2491 return new (C, DC, Extra) UsingPackDecl(DC, InstantiatedFrom, UsingDecls);
2492}
2493
2494UsingPackDecl *UsingPackDecl::CreateDeserialized(ASTContext &C, unsigned ID,
2495 unsigned NumExpansions) {
2496 size_t Extra = additionalSizeToAlloc<NamedDecl *>(NumExpansions);
2497 auto *Result = new (C, ID, Extra) UsingPackDecl(nullptr, nullptr, None);
2498 Result->NumExpansions = NumExpansions;
2499 auto *Trail = Result->getTrailingObjects<NamedDecl *>();
2500 for (unsigned I = 0; I != NumExpansions; ++I)
2501 new (Trail + I) NamedDecl*(nullptr);
2502 return Result;
2503}
2504
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002505void UnresolvedUsingValueDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002506
John McCalle61f2ba2009-11-18 02:36:19 +00002507UnresolvedUsingValueDecl *
2508UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
2509 SourceLocation UsingLoc,
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002510 NestedNameSpecifierLoc QualifierLoc,
Richard Smith151c4562016-12-20 21:35:28 +00002511 const DeclarationNameInfo &NameInfo,
2512 SourceLocation EllipsisLoc) {
Richard Smithf7981722013-11-22 09:01:48 +00002513 return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
Richard Smith151c4562016-12-20 21:35:28 +00002514 QualifierLoc, NameInfo,
2515 EllipsisLoc);
John McCalle61f2ba2009-11-18 02:36:19 +00002516}
2517
Douglas Gregor72172e92012-01-05 21:55:30 +00002518UnresolvedUsingValueDecl *
2519UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002520 return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(),
2521 SourceLocation(),
Richard Smithf7981722013-11-22 09:01:48 +00002522 NestedNameSpecifierLoc(),
Richard Smith151c4562016-12-20 21:35:28 +00002523 DeclarationNameInfo(),
2524 SourceLocation());
Douglas Gregor72172e92012-01-05 21:55:30 +00002525}
2526
Enea Zaffanellac70b2512013-07-17 17:28:56 +00002527SourceRange UnresolvedUsingValueDecl::getSourceRange() const {
2528 SourceLocation Begin = isAccessDeclaration()
2529 ? getQualifierLoc().getBeginLoc() : UsingLocation;
2530 return SourceRange(Begin, getNameInfo().getEndLoc());
2531}
2532
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002533void UnresolvedUsingTypenameDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002534
John McCalle61f2ba2009-11-18 02:36:19 +00002535UnresolvedUsingTypenameDecl *
2536UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
2537 SourceLocation UsingLoc,
2538 SourceLocation TypenameLoc,
Douglas Gregora9d87bc2011-02-25 00:36:19 +00002539 NestedNameSpecifierLoc QualifierLoc,
John McCalle61f2ba2009-11-18 02:36:19 +00002540 SourceLocation TargetNameLoc,
Richard Smith151c4562016-12-20 21:35:28 +00002541 DeclarationName TargetName,
2542 SourceLocation EllipsisLoc) {
Richard Smithf7981722013-11-22 09:01:48 +00002543 return new (C, DC) UnresolvedUsingTypenameDecl(
2544 DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc,
Richard Smith151c4562016-12-20 21:35:28 +00002545 TargetName.getAsIdentifierInfo(), EllipsisLoc);
Anders Carlsson8305c1f2009-08-28 05:30:28 +00002546}
2547
Douglas Gregor72172e92012-01-05 21:55:30 +00002548UnresolvedUsingTypenameDecl *
2549UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00002550 return new (C, ID) UnresolvedUsingTypenameDecl(
Craig Topper36250ad2014-05-12 05:36:57 +00002551 nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
Richard Smith151c4562016-12-20 21:35:28 +00002552 SourceLocation(), nullptr, SourceLocation());
Douglas Gregor72172e92012-01-05 21:55:30 +00002553}
2554
Eugene Zelenko4a5354f2017-11-14 23:13:32 +00002555void StaticAssertDecl::anchor() {}
David Blaikie68e081d2011-12-20 02:48:34 +00002556
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00002557StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnaraea947882011-03-08 16:41:52 +00002558 SourceLocation StaticAssertLoc,
2559 Expr *AssertExpr,
2560 StringLiteral *Message,
Richard Smithded9c2e2012-07-11 22:37:56 +00002561 SourceLocation RParenLoc,
2562 bool Failed) {
Richard Smithf7981722013-11-22 09:01:48 +00002563 return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
2564 RParenLoc, Failed);
Anders Carlsson5bbe1d72009-03-14 00:25:26 +00002565}
2566
Richard Smithf7981722013-11-22 09:01:48 +00002567StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
Douglas Gregor72172e92012-01-05 21:55:30 +00002568 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002569 return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
2570 nullptr, SourceLocation(), false);
Richard Smithf7981722013-11-22 09:01:48 +00002571}
2572
Richard Smithbdb84f32016-07-22 23:36:59 +00002573void BindingDecl::anchor() {}
2574
2575BindingDecl *BindingDecl::Create(ASTContext &C, DeclContext *DC,
2576 SourceLocation IdLoc, IdentifierInfo *Id) {
Richard Smith32cb8c92016-08-12 00:53:41 +00002577 return new (C, DC) BindingDecl(DC, IdLoc, Id);
Richard Smithbdb84f32016-07-22 23:36:59 +00002578}
2579
2580BindingDecl *BindingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smith32cb8c92016-08-12 00:53:41 +00002581 return new (C, ID) BindingDecl(nullptr, SourceLocation(), nullptr);
Richard Smithbdb84f32016-07-22 23:36:59 +00002582}
2583
Richard Smith97fcf4b2016-08-14 23:15:52 +00002584VarDecl *BindingDecl::getHoldingVar() const {
2585 Expr *B = getBinding();
2586 if (!B)
2587 return nullptr;
2588 auto *DRE = dyn_cast<DeclRefExpr>(B->IgnoreImplicit());
2589 if (!DRE)
2590 return nullptr;
2591
2592 auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
2593 assert(VD->isImplicit() && "holding var for binding decl not implicit");
2594 return VD;
2595}
2596
Richard Smithbdb84f32016-07-22 23:36:59 +00002597void DecompositionDecl::anchor() {}
2598
2599DecompositionDecl *DecompositionDecl::Create(ASTContext &C, DeclContext *DC,
2600 SourceLocation StartLoc,
2601 SourceLocation LSquareLoc,
2602 QualType T, TypeSourceInfo *TInfo,
2603 StorageClass SC,
2604 ArrayRef<BindingDecl *> Bindings) {
2605 size_t Extra = additionalSizeToAlloc<BindingDecl *>(Bindings.size());
2606 return new (C, DC, Extra)
2607 DecompositionDecl(C, DC, StartLoc, LSquareLoc, T, TInfo, SC, Bindings);
2608}
2609
2610DecompositionDecl *DecompositionDecl::CreateDeserialized(ASTContext &C,
2611 unsigned ID,
2612 unsigned NumBindings) {
2613 size_t Extra = additionalSizeToAlloc<BindingDecl *>(NumBindings);
Richard Smith7b76d812016-08-12 02:21:25 +00002614 auto *Result = new (C, ID, Extra)
2615 DecompositionDecl(C, nullptr, SourceLocation(), SourceLocation(),
2616 QualType(), nullptr, StorageClass(), None);
Richard Smithbdb84f32016-07-22 23:36:59 +00002617 // Set up and clean out the bindings array.
2618 Result->NumBindings = NumBindings;
2619 auto *Trail = Result->getTrailingObjects<BindingDecl *>();
2620 for (unsigned I = 0; I != NumBindings; ++I)
2621 new (Trail + I) BindingDecl*(nullptr);
2622 return Result;
2623}
2624
Richard Smith7873de02016-08-11 22:25:46 +00002625void DecompositionDecl::printName(llvm::raw_ostream &os) const {
2626 os << '[';
2627 bool Comma = false;
2628 for (auto *B : bindings()) {
2629 if (Comma)
2630 os << ", ";
2631 B->printName(os);
2632 Comma = true;
2633 }
2634 os << ']';
2635}
2636
Richard Smithf7981722013-11-22 09:01:48 +00002637MSPropertyDecl *MSPropertyDecl::Create(ASTContext &C, DeclContext *DC,
2638 SourceLocation L, DeclarationName N,
2639 QualType T, TypeSourceInfo *TInfo,
2640 SourceLocation StartL,
2641 IdentifierInfo *Getter,
2642 IdentifierInfo *Setter) {
2643 return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter);
2644}
2645
2646MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C,
2647 unsigned ID) {
Craig Topper36250ad2014-05-12 05:36:57 +00002648 return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
2649 DeclarationName(), QualType(), nullptr,
2650 SourceLocation(), nullptr, nullptr);
Douglas Gregor72172e92012-01-05 21:55:30 +00002651}
2652
Anders Carlsson6750d162009-03-26 23:46:50 +00002653static const char *getAccessName(AccessSpecifier AS) {
2654 switch (AS) {
Anders Carlsson6750d162009-03-26 23:46:50 +00002655 case AS_none:
David Blaikie83d382b2011-09-23 05:06:16 +00002656 llvm_unreachable("Invalid access specifier!");
Anders Carlsson6750d162009-03-26 23:46:50 +00002657 case AS_public:
2658 return "public";
2659 case AS_private:
2660 return "private";
2661 case AS_protected:
2662 return "protected";
2663 }
David Blaikief47fa302012-01-17 02:30:50 +00002664 llvm_unreachable("Invalid access specifier!");
Anders Carlsson6750d162009-03-26 23:46:50 +00002665}
2666
2667const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
2668 AccessSpecifier AS) {
2669 return DB << getAccessName(AS);
2670}
Richard Smith84f6dcf2012-02-02 01:16:57 +00002671
2672const PartialDiagnostic &clang::operator<<(const PartialDiagnostic &DB,
2673 AccessSpecifier AS) {
2674 return DB << getAccessName(AS);
2675}