blob: 94daf484458a3f08d0a987973c37c6c85e45a93e [file] [log] [blame]
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001//===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the C++ related Decl classes.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/DeclCXX.h"
Douglas Gregord475b8d2009-03-25 21:17:03 +000015#include "clang/AST/DeclTemplate.h"
Ted Kremenek4b7c9832008-09-05 17:16:31 +000016#include "clang/AST/ASTContext.h"
Anders Carlssonfb311762009-03-14 00:25:26 +000017#include "clang/AST/Expr.h"
Douglas Gregor7d7e6722008-11-12 23:21:09 +000018#include "clang/Basic/IdentifierTable.h"
Douglas Gregorfdfab6b2008-12-23 21:31:30 +000019#include "llvm/ADT/STLExtras.h"
Ted Kremenek4b7c9832008-09-05 17:16:31 +000020using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// Decl Allocation/Deallocation Method Implementations
24//===----------------------------------------------------------------------===//
Douglas Gregor72c3f312008-12-05 18:15:24 +000025
Douglas Gregor3e00bad2009-02-17 01:05:43 +000026CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, DeclContext *DC,
Douglas Gregor7d7e6722008-11-12 23:21:09 +000027 SourceLocation L, IdentifierInfo *Id)
Douglas Gregor3e00bad2009-02-17 01:05:43 +000028 : RecordDecl(K, TK, DC, L, Id),
Douglas Gregor7d7e6722008-11-12 23:21:09 +000029 UserDeclaredConstructor(false), UserDeclaredCopyConstructor(false),
Sebastian Redl64b45f72009-01-05 20:52:13 +000030 UserDeclaredCopyAssignment(false), UserDeclaredDestructor(false),
Anders Carlsson67e4dd22009-03-22 01:52:17 +000031 Aggregate(true), PlainOldData(true), Polymorphic(false), Abstract(false),
Anders Carlsson072abef2009-04-17 02:34:54 +000032 HasTrivialConstructor(true), HasTrivialDestructor(true),
Douglas Gregord475b8d2009-03-25 21:17:03 +000033 Bases(0), NumBases(0), Conversions(DC, DeclarationName()),
34 TemplateOrInstantiation() { }
Douglas Gregor7d7e6722008-11-12 23:21:09 +000035
Ted Kremenek4b7c9832008-09-05 17:16:31 +000036CXXRecordDecl *CXXRecordDecl::Create(ASTContext &C, TagKind TK, DeclContext *DC,
37 SourceLocation L, IdentifierInfo *Id,
Douglas Gregoraafc0cc2009-05-15 19:11:46 +000038 CXXRecordDecl* PrevDecl,
39 bool DelayTypeCreation) {
Douglas Gregor3e00bad2009-02-17 01:05:43 +000040 CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TK, DC, L, Id);
Douglas Gregoraafc0cc2009-05-15 19:11:46 +000041 if (!DelayTypeCreation)
42 C.getTypeDeclType(R, PrevDecl);
Ted Kremenek4b7c9832008-09-05 17:16:31 +000043 return R;
44}
45
Douglas Gregorf8268ae2008-10-22 17:49:05 +000046CXXRecordDecl::~CXXRecordDecl() {
Douglas Gregorf8268ae2008-10-22 17:49:05 +000047 delete [] Bases;
48}
49
Douglas Gregor57c856b2008-10-23 18:13:27 +000050void
51CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
52 unsigned NumBases) {
Douglas Gregor64bffa92008-11-05 16:20:31 +000053 // C++ [dcl.init.aggr]p1:
54 // An aggregate is an array or a class (clause 9) with [...]
55 // no base classes [...].
56 Aggregate = false;
57
Douglas Gregor57c856b2008-10-23 18:13:27 +000058 if (this->Bases)
59 delete [] this->Bases;
60
Douglas Gregor2943aed2009-03-03 04:44:36 +000061 // FIXME: allocate using the ASTContext
Douglas Gregor57c856b2008-10-23 18:13:27 +000062 this->Bases = new CXXBaseSpecifier[NumBases];
63 this->NumBases = NumBases;
64 for (unsigned i = 0; i < NumBases; ++i)
65 this->Bases[i] = *Bases[i];
66}
67
Douglas Gregor396b7cd2008-11-03 17:51:48 +000068bool CXXRecordDecl::hasConstCopyConstructor(ASTContext &Context) const {
Sebastian Redl64b45f72009-01-05 20:52:13 +000069 QualType ClassType
70 = Context.getTypeDeclType(const_cast<CXXRecordDecl*>(this));
Douglas Gregor9e7d9de2008-12-15 21:24:18 +000071 DeclarationName ConstructorName
72 = Context.DeclarationNames.getCXXConstructorName(
73 Context.getCanonicalType(ClassType));
74 unsigned TypeQuals;
Douglas Gregorfdfab6b2008-12-23 21:31:30 +000075 DeclContext::lookup_const_iterator Con, ConEnd;
Douglas Gregor6ab35242009-04-09 21:40:53 +000076 for (llvm::tie(Con, ConEnd) = this->lookup(Context, ConstructorName);
Douglas Gregorfdfab6b2008-12-23 21:31:30 +000077 Con != ConEnd; ++Con) {
Douglas Gregor396b7cd2008-11-03 17:51:48 +000078 if (cast<CXXConstructorDecl>(*Con)->isCopyConstructor(Context, TypeQuals) &&
Eli Friedmane8e32052008-12-16 20:06:41 +000079 (TypeQuals & QualType::Const) != 0)
Douglas Gregor396b7cd2008-11-03 17:51:48 +000080 return true;
81 }
Douglas Gregorfdfab6b2008-12-23 21:31:30 +000082
Douglas Gregor396b7cd2008-11-03 17:51:48 +000083 return false;
84}
85
Sebastian Redl64b45f72009-01-05 20:52:13 +000086bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context) const {
87 QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType(
88 const_cast<CXXRecordDecl*>(this)));
89 DeclarationName OpName =Context.DeclarationNames.getCXXOperatorName(OO_Equal);
90
91 DeclContext::lookup_const_iterator Op, OpEnd;
Douglas Gregor6ab35242009-04-09 21:40:53 +000092 for (llvm::tie(Op, OpEnd) = this->lookup(Context, OpName);
Sebastian Redl64b45f72009-01-05 20:52:13 +000093 Op != OpEnd; ++Op) {
94 // C++ [class.copy]p9:
95 // A user-declared copy assignment operator is a non-static non-template
96 // member function of class X with exactly one parameter of type X, X&,
97 // const X&, volatile X& or const volatile X&.
98 const CXXMethodDecl* Method = cast<CXXMethodDecl>(*Op);
99 if (Method->isStatic())
100 continue;
101 // TODO: Skip templates? Or is this implicitly done due to parameter types?
Douglas Gregor72564e72009-02-26 23:50:07 +0000102 const FunctionProtoType *FnType =
103 Method->getType()->getAsFunctionProtoType();
Sebastian Redl64b45f72009-01-05 20:52:13 +0000104 assert(FnType && "Overloaded operator has no prototype.");
105 // Don't assert on this; an invalid decl might have been left in the AST.
106 if (FnType->getNumArgs() != 1 || FnType->isVariadic())
107 continue;
108 bool AcceptsConst = true;
109 QualType ArgType = FnType->getArgType(0);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000110 if (const LValueReferenceType *Ref = ArgType->getAsLValueReferenceType()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +0000111 ArgType = Ref->getPointeeType();
Douglas Gregor2ff44782009-03-20 20:21:37 +0000112 // Is it a non-const lvalue reference?
Sebastian Redl64b45f72009-01-05 20:52:13 +0000113 if (!ArgType.isConstQualified())
114 AcceptsConst = false;
115 }
116 if (Context.getCanonicalType(ArgType).getUnqualifiedType() != ClassType)
117 continue;
118
119 // We have a single argument of type cv X or cv X&, i.e. we've found the
120 // copy assignment operator. Return whether it accepts const arguments.
121 return AcceptsConst;
122 }
123 assert(isInvalidDecl() &&
124 "No copy assignment operator declared in valid code.");
125 return false;
126}
127
128void
Douglas Gregor9e7d9de2008-12-15 21:24:18 +0000129CXXRecordDecl::addedConstructor(ASTContext &Context,
130 CXXConstructorDecl *ConDecl) {
Douglas Gregor6b3945f2009-01-07 19:46:03 +0000131 if (!ConDecl->isImplicit()) {
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000132 // Note that we have a user-declared constructor.
133 UserDeclaredConstructor = true;
134
Douglas Gregor64bffa92008-11-05 16:20:31 +0000135 // C++ [dcl.init.aggr]p1:
136 // An aggregate is an array or a class (clause 9) with no
137 // user-declared constructors (12.1) [...].
138 Aggregate = false;
139
Sebastian Redl64b45f72009-01-05 20:52:13 +0000140 // C++ [class]p4:
141 // A POD-struct is an aggregate class [...]
142 PlainOldData = false;
143
Anders Carlsson347ba892009-04-16 00:08:20 +0000144 // C++ [class.ctor]p5:
145 // A constructor is trivial if it is an implicitly-declared default
146 // constructor.
147 HasTrivialConstructor = false;
148
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000149 // Note when we have a user-declared copy constructor, which will
150 // suppress the implicit declaration of a copy constructor.
151 if (ConDecl->isCopyConstructor(Context))
152 UserDeclaredCopyConstructor = true;
153 }
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000154}
155
Sebastian Redl64b45f72009-01-05 20:52:13 +0000156void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context,
157 CXXMethodDecl *OpDecl) {
158 // We're interested specifically in copy assignment operators.
159 // Unlike addedConstructor, this method is not called for implicit
160 // declarations.
Douglas Gregor72564e72009-02-26 23:50:07 +0000161 const FunctionProtoType *FnType = OpDecl->getType()->getAsFunctionProtoType();
Sebastian Redl64b45f72009-01-05 20:52:13 +0000162 assert(FnType && "Overloaded operator has no proto function type.");
163 assert(FnType->getNumArgs() == 1 && !FnType->isVariadic());
164 QualType ArgType = FnType->getArgType(0);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000165 if (const LValueReferenceType *Ref = ArgType->getAsLValueReferenceType())
Sebastian Redl64b45f72009-01-05 20:52:13 +0000166 ArgType = Ref->getPointeeType();
167
168 ArgType = ArgType.getUnqualifiedType();
169 QualType ClassType = Context.getCanonicalType(Context.getTypeDeclType(
170 const_cast<CXXRecordDecl*>(this)));
171
172 if (ClassType != Context.getCanonicalType(ArgType))
173 return;
174
175 // This is a copy assignment operator.
176 // Suppress the implicit declaration of a copy constructor.
177 UserDeclaredCopyAssignment = true;
178
179 // C++ [class]p4:
180 // A POD-struct is an aggregate class that [...] has no user-defined copy
181 // assignment operator [...].
182 PlainOldData = false;
183}
184
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000185void CXXRecordDecl::addConversionFunction(ASTContext &Context,
186 CXXConversionDecl *ConvDecl) {
187 Conversions.addOverload(ConvDecl);
188}
189
Anders Carlsson7267c162009-05-29 21:03:38 +0000190const CXXDestructorDecl *
191CXXRecordDecl::getDestructor(ASTContext &Context) {
192 QualType ClassType = Context.getTypeDeclType(this);
193
194 DeclarationName Name
195 = Context.DeclarationNames.getCXXDestructorName(ClassType);
196
197 DeclContext::lookup_iterator I, E;
198 llvm::tie(I, E) = lookup(Context, Name);
199 assert(I != E && "Did not find a destructor!");
200
201 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(*I);
202 assert(++I == E && "Found more than one destructor!");
203
204 return Dtor;
205}
206
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000207CXXMethodDecl *
208CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Douglas Gregor10bd3682008-11-17 22:58:34 +0000209 SourceLocation L, DeclarationName N,
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000210 QualType T, bool isStatic, bool isInline) {
Steve Naroff3e970492009-01-27 21:25:57 +0000211 return new (C) CXXMethodDecl(CXXMethod, RD, L, N, T, isStatic, isInline);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000212}
213
Anders Carlsson05eb2442009-05-16 23:58:37 +0000214
215typedef llvm::DenseMap<const CXXMethodDecl*,
216 std::vector<const CXXMethodDecl *> *>
217 OverriddenMethodsMapTy;
218
219static OverriddenMethodsMapTy *OverriddenMethods = 0;
220
221void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
222 // FIXME: The CXXMethodDecl dtor needs to remove and free the entry.
223
224 if (!OverriddenMethods)
225 OverriddenMethods = new OverriddenMethodsMapTy();
226
227 std::vector<const CXXMethodDecl *> *&Methods = (*OverriddenMethods)[this];
228 if (!Methods)
229 Methods = new std::vector<const CXXMethodDecl *>;
230
231 Methods->push_back(MD);
232}
233
234CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
235 if (!OverriddenMethods)
236 return 0;
237
238 OverriddenMethodsMapTy::iterator it = OverriddenMethods->find(this);
239 if (it == OverriddenMethods->end())
240 return 0;
241 return &(*it->second)[0];
242}
243
244CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
245 if (!OverriddenMethods)
246 return 0;
247
248 OverriddenMethodsMapTy::iterator it = OverriddenMethods->find(this);
249 if (it == OverriddenMethods->end())
250 return 0;
251
252 return &(*it->second)[it->second->size()];
253}
254
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000255QualType CXXMethodDecl::getThisType(ASTContext &C) const {
Argyrios Kyrtzidisb0d178d2008-10-24 22:28:18 +0000256 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
257 // If the member function is declared const, the type of this is const X*,
258 // if the member function is declared volatile, the type of this is
259 // volatile X*, and if the member function is declared const volatile,
260 // the type of this is const volatile X*.
261
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000262 assert(isInstance() && "No 'this' for static methods!");
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000263 QualType ClassTy = C.getTagDeclType(const_cast<CXXRecordDecl*>(getParent()));
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000264 ClassTy = ClassTy.getWithAdditionalQualifiers(getTypeQualifiers());
265 return C.getPointerType(ClassTy).withConst();
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000266}
267
Douglas Gregor7ad83902008-11-05 04:29:56 +0000268CXXBaseOrMemberInitializer::
269CXXBaseOrMemberInitializer(QualType BaseType, Expr **Args, unsigned NumArgs)
270 : Args(0), NumArgs(0) {
271 BaseOrMember = reinterpret_cast<uintptr_t>(BaseType.getTypePtr());
272 assert((BaseOrMember & 0x01) == 0 && "Invalid base class type pointer");
273 BaseOrMember |= 0x01;
274
275 if (NumArgs > 0) {
276 this->NumArgs = NumArgs;
277 this->Args = new Expr*[NumArgs];
278 for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
279 this->Args[Idx] = Args[Idx];
280 }
281}
282
283CXXBaseOrMemberInitializer::
Douglas Gregor44b43212008-12-11 16:49:14 +0000284CXXBaseOrMemberInitializer(FieldDecl *Member, Expr **Args, unsigned NumArgs)
Douglas Gregor7ad83902008-11-05 04:29:56 +0000285 : Args(0), NumArgs(0) {
286 BaseOrMember = reinterpret_cast<uintptr_t>(Member);
287 assert((BaseOrMember & 0x01) == 0 && "Invalid member pointer");
288
289 if (NumArgs > 0) {
290 this->NumArgs = NumArgs;
291 this->Args = new Expr*[NumArgs];
292 for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
293 this->Args[Idx] = Args[Idx];
294 }
295}
296
297CXXBaseOrMemberInitializer::~CXXBaseOrMemberInitializer() {
298 delete [] Args;
299}
300
Douglas Gregorb48fe382008-10-31 09:07:45 +0000301CXXConstructorDecl *
302CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000303 SourceLocation L, DeclarationName N,
Douglas Gregorb48fe382008-10-31 09:07:45 +0000304 QualType T, bool isExplicit,
305 bool isInline, bool isImplicitlyDeclared) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000306 assert(N.getNameKind() == DeclarationName::CXXConstructorName &&
307 "Name must refer to a constructor");
Steve Naroff3e970492009-01-27 21:25:57 +0000308 return new (C) CXXConstructorDecl(RD, L, N, T, isExplicit, isInline,
Douglas Gregorb48fe382008-10-31 09:07:45 +0000309 isImplicitlyDeclared);
310}
311
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000312bool CXXConstructorDecl::isDefaultConstructor() const {
313 // C++ [class.ctor]p5:
Douglas Gregor64bffa92008-11-05 16:20:31 +0000314 // A default constructor for a class X is a constructor of class
315 // X that can be called without an argument.
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000316 return (getNumParams() == 0) ||
Douglas Gregorf03d7c72008-11-05 15:29:30 +0000317 (getNumParams() > 0 && getParamDecl(0)->getDefaultArg() != 0);
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000318}
319
320bool
321CXXConstructorDecl::isCopyConstructor(ASTContext &Context,
322 unsigned &TypeQuals) const {
323 // C++ [class.copy]p2:
Douglas Gregor64bffa92008-11-05 16:20:31 +0000324 // A non-template constructor for class X is a copy constructor
325 // if its first parameter is of type X&, const X&, volatile X& or
326 // const volatile X&, and either there are no other parameters
327 // or else all other parameters have default arguments (8.3.6).
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000328 if ((getNumParams() < 1) ||
Anders Carlssonae0b4e72009-06-06 04:14:07 +0000329 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()))
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000330 return false;
331
332 const ParmVarDecl *Param = getParamDecl(0);
333
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000334 // Do we have a reference type? Rvalue references don't count.
335 const LValueReferenceType *ParamRefType =
336 Param->getType()->getAsLValueReferenceType();
Douglas Gregor030ff0c2008-10-31 20:25:05 +0000337 if (!ParamRefType)
338 return false;
339
340 // Is it a reference to our class type?
341 QualType PointeeType
342 = Context.getCanonicalType(ParamRefType->getPointeeType());
343 QualType ClassTy
344 = Context.getTagDeclType(const_cast<CXXRecordDecl*>(getParent()));
345 if (PointeeType.getUnqualifiedType() != ClassTy)
346 return false;
347
348 // We have a copy constructor.
349 TypeQuals = PointeeType.getCVRQualifiers();
350 return true;
351}
352
Douglas Gregor60d62c22008-10-31 16:23:19 +0000353bool CXXConstructorDecl::isConvertingConstructor() const {
354 // C++ [class.conv.ctor]p1:
355 // A constructor declared without the function-specifier explicit
356 // that can be called with a single parameter specifies a
357 // conversion from the type of its first parameter to the type of
358 // its class. Such a constructor is called a converting
359 // constructor.
360 if (isExplicit())
361 return false;
362
363 return (getNumParams() == 0 &&
Douglas Gregor72564e72009-02-26 23:50:07 +0000364 getType()->getAsFunctionProtoType()->isVariadic()) ||
Douglas Gregor60d62c22008-10-31 16:23:19 +0000365 (getNumParams() == 1) ||
Anders Carlssonae0b4e72009-06-06 04:14:07 +0000366 (getNumParams() > 1 && getParamDecl(1)->hasDefaultArg());
Douglas Gregor60d62c22008-10-31 16:23:19 +0000367}
Douglas Gregorb48fe382008-10-31 09:07:45 +0000368
Douglas Gregor42a552f2008-11-05 20:51:48 +0000369CXXDestructorDecl *
370CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000371 SourceLocation L, DeclarationName N,
Douglas Gregor42a552f2008-11-05 20:51:48 +0000372 QualType T, bool isInline,
373 bool isImplicitlyDeclared) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000374 assert(N.getNameKind() == DeclarationName::CXXDestructorName &&
375 "Name must refer to a destructor");
Steve Naroff3e970492009-01-27 21:25:57 +0000376 return new (C) CXXDestructorDecl(RD, L, N, T, isInline,
377 isImplicitlyDeclared);
Douglas Gregor42a552f2008-11-05 20:51:48 +0000378}
379
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000380CXXConversionDecl *
381CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000382 SourceLocation L, DeclarationName N,
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000383 QualType T, bool isInline, bool isExplicit) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000384 assert(N.getNameKind() == DeclarationName::CXXConversionFunctionName &&
385 "Name must refer to a conversion function");
Steve Naroff3e970492009-01-27 21:25:57 +0000386 return new (C) CXXConversionDecl(RD, L, N, T, isInline, isExplicit);
Douglas Gregor2f1bc522008-11-07 20:08:42 +0000387}
388
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000389OverloadedFunctionDecl *
390OverloadedFunctionDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregor2e1cd422008-11-17 14:58:09 +0000391 DeclarationName N) {
Steve Naroff3e970492009-01-27 21:25:57 +0000392 return new (C) OverloadedFunctionDecl(DC, N);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000393}
Chris Lattner21ef7ae2008-11-04 16:51:42 +0000394
395LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
Douglas Gregor074149e2009-01-05 19:45:36 +0000396 DeclContext *DC,
Chris Lattner21ef7ae2008-11-04 16:51:42 +0000397 SourceLocation L,
Douglas Gregor074149e2009-01-05 19:45:36 +0000398 LanguageIDs Lang, bool Braces) {
Steve Naroff3e970492009-01-27 21:25:57 +0000399 return new (C) LinkageSpecDecl(DC, L, Lang, Braces);
Douglas Gregorf44515a2008-12-16 22:23:02 +0000400}
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000401
402UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
403 SourceLocation L,
404 SourceLocation NamespaceLoc,
Douglas Gregor8419fa32009-05-30 06:31:56 +0000405 SourceRange QualifierRange,
406 NestedNameSpecifier *Qualifier,
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000407 SourceLocation IdentLoc,
408 NamespaceDecl *Used,
409 DeclContext *CommonAncestor) {
Douglas Gregor8419fa32009-05-30 06:31:56 +0000410 return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierRange,
411 Qualifier, IdentLoc, Used, CommonAncestor);
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000412}
413
Anders Carlsson68771c72009-03-28 22:58:02 +0000414NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
415 SourceLocation L,
416 SourceLocation AliasLoc,
417 IdentifierInfo *Alias,
Douglas Gregor6c9c9402009-05-30 06:48:27 +0000418 SourceRange QualifierRange,
419 NestedNameSpecifier *Qualifier,
Anders Carlsson68771c72009-03-28 22:58:02 +0000420 SourceLocation IdentLoc,
421 NamedDecl *Namespace) {
Douglas Gregor6c9c9402009-05-30 06:48:27 +0000422 return new (C) NamespaceAliasDecl(DC, L, AliasLoc, Alias, QualifierRange,
423 Qualifier, IdentLoc, Namespace);
Anders Carlsson68771c72009-03-28 22:58:02 +0000424}
425
Anders Carlssonfb311762009-03-14 00:25:26 +0000426StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
427 SourceLocation L, Expr *AssertExpr,
428 StringLiteral *Message) {
429 return new (C) StaticAssertDecl(DC, L, AssertExpr, Message);
430}
431
432void StaticAssertDecl::Destroy(ASTContext& C) {
433 AssertExpr->Destroy(C);
434 Message->Destroy(C);
435 this->~StaticAssertDecl();
436 C.Deallocate((void *)this);
437}
438
439StaticAssertDecl::~StaticAssertDecl() {
440}
441
Anders Carlsson05bf2c72009-03-26 23:46:50 +0000442static const char *getAccessName(AccessSpecifier AS) {
443 switch (AS) {
444 default:
445 case AS_none:
446 assert("Invalid access specifier!");
447 return 0;
448 case AS_public:
449 return "public";
450 case AS_private:
451 return "private";
452 case AS_protected:
453 return "protected";
454 }
455}
456
457const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
458 AccessSpecifier AS) {
459 return DB << getAccessName(AS);
460}
461
462