blob: f4b8333dd3aee452a86c2b3c42ab2e7b2bff9bd7 [file] [log] [blame]
Ted Kremeneka758d092007-08-24 20:21:10 +00001//===--- ExprCXX.cpp - (C++) Expression AST Node Implementation -----------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Ted Kremeneka758d092007-08-24 20:21:10 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the subclesses of Expr class declared in ExprCXX.h
11//
12//===----------------------------------------------------------------------===//
13
Douglas Gregorb4609802008-11-14 16:09:21 +000014#include "clang/Basic/IdentifierTable.h"
15#include "clang/AST/DeclCXX.h"
Douglas Gregoredce4dd2009-06-30 22:34:41 +000016#include "clang/AST/DeclTemplate.h"
Ted Kremeneka758d092007-08-24 20:21:10 +000017#include "clang/AST/ExprCXX.h"
18using namespace clang;
19
20//===----------------------------------------------------------------------===//
21// Child Iterators for iterating over subexpressions/substatements
22//===----------------------------------------------------------------------===//
23
Sebastian Redlc42e1182008-11-11 11:37:55 +000024// CXXTypeidExpr - has child iterators if the operand is an expression
25Stmt::child_iterator CXXTypeidExpr::child_begin() {
Sebastian Redld4575892008-12-03 23:17:54 +000026 return isTypeOperand() ? child_iterator() : &Operand.Ex;
Sebastian Redlc42e1182008-11-11 11:37:55 +000027}
28Stmt::child_iterator CXXTypeidExpr::child_end() {
Sebastian Redld4575892008-12-03 23:17:54 +000029 return isTypeOperand() ? child_iterator() : &Operand.Ex+1;
Sebastian Redlc42e1182008-11-11 11:37:55 +000030}
Ted Kremeneka758d092007-08-24 20:21:10 +000031
Ted Kremeneka758d092007-08-24 20:21:10 +000032// CXXBoolLiteralExpr
Mike Stump1eb44332009-09-09 15:08:12 +000033Stmt::child_iterator CXXBoolLiteralExpr::child_begin() {
Ted Kremenek9ac59282007-10-18 23:28:49 +000034 return child_iterator();
35}
36Stmt::child_iterator CXXBoolLiteralExpr::child_end() {
37 return child_iterator();
38}
Chris Lattner50dd2892008-02-26 00:51:44 +000039
Sebastian Redl6e8ed162009-05-10 18:38:11 +000040// CXXNullPtrLiteralExpr
Mike Stump1eb44332009-09-09 15:08:12 +000041Stmt::child_iterator CXXNullPtrLiteralExpr::child_begin() {
Sebastian Redl6e8ed162009-05-10 18:38:11 +000042 return child_iterator();
43}
44Stmt::child_iterator CXXNullPtrLiteralExpr::child_end() {
45 return child_iterator();
46}
47
Douglas Gregor796da182008-11-04 14:32:21 +000048// CXXThisExpr
49Stmt::child_iterator CXXThisExpr::child_begin() { return child_iterator(); }
50Stmt::child_iterator CXXThisExpr::child_end() { return child_iterator(); }
51
Chris Lattner50dd2892008-02-26 00:51:44 +000052// CXXThrowExpr
Ted Kremenek1060aff2008-06-17 03:11:08 +000053Stmt::child_iterator CXXThrowExpr::child_begin() { return &Op; }
Chris Lattner50dd2892008-02-26 00:51:44 +000054Stmt::child_iterator CXXThrowExpr::child_end() {
55 // If Op is 0, we are processing throw; which has no children.
Ted Kremenek1060aff2008-06-17 03:11:08 +000056 return Op ? &Op+1 : &Op;
Chris Lattner50dd2892008-02-26 00:51:44 +000057}
Chris Lattner04421082008-04-08 04:40:51 +000058
59// CXXDefaultArgExpr
60Stmt::child_iterator CXXDefaultArgExpr::child_begin() {
Chris Lattner8123a952008-04-10 02:22:51 +000061 return child_iterator();
Chris Lattner04421082008-04-08 04:40:51 +000062}
63Stmt::child_iterator CXXDefaultArgExpr::child_end() {
Chris Lattner8123a952008-04-10 02:22:51 +000064 return child_iterator();
Chris Lattner04421082008-04-08 04:40:51 +000065}
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +000066
67// CXXZeroInitValueExpr
Mike Stump1eb44332009-09-09 15:08:12 +000068Stmt::child_iterator CXXZeroInitValueExpr::child_begin() {
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +000069 return child_iterator();
70}
71Stmt::child_iterator CXXZeroInitValueExpr::child_end() {
72 return child_iterator();
73}
Argyrios Kyrtzidis9e922b12008-09-09 23:47:53 +000074
Sebastian Redl4c5d3202008-11-21 19:14:01 +000075// CXXNewExpr
Ted Kremenekad7fe862010-02-11 22:51:03 +000076CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
Sebastian Redl4c5d3202008-11-21 19:14:01 +000077 Expr **placementArgs, unsigned numPlaceArgs,
Sebastian Redlcee63fb2008-12-02 14:43:59 +000078 bool parenTypeId, Expr *arraySize,
Sebastian Redl4c5d3202008-11-21 19:14:01 +000079 CXXConstructorDecl *constructor, bool initializer,
80 Expr **constructorArgs, unsigned numConsArgs,
81 FunctionDecl *operatorDelete, QualType ty,
82 SourceLocation startLoc, SourceLocation endLoc)
Sebastian Redl28507842009-02-26 14:39:58 +000083 : Expr(CXXNewExprClass, ty, ty->isDependentType(), ty->isDependentType()),
84 GlobalNew(globalNew), ParenTypeId(parenTypeId),
Sebastian Redlcee63fb2008-12-02 14:43:59 +000085 Initializer(initializer), Array(arraySize), NumPlacementArgs(numPlaceArgs),
Sebastian Redl4c5d3202008-11-21 19:14:01 +000086 NumConstructorArgs(numConsArgs), OperatorNew(operatorNew),
Sebastian Redlcee63fb2008-12-02 14:43:59 +000087 OperatorDelete(operatorDelete), Constructor(constructor),
Mike Stump1eb44332009-09-09 15:08:12 +000088 StartLoc(startLoc), EndLoc(endLoc) {
Sebastian Redlcee63fb2008-12-02 14:43:59 +000089 unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
Ted Kremenekad7fe862010-02-11 22:51:03 +000090 SubExprs = new (C) Stmt*[TotalSize];
Sebastian Redl4c5d3202008-11-21 19:14:01 +000091 unsigned i = 0;
Sebastian Redlcee63fb2008-12-02 14:43:59 +000092 if (Array)
93 SubExprs[i++] = arraySize;
94 for (unsigned j = 0; j < NumPlacementArgs; ++j)
Sebastian Redl4c5d3202008-11-21 19:14:01 +000095 SubExprs[i++] = placementArgs[j];
Sebastian Redlcee63fb2008-12-02 14:43:59 +000096 for (unsigned j = 0; j < NumConstructorArgs; ++j)
Sebastian Redl4c5d3202008-11-21 19:14:01 +000097 SubExprs[i++] = constructorArgs[j];
98 assert(i == TotalSize);
99}
100
Ted Kremenekad7fe862010-02-11 22:51:03 +0000101void CXXNewExpr::DoDestroy(ASTContext &C) {
102 DestroyChildren(C);
103 if (SubExprs)
104 C.Deallocate(SubExprs);
105 this->~CXXNewExpr();
106 C.Deallocate((void*)this);
107}
108
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000109Stmt::child_iterator CXXNewExpr::child_begin() { return &SubExprs[0]; }
110Stmt::child_iterator CXXNewExpr::child_end() {
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000111 return &SubExprs[0] + Array + getNumPlacementArgs() + getNumConstructorArgs();
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000112}
113
114// CXXDeleteExpr
115Stmt::child_iterator CXXDeleteExpr::child_begin() { return &Argument; }
116Stmt::child_iterator CXXDeleteExpr::child_end() { return &Argument+1; }
117
Douglas Gregora71d8192009-09-04 17:36:40 +0000118// CXXPseudoDestructorExpr
119Stmt::child_iterator CXXPseudoDestructorExpr::child_begin() { return &Base; }
120Stmt::child_iterator CXXPseudoDestructorExpr::child_end() {
121 return &Base + 1;
122}
123
John McCallba135432009-11-21 08:51:07 +0000124// UnresolvedLookupExpr
John McCallf7a1a742009-11-24 19:00:30 +0000125UnresolvedLookupExpr *
126UnresolvedLookupExpr::Create(ASTContext &C, bool Dependent,
John McCallc373d482010-01-27 01:50:18 +0000127 CXXRecordDecl *NamingClass,
John McCallf7a1a742009-11-24 19:00:30 +0000128 NestedNameSpecifier *Qualifier,
129 SourceRange QualifierRange, DeclarationName Name,
130 SourceLocation NameLoc, bool ADL,
131 const TemplateArgumentListInfo &Args)
132{
133 void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
134 ExplicitTemplateArgumentList::sizeFor(Args));
135 UnresolvedLookupExpr *ULE
136 = new (Mem) UnresolvedLookupExpr(Dependent ? C.DependentTy : C.OverloadTy,
John McCallc373d482010-01-27 01:50:18 +0000137 Dependent, NamingClass,
138 Qualifier, QualifierRange,
John McCallf7a1a742009-11-24 19:00:30 +0000139 Name, NameLoc, ADL,
140 /*Overload*/ true,
141 /*ExplicitTemplateArgs*/ true);
142
143 reinterpret_cast<ExplicitTemplateArgumentList*>(ULE+1)->initializeFrom(Args);
144
145 return ULE;
146}
147
John McCall7bb12da2010-02-02 06:20:04 +0000148bool OverloadExpr::ComputeDependence(UnresolvedSetIterator Begin,
149 UnresolvedSetIterator End,
150 const TemplateArgumentListInfo *Args) {
John McCalleec51cf2010-01-20 00:46:10 +0000151 for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I)
John McCallf7a1a742009-11-24 19:00:30 +0000152 if ((*I)->getDeclContext()->isDependentContext())
153 return true;
154
155 if (Args && TemplateSpecializationType::anyDependentTemplateArguments(*Args))
156 return true;
157
158 return false;
159}
160
John McCallba135432009-11-21 08:51:07 +0000161Stmt::child_iterator UnresolvedLookupExpr::child_begin() {
Mike Stump1eb44332009-09-09 15:08:12 +0000162 return child_iterator();
Douglas Gregor5c37de72008-12-06 00:22:45 +0000163}
John McCallba135432009-11-21 08:51:07 +0000164Stmt::child_iterator UnresolvedLookupExpr::child_end() {
Douglas Gregor5c37de72008-12-06 00:22:45 +0000165 return child_iterator();
166}
Sebastian Redl64b45f72009-01-05 20:52:13 +0000167// UnaryTypeTraitExpr
168Stmt::child_iterator UnaryTypeTraitExpr::child_begin() {
169 return child_iterator();
170}
171Stmt::child_iterator UnaryTypeTraitExpr::child_end() {
172 return child_iterator();
173}
174
John McCall865d4472009-11-19 22:55:06 +0000175// DependentScopeDeclRefExpr
John McCallf7a1a742009-11-24 19:00:30 +0000176DependentScopeDeclRefExpr *
177DependentScopeDeclRefExpr::Create(ASTContext &C,
178 NestedNameSpecifier *Qualifier,
179 SourceRange QualifierRange,
180 DeclarationName Name,
181 SourceLocation NameLoc,
182 const TemplateArgumentListInfo *Args) {
183 std::size_t size = sizeof(DependentScopeDeclRefExpr);
184 if (Args) size += ExplicitTemplateArgumentList::sizeFor(*Args);
185 void *Mem = C.Allocate(size);
186
187 DependentScopeDeclRefExpr *DRE
188 = new (Mem) DependentScopeDeclRefExpr(C.DependentTy,
189 Qualifier, QualifierRange,
190 Name, NameLoc,
191 Args != 0);
192
193 if (Args)
194 reinterpret_cast<ExplicitTemplateArgumentList*>(DRE+1)
195 ->initializeFrom(*Args);
196
197 return DRE;
198}
199
John McCall865d4472009-11-19 22:55:06 +0000200StmtIterator DependentScopeDeclRefExpr::child_begin() {
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000201 return child_iterator();
202}
203
John McCall865d4472009-11-19 22:55:06 +0000204StmtIterator DependentScopeDeclRefExpr::child_end() {
Douglas Gregor5953d8b2009-03-19 17:26:29 +0000205 return child_iterator();
206}
207
Douglas Gregor5e03f9e2009-07-23 23:49:00 +0000208bool UnaryTypeTraitExpr::EvaluateTrait(ASTContext& C) const {
Sebastian Redl64b45f72009-01-05 20:52:13 +0000209 switch(UTT) {
210 default: assert(false && "Unknown type trait or not implemented");
211 case UTT_IsPOD: return QueriedType->isPODType();
Sebastian Redlccf43502009-12-03 00:13:20 +0000212 case UTT_IsLiteral: return QueriedType->isLiteralType();
Sebastian Redl64b45f72009-01-05 20:52:13 +0000213 case UTT_IsClass: // Fallthrough
214 case UTT_IsUnion:
Ted Kremenek6217b802009-07-29 21:53:49 +0000215 if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +0000216 bool Union = Record->getDecl()->isUnion();
217 return UTT == UTT_IsUnion ? Union : !Union;
218 }
219 return false;
220 case UTT_IsEnum: return QueriedType->isEnumeralType();
221 case UTT_IsPolymorphic:
Ted Kremenek6217b802009-07-29 21:53:49 +0000222 if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
Sebastian Redl64b45f72009-01-05 20:52:13 +0000223 // Type traits are only parsed in C++, so we've got CXXRecords.
224 return cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic();
225 }
226 return false;
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000227 case UTT_IsAbstract:
Ted Kremenek6217b802009-07-29 21:53:49 +0000228 if (const RecordType *RT = QueriedType->getAs<RecordType>())
Anders Carlsson67e4dd22009-03-22 01:52:17 +0000229 return cast<CXXRecordDecl>(RT->getDecl())->isAbstract();
230 return false;
Eli Friedman1d954f62009-08-15 21:55:26 +0000231 case UTT_IsEmpty:
232 if (const RecordType *Record = QueriedType->getAs<RecordType>()) {
233 return !Record->getDecl()->isUnion()
234 && cast<CXXRecordDecl>(Record->getDecl())->isEmpty();
235 }
236 return false;
Anders Carlsson347ba892009-04-16 00:08:20 +0000237 case UTT_HasTrivialConstructor:
Douglas Gregor5e03f9e2009-07-23 23:49:00 +0000238 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
239 // If __is_pod (type) is true then the trait is true, else if type is
240 // a cv class or union type (or array thereof) with a trivial default
241 // constructor ([class.ctor]) then the trait is true, else it is false.
242 if (QueriedType->isPODType())
243 return true;
244 if (const RecordType *RT =
Ted Kremenek6217b802009-07-29 21:53:49 +0000245 C.getBaseElementType(QueriedType)->getAs<RecordType>())
Anders Carlsson347ba892009-04-16 00:08:20 +0000246 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialConstructor();
Anders Carlsson072abef2009-04-17 02:34:54 +0000247 return false;
Douglas Gregor5e03f9e2009-07-23 23:49:00 +0000248 case UTT_HasTrivialCopy:
249 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
250 // If __is_pod (type) is true or type is a reference type then
251 // the trait is true, else if type is a cv class or union type
252 // with a trivial copy constructor ([class.copy]) then the trait
253 // is true, else it is false.
254 if (QueriedType->isPODType() || QueriedType->isReferenceType())
255 return true;
Ted Kremenek6217b802009-07-29 21:53:49 +0000256 if (const RecordType *RT = QueriedType->getAs<RecordType>())
Douglas Gregor5e03f9e2009-07-23 23:49:00 +0000257 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyConstructor();
258 return false;
259 case UTT_HasTrivialAssign:
260 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
261 // If type is const qualified or is a reference type then the
262 // trait is false. Otherwise if __is_pod (type) is true then the
263 // trait is true, else if type is a cv class or union type with
264 // a trivial copy assignment ([class.copy]) then the trait is
265 // true, else it is false.
266 // Note: the const and reference restrictions are interesting,
267 // given that const and reference members don't prevent a class
268 // from having a trivial copy assignment operator (but do cause
269 // errors if the copy assignment operator is actually used, q.v.
270 // [class.copy]p12).
271
272 if (C.getBaseElementType(QueriedType).isConstQualified())
273 return false;
274 if (QueriedType->isPODType())
275 return true;
Ted Kremenek6217b802009-07-29 21:53:49 +0000276 if (const RecordType *RT = QueriedType->getAs<RecordType>())
Douglas Gregor5e03f9e2009-07-23 23:49:00 +0000277 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialCopyAssignment();
278 return false;
279 case UTT_HasTrivialDestructor:
280 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html:
281 // If __is_pod (type) is true or type is a reference type
282 // then the trait is true, else if type is a cv class or union
283 // type (or array thereof) with a trivial destructor
284 // ([class.dtor]) then the trait is true, else it is
285 // false.
286 if (QueriedType->isPODType() || QueriedType->isReferenceType())
287 return true;
288 if (const RecordType *RT =
Ted Kremenek6217b802009-07-29 21:53:49 +0000289 C.getBaseElementType(QueriedType)->getAs<RecordType>())
Anders Carlsson072abef2009-04-17 02:34:54 +0000290 return cast<CXXRecordDecl>(RT->getDecl())->hasTrivialDestructor();
291 return false;
Sebastian Redl64b45f72009-01-05 20:52:13 +0000292 }
293}
294
Ted Kremeneke3837682009-12-23 04:00:48 +0000295SourceRange CXXConstructExpr::getSourceRange() const {
296 // FIXME: Should we know where the parentheses are, if there are any?
297 for (std::reverse_iterator<Stmt**> I(&Args[NumArgs]), E(&Args[0]); I!=E;++I) {
298 // Ignore CXXDefaultExprs when computing the range, as they don't
299 // have a range.
300 if (!isa<CXXDefaultArgExpr>(*I))
301 return SourceRange(Loc, (*I)->getLocEnd());
302 }
303
304 return SourceRange(Loc);
305}
306
Douglas Gregorb4609802008-11-14 16:09:21 +0000307SourceRange CXXOperatorCallExpr::getSourceRange() const {
308 OverloadedOperatorKind Kind = getOperator();
309 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
310 if (getNumArgs() == 1)
311 // Prefix operator
Mike Stump1eb44332009-09-09 15:08:12 +0000312 return SourceRange(getOperatorLoc(),
Douglas Gregorb4609802008-11-14 16:09:21 +0000313 getArg(0)->getSourceRange().getEnd());
314 else
315 // Postfix operator
316 return SourceRange(getArg(0)->getSourceRange().getEnd(),
317 getOperatorLoc());
318 } else if (Kind == OO_Call) {
319 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
320 } else if (Kind == OO_Subscript) {
321 return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
322 } else if (getNumArgs() == 1) {
323 return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
324 } else if (getNumArgs() == 2) {
325 return SourceRange(getArg(0)->getSourceRange().getBegin(),
326 getArg(1)->getSourceRange().getEnd());
327 } else {
328 return SourceRange();
329 }
330}
331
Douglas Gregor88a35142008-12-22 05:46:06 +0000332Expr *CXXMemberCallExpr::getImplicitObjectArgument() {
333 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
334 return MemExpr->getBase();
335
336 // FIXME: Will eventually need to cope with member pointers.
337 return 0;
338}
339
Douglas Gregor00b98c22009-11-12 15:31:47 +0000340SourceRange CXXMemberCallExpr::getSourceRange() const {
341 SourceLocation LocStart = getCallee()->getLocStart();
342 if (LocStart.isInvalid() && getNumArgs() > 0)
343 LocStart = getArg(0)->getLocStart();
344 return SourceRange(LocStart, getRParenLoc());
345}
346
347
Douglas Gregor49badde2008-10-27 19:41:14 +0000348//===----------------------------------------------------------------------===//
349// Named casts
350//===----------------------------------------------------------------------===//
351
352/// getCastName - Get the name of the C++ cast being used, e.g.,
353/// "static_cast", "dynamic_cast", "reinterpret_cast", or
354/// "const_cast". The returned pointer must not be freed.
355const char *CXXNamedCastExpr::getCastName() const {
356 switch (getStmtClass()) {
357 case CXXStaticCastExprClass: return "static_cast";
358 case CXXDynamicCastExprClass: return "dynamic_cast";
359 case CXXReinterpretCastExprClass: return "reinterpret_cast";
360 case CXXConstCastExprClass: return "const_cast";
361 default: return "<invalid cast>";
362 }
363}
Douglas Gregor506ae412009-01-16 18:33:17 +0000364
Douglas Gregor65222e82009-12-23 18:19:08 +0000365CXXDefaultArgExpr *
Douglas Gregor036aed12009-12-23 23:03:06 +0000366CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
367 ParmVarDecl *Param, Expr *SubExpr) {
Douglas Gregor65222e82009-12-23 18:19:08 +0000368 void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
Douglas Gregor036aed12009-12-23 23:03:06 +0000369 return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
370 SubExpr);
Douglas Gregor65222e82009-12-23 18:19:08 +0000371}
372
373void CXXDefaultArgExpr::DoDestroy(ASTContext &C) {
374 if (Param.getInt())
375 getExpr()->Destroy(C);
376 this->~CXXDefaultArgExpr();
377 C.Deallocate(this);
378}
379
Mike Stump1eb44332009-09-09 15:08:12 +0000380CXXTemporary *CXXTemporary::Create(ASTContext &C,
Anders Carlssonb859f352009-05-30 20:34:37 +0000381 const CXXDestructorDecl *Destructor) {
Anders Carlsson88eaf072009-05-30 22:38:53 +0000382 return new (C) CXXTemporary(Destructor);
383}
384
Douglas Gregor42602bb2009-08-07 06:08:38 +0000385void CXXTemporary::Destroy(ASTContext &Ctx) {
Anders Carlsson88eaf072009-05-30 22:38:53 +0000386 this->~CXXTemporary();
Douglas Gregor42602bb2009-08-07 06:08:38 +0000387 Ctx.Deallocate(this);
Anders Carlssonc1ce4772009-05-30 19:54:15 +0000388}
389
Mike Stump1eb44332009-09-09 15:08:12 +0000390CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
Anders Carlssonfceb0a82009-05-30 20:03:25 +0000391 CXXTemporary *Temp,
392 Expr* SubExpr) {
Mike Stump1eb44332009-09-09 15:08:12 +0000393 assert(SubExpr->getType()->isRecordType() &&
Anders Carlssonfceb0a82009-05-30 20:03:25 +0000394 "Expression bound to a temporary must have record type!");
395
Anders Carlssonb859f352009-05-30 20:34:37 +0000396 return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
Anders Carlssonfceb0a82009-05-30 20:03:25 +0000397}
398
Douglas Gregor42602bb2009-08-07 06:08:38 +0000399void CXXBindTemporaryExpr::DoDestroy(ASTContext &C) {
Anders Carlsson88eaf072009-05-30 22:38:53 +0000400 Temp->Destroy(C);
401 this->~CXXBindTemporaryExpr();
402 C.Deallocate(this);
403}
404
Anders Carlssoneb60edf2010-01-29 02:39:32 +0000405CXXBindReferenceExpr *CXXBindReferenceExpr::Create(ASTContext &C, Expr *SubExpr,
406 bool ExtendsLifetime,
407 bool RequiresTemporaryCopy) {
408 return new (C) CXXBindReferenceExpr(SubExpr,
409 ExtendsLifetime,
410 RequiresTemporaryCopy);
411}
412
413void CXXBindReferenceExpr::DoDestroy(ASTContext &C) {
414 this->~CXXBindReferenceExpr();
415 C.Deallocate(this);
416}
417
Anders Carlsson8e587a12009-05-30 20:56:46 +0000418CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
Anders Carlsson26de5492009-04-24 05:23:13 +0000419 CXXConstructorDecl *Cons,
Douglas Gregor506ae412009-01-16 18:33:17 +0000420 QualType writtenTy,
Mike Stump1eb44332009-09-09 15:08:12 +0000421 SourceLocation tyBeginLoc,
Douglas Gregor506ae412009-01-16 18:33:17 +0000422 Expr **Args,
Mike Stump1eb44332009-09-09 15:08:12 +0000423 unsigned NumArgs,
Douglas Gregor506ae412009-01-16 18:33:17 +0000424 SourceLocation rParenLoc)
Douglas Gregor99a2e602009-12-16 01:38:02 +0000425 : CXXConstructExpr(C, CXXTemporaryObjectExprClass, writtenTy, tyBeginLoc,
426 Cons, false, Args, NumArgs),
Anders Carlsson524fa132009-04-24 17:34:38 +0000427 TyBeginLoc(tyBeginLoc), RParenLoc(rParenLoc) {
Douglas Gregor506ae412009-01-16 18:33:17 +0000428}
Anders Carlsson19d28a62009-04-21 02:22:11 +0000429
Mike Stump1eb44332009-09-09 15:08:12 +0000430CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
Douglas Gregor99a2e602009-12-16 01:38:02 +0000431 SourceLocation Loc,
Anders Carlsson8e587a12009-05-30 20:56:46 +0000432 CXXConstructorDecl *D, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +0000433 Expr **Args, unsigned NumArgs,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000434 bool ZeroInitialization,
435 bool BaseInitialization) {
Douglas Gregor99a2e602009-12-16 01:38:02 +0000436 return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000437 Elidable, Args, NumArgs, ZeroInitialization,
438 BaseInitialization);
Anders Carlssone349bea2009-04-23 02:32:43 +0000439}
440
Mike Stump1eb44332009-09-09 15:08:12 +0000441CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
Douglas Gregor99a2e602009-12-16 01:38:02 +0000442 SourceLocation Loc,
Anders Carlsson8e587a12009-05-30 20:56:46 +0000443 CXXConstructorDecl *D, bool elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +0000444 Expr **args, unsigned numargs,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000445 bool ZeroInitialization,
446 bool BaseInitialization)
Anders Carlssonbd6734e2009-04-24 05:04:04 +0000447: Expr(SC, T,
Anders Carlssone349bea2009-04-23 02:32:43 +0000448 T->isDependentType(),
449 (T->isDependentType() ||
450 CallExpr::hasAnyValueDependentArguments(args, numargs))),
Douglas Gregor16006c92009-12-16 18:50:27 +0000451 Constructor(D), Loc(Loc), Elidable(elidable),
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000452 ZeroInitialization(ZeroInitialization),
453 BaseInitialization(BaseInitialization), Args(0), NumArgs(numargs)
Douglas Gregor16006c92009-12-16 18:50:27 +0000454{
455 if (NumArgs) {
456 Args = new (C) Stmt*[NumArgs];
457
458 for (unsigned i = 0; i != NumArgs; ++i) {
459 assert(args[i] && "NULL argument in CXXConstructExpr");
460 Args[i] = args[i];
Anders Carlssone349bea2009-04-23 02:32:43 +0000461 }
Douglas Gregor16006c92009-12-16 18:50:27 +0000462 }
Anders Carlssone349bea2009-04-23 02:32:43 +0000463}
464
Douglas Gregor39da0b82009-09-09 23:08:42 +0000465CXXConstructExpr::CXXConstructExpr(EmptyShell Empty, ASTContext &C,
466 unsigned numargs)
467 : Expr(CXXConstructExprClass, Empty), Args(0), NumArgs(numargs)
468{
469 if (NumArgs)
470 Args = new (C) Stmt*[NumArgs];
471}
472
Douglas Gregor42602bb2009-08-07 06:08:38 +0000473void CXXConstructExpr::DoDestroy(ASTContext &C) {
Anders Carlssone349bea2009-04-23 02:32:43 +0000474 DestroyChildren(C);
475 if (Args)
476 C.Deallocate(Args);
477 this->~CXXConstructExpr();
478 C.Deallocate(this);
479}
480
Mike Stump1eb44332009-09-09 15:08:12 +0000481CXXExprWithTemporaries::CXXExprWithTemporaries(Expr *subexpr,
482 CXXTemporary **temps,
Anders Carlsson0ece4912009-12-15 20:51:39 +0000483 unsigned numtemps)
Anders Carlsson2d44e8a2009-05-01 22:18:43 +0000484: Expr(CXXExprWithTemporariesClass, subexpr->getType(),
Mike Stump1eb44332009-09-09 15:08:12 +0000485 subexpr->isTypeDependent(), subexpr->isValueDependent()),
Anders Carlsson0ece4912009-12-15 20:51:39 +0000486 SubExpr(subexpr), Temps(0), NumTemps(numtemps) {
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000487 if (NumTemps > 0) {
488 Temps = new CXXTemporary*[NumTemps];
489 for (unsigned i = 0; i < NumTemps; ++i)
490 Temps[i] = temps[i];
Anders Carlsson02bbfa32009-04-24 22:47:04 +0000491 }
492}
493
Mike Stump1eb44332009-09-09 15:08:12 +0000494CXXExprWithTemporaries *CXXExprWithTemporaries::Create(ASTContext &C,
Anders Carlsson88eaf072009-05-30 22:38:53 +0000495 Expr *SubExpr,
Mike Stump1eb44332009-09-09 15:08:12 +0000496 CXXTemporary **Temps,
Anders Carlsson0ece4912009-12-15 20:51:39 +0000497 unsigned NumTemps) {
498 return new (C) CXXExprWithTemporaries(SubExpr, Temps, NumTemps);
Anders Carlsson88eaf072009-05-30 22:38:53 +0000499}
500
Douglas Gregor42602bb2009-08-07 06:08:38 +0000501void CXXExprWithTemporaries::DoDestroy(ASTContext &C) {
Anders Carlsson88eaf072009-05-30 22:38:53 +0000502 DestroyChildren(C);
503 this->~CXXExprWithTemporaries();
504 C.Deallocate(this);
505}
506
Anders Carlsson2d44e8a2009-05-01 22:18:43 +0000507CXXExprWithTemporaries::~CXXExprWithTemporaries() {
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000508 delete[] Temps;
Anders Carlsson02bbfa32009-04-24 22:47:04 +0000509}
510
Anders Carlssonfceb0a82009-05-30 20:03:25 +0000511// CXXBindTemporaryExpr
512Stmt::child_iterator CXXBindTemporaryExpr::child_begin() {
513 return &SubExpr;
514}
515
Mike Stump1eb44332009-09-09 15:08:12 +0000516Stmt::child_iterator CXXBindTemporaryExpr::child_end() {
Anders Carlssonfceb0a82009-05-30 20:03:25 +0000517 return &SubExpr + 1;
518}
519
Anders Carlssoneb60edf2010-01-29 02:39:32 +0000520// CXXBindReferenceExpr
521Stmt::child_iterator CXXBindReferenceExpr::child_begin() {
522 return &SubExpr;
523}
524
525Stmt::child_iterator CXXBindReferenceExpr::child_end() {
526 return &SubExpr + 1;
527}
528
Anders Carlssone349bea2009-04-23 02:32:43 +0000529// CXXConstructExpr
530Stmt::child_iterator CXXConstructExpr::child_begin() {
531 return &Args[0];
532}
533Stmt::child_iterator CXXConstructExpr::child_end() {
534 return &Args[0]+NumArgs;
535}
536
Anders Carlsson55674ac2009-05-01 22:21:22 +0000537// CXXExprWithTemporaries
538Stmt::child_iterator CXXExprWithTemporaries::child_begin() {
539 return &SubExpr;
Anders Carlsson19d28a62009-04-21 02:22:11 +0000540}
Anders Carlsson02bbfa32009-04-24 22:47:04 +0000541
Mike Stump1eb44332009-09-09 15:08:12 +0000542Stmt::child_iterator CXXExprWithTemporaries::child_end() {
Anders Carlsson55674ac2009-05-01 22:21:22 +0000543 return &SubExpr + 1;
544}
Anders Carlsson02bbfa32009-04-24 22:47:04 +0000545
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000546CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
547 SourceLocation TyBeginLoc,
548 QualType T,
549 SourceLocation LParenLoc,
550 Expr **Args,
551 unsigned NumArgs,
552 SourceLocation RParenLoc)
553 : Expr(CXXUnresolvedConstructExprClass, T.getNonReferenceType(),
554 T->isDependentType(), true),
555 TyBeginLoc(TyBeginLoc),
556 Type(T),
557 LParenLoc(LParenLoc),
558 RParenLoc(RParenLoc),
559 NumArgs(NumArgs) {
560 Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
561 memcpy(StoredArgs, Args, sizeof(Expr *) * NumArgs);
562}
563
564CXXUnresolvedConstructExpr *
Mike Stump1eb44332009-09-09 15:08:12 +0000565CXXUnresolvedConstructExpr::Create(ASTContext &C,
Douglas Gregord81e6ca2009-05-20 18:46:25 +0000566 SourceLocation TyBegin,
567 QualType T,
568 SourceLocation LParenLoc,
569 Expr **Args,
570 unsigned NumArgs,
571 SourceLocation RParenLoc) {
572 void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
573 sizeof(Expr *) * NumArgs);
574 return new (Mem) CXXUnresolvedConstructExpr(TyBegin, T, LParenLoc,
575 Args, NumArgs, RParenLoc);
576}
577
578Stmt::child_iterator CXXUnresolvedConstructExpr::child_begin() {
579 return child_iterator(reinterpret_cast<Stmt **>(this + 1));
580}
581
582Stmt::child_iterator CXXUnresolvedConstructExpr::child_end() {
583 return child_iterator(reinterpret_cast<Stmt **>(this + 1) + NumArgs);
584}
Sebastian Redl8b0b4752009-05-16 18:50:46 +0000585
John McCall865d4472009-11-19 22:55:06 +0000586CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
John McCallaa81e162009-12-01 22:10:20 +0000587 Expr *Base, QualType BaseType,
588 bool IsArrow,
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000589 SourceLocation OperatorLoc,
590 NestedNameSpecifier *Qualifier,
591 SourceRange QualifierRange,
592 NamedDecl *FirstQualifierFoundInScope,
593 DeclarationName Member,
594 SourceLocation MemberLoc,
John McCalld5532b62009-11-23 01:53:49 +0000595 const TemplateArgumentListInfo *TemplateArgs)
John McCall865d4472009-11-19 22:55:06 +0000596 : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, true, true),
John McCallaa81e162009-12-01 22:10:20 +0000597 Base(Base), BaseType(BaseType), IsArrow(IsArrow),
598 HasExplicitTemplateArgs(TemplateArgs != 0),
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000599 OperatorLoc(OperatorLoc),
600 Qualifier(Qualifier), QualifierRange(QualifierRange),
601 FirstQualifierFoundInScope(FirstQualifierFoundInScope),
Mike Stump1eb44332009-09-09 15:08:12 +0000602 Member(Member), MemberLoc(MemberLoc) {
John McCalld5532b62009-11-23 01:53:49 +0000603 if (TemplateArgs)
604 getExplicitTemplateArgumentList()->initializeFrom(*TemplateArgs);
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000605}
606
John McCall865d4472009-11-19 22:55:06 +0000607CXXDependentScopeMemberExpr *
608CXXDependentScopeMemberExpr::Create(ASTContext &C,
John McCallaa81e162009-12-01 22:10:20 +0000609 Expr *Base, QualType BaseType, bool IsArrow,
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000610 SourceLocation OperatorLoc,
611 NestedNameSpecifier *Qualifier,
612 SourceRange QualifierRange,
613 NamedDecl *FirstQualifierFoundInScope,
614 DeclarationName Member,
615 SourceLocation MemberLoc,
John McCalld5532b62009-11-23 01:53:49 +0000616 const TemplateArgumentListInfo *TemplateArgs) {
617 if (!TemplateArgs)
John McCallaa81e162009-12-01 22:10:20 +0000618 return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
619 IsArrow, OperatorLoc,
620 Qualifier, QualifierRange,
621 FirstQualifierFoundInScope,
622 Member, MemberLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000623
John McCalld5532b62009-11-23 01:53:49 +0000624 std::size_t size = sizeof(CXXDependentScopeMemberExpr);
625 if (TemplateArgs)
626 size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
627
628 void *Mem = C.Allocate(size, llvm::alignof<CXXDependentScopeMemberExpr>());
John McCallaa81e162009-12-01 22:10:20 +0000629 return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
630 IsArrow, OperatorLoc,
631 Qualifier, QualifierRange,
632 FirstQualifierFoundInScope,
633 Member, MemberLoc, TemplateArgs);
Douglas Gregor3b6afbb2009-09-09 00:23:06 +0000634}
635
John McCall865d4472009-11-19 22:55:06 +0000636Stmt::child_iterator CXXDependentScopeMemberExpr::child_begin() {
Douglas Gregor1c0ca592009-05-22 21:13:27 +0000637 return child_iterator(&Base);
638}
639
John McCall865d4472009-11-19 22:55:06 +0000640Stmt::child_iterator CXXDependentScopeMemberExpr::child_end() {
John McCallaa81e162009-12-01 22:10:20 +0000641 if (isImplicitAccess())
642 return child_iterator(&Base);
Douglas Gregor1c0ca592009-05-22 21:13:27 +0000643 return child_iterator(&Base + 1);
644}
John McCall129e2df2009-11-30 22:42:35 +0000645
646UnresolvedMemberExpr::UnresolvedMemberExpr(QualType T, bool Dependent,
647 bool HasUnresolvedUsing,
John McCallaa81e162009-12-01 22:10:20 +0000648 Expr *Base, QualType BaseType,
649 bool IsArrow,
John McCall129e2df2009-11-30 22:42:35 +0000650 SourceLocation OperatorLoc,
651 NestedNameSpecifier *Qualifier,
652 SourceRange QualifierRange,
653 DeclarationName MemberName,
654 SourceLocation MemberLoc,
655 const TemplateArgumentListInfo *TemplateArgs)
John McCall7bb12da2010-02-02 06:20:04 +0000656 : OverloadExpr(UnresolvedMemberExprClass, T, Dependent,
657 Qualifier, QualifierRange, MemberName, MemberLoc,
658 TemplateArgs != 0),
659 IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
660 Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
John McCall129e2df2009-11-30 22:42:35 +0000661 if (TemplateArgs)
John McCall7bb12da2010-02-02 06:20:04 +0000662 getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
John McCall129e2df2009-11-30 22:42:35 +0000663}
664
665UnresolvedMemberExpr *
666UnresolvedMemberExpr::Create(ASTContext &C, bool Dependent,
667 bool HasUnresolvedUsing,
John McCallaa81e162009-12-01 22:10:20 +0000668 Expr *Base, QualType BaseType, bool IsArrow,
John McCall129e2df2009-11-30 22:42:35 +0000669 SourceLocation OperatorLoc,
670 NestedNameSpecifier *Qualifier,
671 SourceRange QualifierRange,
672 DeclarationName Member,
673 SourceLocation MemberLoc,
674 const TemplateArgumentListInfo *TemplateArgs) {
675 std::size_t size = sizeof(UnresolvedMemberExpr);
676 if (TemplateArgs)
677 size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
678
679 void *Mem = C.Allocate(size, llvm::alignof<UnresolvedMemberExpr>());
680 return new (Mem) UnresolvedMemberExpr(
681 Dependent ? C.DependentTy : C.OverloadTy,
John McCallaa81e162009-12-01 22:10:20 +0000682 Dependent, HasUnresolvedUsing, Base, BaseType,
683 IsArrow, OperatorLoc, Qualifier, QualifierRange,
John McCall129e2df2009-11-30 22:42:35 +0000684 Member, MemberLoc, TemplateArgs);
685}
686
John McCallc373d482010-01-27 01:50:18 +0000687CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
688 // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
689
690 // If there was a nested name specifier, it names the naming class.
691 // It can't be dependent: after all, we were actually able to do the
692 // lookup.
693 const RecordType *RT;
John McCall7bb12da2010-02-02 06:20:04 +0000694 if (getQualifier()) {
695 Type *T = getQualifier()->getAsType();
John McCallc373d482010-01-27 01:50:18 +0000696 assert(T && "qualifier in member expression does not name type");
697 RT = T->getAs<RecordType>();
698 assert(RT && "qualifier in member expression does not name record");
699
700 // Otherwise the naming class must have been the base class.
701 } else {
702 QualType BaseType = getBaseType().getNonReferenceType();
703 if (isArrow()) {
704 const PointerType *PT = BaseType->getAs<PointerType>();
705 assert(PT && "base of arrow member access is not pointer");
706 BaseType = PT->getPointeeType();
707 }
708
709 RT = BaseType->getAs<RecordType>();
710 assert(RT && "base of member expression does not name record");
711 }
712
713 return cast<CXXRecordDecl>(RT->getDecl());
714}
715
John McCall129e2df2009-11-30 22:42:35 +0000716Stmt::child_iterator UnresolvedMemberExpr::child_begin() {
717 return child_iterator(&Base);
718}
719
720Stmt::child_iterator UnresolvedMemberExpr::child_end() {
John McCallaa81e162009-12-01 22:10:20 +0000721 if (isImplicitAccess())
722 return child_iterator(&Base);
John McCall129e2df2009-11-30 22:42:35 +0000723 return child_iterator(&Base + 1);
724}