ExprCXX.cpp revision 007a9b1c632bfaac20e41c60cbe07fdc6d0e647c 
1//===--- ExprCXX.cpp - (C++) Expression 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 subclesses of Expr class declared in ExprCXX.h
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Basic/IdentifierTable.h"
15#include "clang/AST/DeclCXX.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/ExprCXX.h"
18#include "clang/AST/TypeLoc.h"
19using namespace clang;
20
21
22//===----------------------------------------------------------------------===//
23//  Child Iterators for iterating over subexpressions/substatements
24//===----------------------------------------------------------------------===//
25
26QualType CXXTypeidExpr::getTypeOperand() const {
27  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
28  return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
29                                                        .getUnqualifiedType();
30}
31
32// CXXTypeidExpr - has child iterators if the operand is an expression
33Stmt::child_iterator CXXTypeidExpr::child_begin() {
34  return isTypeOperand() ? child_iterator()
35                         : reinterpret_cast<Stmt **>(&Operand);
36}
37Stmt::child_iterator CXXTypeidExpr::child_end() {
38  return isTypeOperand() ? child_iterator()
39                         : reinterpret_cast<Stmt **>(&Operand) + 1;
40}
41
42QualType CXXUuidofExpr::getTypeOperand() const {
43  assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)");
44  return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
45                                                        .getUnqualifiedType();
46}
47
48// CXXUuidofExpr - has child iterators if the operand is an expression
49Stmt::child_iterator CXXUuidofExpr::child_begin() {
50  return isTypeOperand() ? child_iterator()
51                         : reinterpret_cast<Stmt **>(&Operand);
52}
53Stmt::child_iterator CXXUuidofExpr::child_end() {
54  return isTypeOperand() ? child_iterator()
55                         : reinterpret_cast<Stmt **>(&Operand) + 1;
56}
57
58// CXXBoolLiteralExpr
59Stmt::child_iterator CXXBoolLiteralExpr::child_begin() {
60  return child_iterator();
61}
62Stmt::child_iterator CXXBoolLiteralExpr::child_end() {
63  return child_iterator();
64}
65
66// CXXNullPtrLiteralExpr
67Stmt::child_iterator CXXNullPtrLiteralExpr::child_begin() {
68  return child_iterator();
69}
70Stmt::child_iterator CXXNullPtrLiteralExpr::child_end() {
71  return child_iterator();
72}
73
74// CXXThisExpr
75Stmt::child_iterator CXXThisExpr::child_begin() { return child_iterator(); }
76Stmt::child_iterator CXXThisExpr::child_end() { return child_iterator(); }
77
78// CXXThrowExpr
79Stmt::child_iterator CXXThrowExpr::child_begin() { return &Op; }
80Stmt::child_iterator CXXThrowExpr::child_end() {
81  // If Op is 0, we are processing throw; which has no children.
82  return Op ? &Op+1 : &Op;
83}
84
85// CXXDefaultArgExpr
86Stmt::child_iterator CXXDefaultArgExpr::child_begin() {
87  return child_iterator();
88}
89Stmt::child_iterator CXXDefaultArgExpr::child_end() {
90  return child_iterator();
91}
92
93// CXXScalarValueInitExpr
94SourceRange CXXScalarValueInitExpr::getSourceRange() const {
95  SourceLocation Start = RParenLoc;
96  if (TypeInfo)
97    Start = TypeInfo->getTypeLoc().getBeginLoc();
98  return SourceRange(Start, RParenLoc);
99}
100
101Stmt::child_iterator CXXScalarValueInitExpr::child_begin() {
102  return child_iterator();
103}
104Stmt::child_iterator CXXScalarValueInitExpr::child_end() {
105  return child_iterator();
106}
107
108// CXXNewExpr
109CXXNewExpr::CXXNewExpr(ASTContext &C, bool globalNew, FunctionDecl *operatorNew,
110                       Expr **placementArgs, unsigned numPlaceArgs,
111                       SourceRange TypeIdParens, Expr *arraySize,
112                       CXXConstructorDecl *constructor, bool initializer,
113                       Expr **constructorArgs, unsigned numConsArgs,
114                       FunctionDecl *operatorDelete, QualType ty,
115                       TypeSourceInfo *AllocatedTypeInfo,
116                       SourceLocation startLoc, SourceLocation endLoc,
117                       SourceLocation constructorLParen,
118                       SourceLocation constructorRParen)
119  : Expr(CXXNewExprClass, ty, ty->isDependentType(), ty->isDependentType()),
120    GlobalNew(globalNew),
121    Initializer(initializer), SubExprs(0), OperatorNew(operatorNew),
122    OperatorDelete(operatorDelete), Constructor(constructor),
123    AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens),
124    StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen),
125    ConstructorRParen(constructorRParen) {
126  AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs);
127  unsigned i = 0;
128  if (Array)
129    SubExprs[i++] = arraySize;
130  for (unsigned j = 0; j < NumPlacementArgs; ++j)
131    SubExprs[i++] = placementArgs[j];
132  for (unsigned j = 0; j < NumConstructorArgs; ++j)
133    SubExprs[i++] = constructorArgs[j];
134}
135
136void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
137                                   unsigned numPlaceArgs, unsigned numConsArgs){
138  assert(SubExprs == 0 && "SubExprs already allocated");
139  Array = isArray;
140  NumPlacementArgs = numPlaceArgs;
141  NumConstructorArgs = numConsArgs;
142
143  unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
144  SubExprs = new (C) Stmt*[TotalSize];
145}
146
147
148Stmt::child_iterator CXXNewExpr::child_begin() { return &SubExprs[0]; }
149Stmt::child_iterator CXXNewExpr::child_end() {
150  return &SubExprs[0] + Array + getNumPlacementArgs() + getNumConstructorArgs();
151}
152
153// CXXDeleteExpr
154QualType CXXDeleteExpr::getDestroyedType() const {
155  const Expr *Arg = getArgument();
156  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
157    if (ICE->getCastKind() != CK_UserDefinedConversion &&
158        ICE->getType()->isVoidPointerType())
159      Arg = ICE->getSubExpr();
160    else
161      break;
162  }
163  // The type-to-delete may not be a pointer if it's a dependent type.
164  const QualType ArgType = Arg->getType();
165  if (ArgType->isDependentType())
166    return ArgType;
167
168  return ArgType->getAs<PointerType>()->getPointeeType();
169}
170
171Stmt::child_iterator CXXDeleteExpr::child_begin() { return &Argument; }
172Stmt::child_iterator CXXDeleteExpr::child_end() { return &Argument+1; }
173
174// CXXPseudoDestructorExpr
175Stmt::child_iterator CXXPseudoDestructorExpr::child_begin() { return &Base; }
176Stmt::child_iterator CXXPseudoDestructorExpr::child_end() {
177  return &Base + 1;
178}
179
180PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
181 : Type(Info)
182{
183  Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
184}
185
186QualType CXXPseudoDestructorExpr::getDestroyedType() const {
187  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
188    return TInfo->getType();
189
190  return QualType();
191}
192
193SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
194  SourceLocation End = DestroyedType.getLocation();
195  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
196    End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
197  return SourceRange(Base->getLocStart(), End);
198}
199
200
201// UnresolvedLookupExpr
202UnresolvedLookupExpr *
203UnresolvedLookupExpr::Create(ASTContext &C, bool Dependent,
204                             CXXRecordDecl *NamingClass,
205                             NestedNameSpecifier *Qualifier,
206                             SourceRange QualifierRange,
207                             const DeclarationNameInfo &NameInfo,
208                             bool ADL,
209                             const TemplateArgumentListInfo &Args,
210                             UnresolvedSetIterator Begin,
211                             UnresolvedSetIterator End)
212{
213  void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
214                         ExplicitTemplateArgumentList::sizeFor(Args));
215  UnresolvedLookupExpr *ULE
216    = new (Mem) UnresolvedLookupExpr(C,
217                                     Dependent ? C.DependentTy : C.OverloadTy,
218                                     Dependent, NamingClass,
219                                     Qualifier, QualifierRange, NameInfo,
220                                     ADL,
221                                     /*Overload*/ true,
222                                     /*ExplicitTemplateArgs*/ true,
223                                     Begin, End);
224
225  reinterpret_cast<ExplicitTemplateArgumentList*>(ULE+1)->initializeFrom(Args);
226
227  return ULE;
228}
229
230UnresolvedLookupExpr *
231UnresolvedLookupExpr::CreateEmpty(ASTContext &C, unsigned NumTemplateArgs) {
232  std::size_t size = sizeof(UnresolvedLookupExpr);
233  if (NumTemplateArgs != 0)
234    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
235
236  void *Mem = C.Allocate(size, llvm::alignof<UnresolvedLookupExpr>());
237  UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
238  E->HasExplicitTemplateArgs = NumTemplateArgs != 0;
239  return E;
240}
241
242OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C, QualType T,
243                           bool Dependent, NestedNameSpecifier *Qualifier,
244                           SourceRange QRange,
245                           const DeclarationNameInfo &NameInfo,
246                           bool HasTemplateArgs,
247                           UnresolvedSetIterator Begin,
248                           UnresolvedSetIterator End)
249  : Expr(K, T, Dependent, Dependent),
250  Results(0), NumResults(0), NameInfo(NameInfo), Qualifier(Qualifier),
251  QualifierRange(QRange), HasExplicitTemplateArgs(HasTemplateArgs)
252{
253  initializeResults(C, Begin, End);
254}
255
256void OverloadExpr::initializeResults(ASTContext &C,
257                                     UnresolvedSetIterator Begin,
258                                     UnresolvedSetIterator End) {
259  assert(Results == 0 && "Results already initialized!");
260  NumResults = End - Begin;
261  if (NumResults) {
262    Results = static_cast<DeclAccessPair *>(
263                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
264                                           llvm::alignof<DeclAccessPair>()));
265    memcpy(Results, &*Begin.getIterator(),
266           NumResults * sizeof(DeclAccessPair));
267  }
268}
269
270
271bool OverloadExpr::ComputeDependence(UnresolvedSetIterator Begin,
272                                     UnresolvedSetIterator End,
273                                     const TemplateArgumentListInfo *Args) {
274  for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I)
275    if ((*I)->getDeclContext()->isDependentContext())
276      return true;
277
278  if (Args && TemplateSpecializationType::anyDependentTemplateArguments(*Args))
279    return true;
280
281  return false;
282}
283
284CXXRecordDecl *OverloadExpr::getNamingClass() const {
285  if (isa<UnresolvedLookupExpr>(this))
286    return cast<UnresolvedLookupExpr>(this)->getNamingClass();
287  else
288    return cast<UnresolvedMemberExpr>(this)->getNamingClass();
289}
290
291Stmt::child_iterator UnresolvedLookupExpr::child_begin() {
292  return child_iterator();
293}
294Stmt::child_iterator UnresolvedLookupExpr::child_end() {
295  return child_iterator();
296}
297// UnaryTypeTraitExpr
298Stmt::child_iterator UnaryTypeTraitExpr::child_begin() {
299  return child_iterator();
300}
301Stmt::child_iterator UnaryTypeTraitExpr::child_end() {
302  return child_iterator();
303}
304
305// DependentScopeDeclRefExpr
306DependentScopeDeclRefExpr *
307DependentScopeDeclRefExpr::Create(ASTContext &C,
308                                  NestedNameSpecifier *Qualifier,
309                                  SourceRange QualifierRange,
310                                  const DeclarationNameInfo &NameInfo,
311                                  const TemplateArgumentListInfo *Args) {
312  std::size_t size = sizeof(DependentScopeDeclRefExpr);
313  if (Args) size += ExplicitTemplateArgumentList::sizeFor(*Args);
314  void *Mem = C.Allocate(size);
315
316  DependentScopeDeclRefExpr *DRE
317    = new (Mem) DependentScopeDeclRefExpr(C.DependentTy,
318                                          Qualifier, QualifierRange,
319                                          NameInfo, Args != 0);
320
321  if (Args)
322    reinterpret_cast<ExplicitTemplateArgumentList*>(DRE+1)
323      ->initializeFrom(*Args);
324
325  return DRE;
326}
327
328DependentScopeDeclRefExpr *
329DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
330                                       unsigned NumTemplateArgs) {
331  std::size_t size = sizeof(DependentScopeDeclRefExpr);
332  if (NumTemplateArgs)
333    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
334  void *Mem = C.Allocate(size);
335
336  return new (Mem) DependentScopeDeclRefExpr(QualType(), 0, SourceRange(),
337                                             DeclarationNameInfo(),
338                                             NumTemplateArgs != 0);
339}
340
341StmtIterator DependentScopeDeclRefExpr::child_begin() {
342  return child_iterator();
343}
344
345StmtIterator DependentScopeDeclRefExpr::child_end() {
346  return child_iterator();
347}
348
349SourceRange CXXConstructExpr::getSourceRange() const {
350  return ParenRange.isValid() ?
351      SourceRange(Loc, ParenRange.getEnd()) :
352      SourceRange(Loc);
353}
354
355SourceRange CXXOperatorCallExpr::getSourceRange() const {
356  OverloadedOperatorKind Kind = getOperator();
357  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
358    if (getNumArgs() == 1)
359      // Prefix operator
360      return SourceRange(getOperatorLoc(),
361                         getArg(0)->getSourceRange().getEnd());
362    else
363      // Postfix operator
364      return SourceRange(getArg(0)->getSourceRange().getEnd(),
365                         getOperatorLoc());
366  } else if (Kind == OO_Call) {
367    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
368  } else if (Kind == OO_Subscript) {
369    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
370  } else if (getNumArgs() == 1) {
371    return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
372  } else if (getNumArgs() == 2) {
373    return SourceRange(getArg(0)->getSourceRange().getBegin(),
374                       getArg(1)->getSourceRange().getEnd());
375  } else {
376    return SourceRange();
377  }
378}
379
380Expr *CXXMemberCallExpr::getImplicitObjectArgument() {
381  if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
382    return MemExpr->getBase();
383
384  // FIXME: Will eventually need to cope with member pointers.
385  return 0;
386}
387
388CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
389  Expr* ThisArg = getImplicitObjectArgument();
390  if (!ThisArg)
391    return 0;
392
393  if (ThisArg->getType()->isAnyPointerType())
394    return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
395
396  return ThisArg->getType()->getAsCXXRecordDecl();
397}
398
399SourceRange CXXMemberCallExpr::getSourceRange() const {
400  SourceLocation LocStart = getCallee()->getLocStart();
401  if (LocStart.isInvalid() && getNumArgs() > 0)
402    LocStart = getArg(0)->getLocStart();
403  return SourceRange(LocStart, getRParenLoc());
404}
405
406
407//===----------------------------------------------------------------------===//
408//  Named casts
409//===----------------------------------------------------------------------===//
410
411/// getCastName - Get the name of the C++ cast being used, e.g.,
412/// "static_cast", "dynamic_cast", "reinterpret_cast", or
413/// "const_cast". The returned pointer must not be freed.
414const char *CXXNamedCastExpr::getCastName() const {
415  switch (getStmtClass()) {
416  case CXXStaticCastExprClass:      return "static_cast";
417  case CXXDynamicCastExprClass:     return "dynamic_cast";
418  case CXXReinterpretCastExprClass: return "reinterpret_cast";
419  case CXXConstCastExprClass:       return "const_cast";
420  default:                          return "<invalid cast>";
421  }
422}
423
424CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
425                                             CastKind K, Expr *Op,
426                                             const CXXCastPath *BasePath,
427                                             TypeSourceInfo *WrittenTy,
428                                             SourceLocation L) {
429  unsigned PathSize = (BasePath ? BasePath->size() : 0);
430  void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
431                            + PathSize * sizeof(CXXBaseSpecifier*));
432  CXXStaticCastExpr *E =
433    new (Buffer) CXXStaticCastExpr(T, K, Op, PathSize, WrittenTy, L);
434  if (PathSize) E->setCastPath(*BasePath);
435  return E;
436}
437
438CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
439                                                  unsigned PathSize) {
440  void *Buffer =
441    C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
442  return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
443}
444
445CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
446                                               CastKind K, Expr *Op,
447                                               const CXXCastPath *BasePath,
448                                               TypeSourceInfo *WrittenTy,
449                                               SourceLocation L) {
450  unsigned PathSize = (BasePath ? BasePath->size() : 0);
451  void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
452                            + PathSize * sizeof(CXXBaseSpecifier*));
453  CXXDynamicCastExpr *E =
454    new (Buffer) CXXDynamicCastExpr(T, K, Op, PathSize, WrittenTy, L);
455  if (PathSize) E->setCastPath(*BasePath);
456  return E;
457}
458
459CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
460                                                    unsigned PathSize) {
461  void *Buffer =
462    C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
463  return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
464}
465
466CXXReinterpretCastExpr *
467CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, CastKind K, Expr *Op,
468                               const CXXCastPath *BasePath,
469                               TypeSourceInfo *WrittenTy, SourceLocation L) {
470  unsigned PathSize = (BasePath ? BasePath->size() : 0);
471  void *Buffer =
472    C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
473  CXXReinterpretCastExpr *E =
474    new (Buffer) CXXReinterpretCastExpr(T, K, Op, PathSize, WrittenTy, L);
475  if (PathSize) E->setCastPath(*BasePath);
476  return E;
477}
478
479CXXReinterpretCastExpr *
480CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
481  void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
482                            + PathSize * sizeof(CXXBaseSpecifier*));
483  return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
484}
485
486CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T, Expr *Op,
487                                           TypeSourceInfo *WrittenTy,
488                                           SourceLocation L) {
489  return new (C) CXXConstCastExpr(T, Op, WrittenTy, L);
490}
491
492CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
493  return new (C) CXXConstCastExpr(EmptyShell());
494}
495
496CXXFunctionalCastExpr *
497CXXFunctionalCastExpr::Create(ASTContext &C, QualType T,
498                              TypeSourceInfo *Written, SourceLocation L,
499                              CastKind K, Expr *Op, const CXXCastPath *BasePath,
500                               SourceLocation R) {
501  unsigned PathSize = (BasePath ? BasePath->size() : 0);
502  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
503                            + PathSize * sizeof(CXXBaseSpecifier*));
504  CXXFunctionalCastExpr *E =
505    new (Buffer) CXXFunctionalCastExpr(T, Written, L, K, Op, PathSize, R);
506  if (PathSize) E->setCastPath(*BasePath);
507  return E;
508}
509
510CXXFunctionalCastExpr *
511CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
512  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
513                            + PathSize * sizeof(CXXBaseSpecifier*));
514  return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
515}
516
517
518CXXDefaultArgExpr *
519CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
520                          ParmVarDecl *Param, Expr *SubExpr) {
521  void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
522  return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
523                                     SubExpr);
524}
525
526CXXTemporary *CXXTemporary::Create(ASTContext &C,
527                                   const CXXDestructorDecl *Destructor) {
528  return new (C) CXXTemporary(Destructor);
529}
530
531CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
532                                                   CXXTemporary *Temp,
533                                                   Expr* SubExpr) {
534  assert(SubExpr->getType()->isRecordType() &&
535         "Expression bound to a temporary must have record type!");
536
537  return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
538}
539
540CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
541                                               CXXConstructorDecl *Cons,
542                                               TypeSourceInfo *Type,
543                                               Expr **Args,
544                                               unsigned NumArgs,
545                                               SourceRange parenRange,
546                                               bool ZeroInitialization)
547  : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
548                     Type->getType().getNonReferenceType(),
549                     Type->getTypeLoc().getBeginLoc(),
550                     Cons, false, Args, NumArgs, ZeroInitialization,
551                     CXXConstructExpr::CK_Complete, parenRange),
552    Type(Type) {
553}
554
555SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
556  return SourceRange(Type->getTypeLoc().getBeginLoc(),
557                     getParenRange().getEnd());
558}
559
560CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
561                                           SourceLocation Loc,
562                                           CXXConstructorDecl *D, bool Elidable,
563                                           Expr **Args, unsigned NumArgs,
564                                           bool ZeroInitialization,
565                                           ConstructionKind ConstructKind,
566                                           SourceRange ParenRange) {
567  return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
568                                  Elidable, Args, NumArgs, ZeroInitialization,
569                                  ConstructKind, ParenRange);
570}
571
572CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
573                                   SourceLocation Loc,
574                                   CXXConstructorDecl *D, bool elidable,
575                                   Expr **args, unsigned numargs,
576                                   bool ZeroInitialization,
577                                   ConstructionKind ConstructKind,
578                                   SourceRange ParenRange)
579: Expr(SC, T,
580       T->isDependentType(),
581       (T->isDependentType() ||
582        CallExpr::hasAnyValueDependentArguments(args, numargs))),
583  Constructor(D), Loc(Loc), ParenRange(ParenRange), Elidable(elidable),
584  ZeroInitialization(ZeroInitialization), ConstructKind(ConstructKind),
585  Args(0), NumArgs(numargs)
586{
587  if (NumArgs) {
588    Args = new (C) Stmt*[NumArgs];
589
590    for (unsigned i = 0; i != NumArgs; ++i) {
591      assert(args[i] && "NULL argument in CXXConstructExpr");
592      Args[i] = args[i];
593    }
594  }
595}
596
597CXXExprWithTemporaries::CXXExprWithTemporaries(ASTContext &C,
598                                               Expr *subexpr,
599                                               CXXTemporary **temps,
600                                               unsigned numtemps)
601  : Expr(CXXExprWithTemporariesClass, subexpr->getType(),
602       subexpr->isTypeDependent(), subexpr->isValueDependent()),
603    SubExpr(subexpr), Temps(0), NumTemps(0) {
604  if (numtemps) {
605    setNumTemporaries(C, numtemps);
606    for (unsigned i = 0; i != numtemps; ++i)
607      Temps[i] = temps[i];
608  }
609}
610
611void CXXExprWithTemporaries::setNumTemporaries(ASTContext &C, unsigned N) {
612  assert(Temps == 0 && "Cannot resize with this");
613  NumTemps = N;
614  Temps = new (C) CXXTemporary*[NumTemps];
615}
616
617
618CXXExprWithTemporaries *CXXExprWithTemporaries::Create(ASTContext &C,
619                                                       Expr *SubExpr,
620                                                       CXXTemporary **Temps,
621                                                       unsigned NumTemps) {
622  return new (C) CXXExprWithTemporaries(C, SubExpr, Temps, NumTemps);
623}
624
625// CXXBindTemporaryExpr
626Stmt::child_iterator CXXBindTemporaryExpr::child_begin() {
627  return &SubExpr;
628}
629
630Stmt::child_iterator CXXBindTemporaryExpr::child_end() {
631  return &SubExpr + 1;
632}
633
634// CXXConstructExpr
635Stmt::child_iterator CXXConstructExpr::child_begin() {
636  return &Args[0];
637}
638Stmt::child_iterator CXXConstructExpr::child_end() {
639  return &Args[0]+NumArgs;
640}
641
642// CXXExprWithTemporaries
643Stmt::child_iterator CXXExprWithTemporaries::child_begin() {
644  return &SubExpr;
645}
646
647Stmt::child_iterator CXXExprWithTemporaries::child_end() {
648  return &SubExpr + 1;
649}
650
651CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
652                                                 SourceLocation LParenLoc,
653                                                 Expr **Args,
654                                                 unsigned NumArgs,
655                                                 SourceLocation RParenLoc)
656  : Expr(CXXUnresolvedConstructExprClass,
657         Type->getType().getNonReferenceType(),
658         Type->getType()->isDependentType(), true),
659    Type(Type),
660    LParenLoc(LParenLoc),
661    RParenLoc(RParenLoc),
662    NumArgs(NumArgs) {
663  Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
664  memcpy(StoredArgs, Args, sizeof(Expr *) * NumArgs);
665}
666
667CXXUnresolvedConstructExpr *
668CXXUnresolvedConstructExpr::Create(ASTContext &C,
669                                   TypeSourceInfo *Type,
670                                   SourceLocation LParenLoc,
671                                   Expr **Args,
672                                   unsigned NumArgs,
673                                   SourceLocation RParenLoc) {
674  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
675                         sizeof(Expr *) * NumArgs);
676  return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
677                                              Args, NumArgs, RParenLoc);
678}
679
680CXXUnresolvedConstructExpr *
681CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
682  Stmt::EmptyShell Empty;
683  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
684                         sizeof(Expr *) * NumArgs);
685  return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
686}
687
688SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
689  return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
690}
691
692Stmt::child_iterator CXXUnresolvedConstructExpr::child_begin() {
693  return child_iterator(reinterpret_cast<Stmt **>(this + 1));
694}
695
696Stmt::child_iterator CXXUnresolvedConstructExpr::child_end() {
697  return child_iterator(reinterpret_cast<Stmt **>(this + 1) + NumArgs);
698}
699
700CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
701                                                 Expr *Base, QualType BaseType,
702                                                 bool IsArrow,
703                                                 SourceLocation OperatorLoc,
704                                                 NestedNameSpecifier *Qualifier,
705                                                 SourceRange QualifierRange,
706                                          NamedDecl *FirstQualifierFoundInScope,
707                                          DeclarationNameInfo MemberNameInfo,
708                                   const TemplateArgumentListInfo *TemplateArgs)
709  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy, true, true),
710    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
711    HasExplicitTemplateArgs(TemplateArgs != 0),
712    OperatorLoc(OperatorLoc),
713    Qualifier(Qualifier), QualifierRange(QualifierRange),
714    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
715    MemberNameInfo(MemberNameInfo) {
716  if (TemplateArgs)
717    getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
718}
719
720CXXDependentScopeMemberExpr *
721CXXDependentScopeMemberExpr::Create(ASTContext &C,
722                                Expr *Base, QualType BaseType, bool IsArrow,
723                                SourceLocation OperatorLoc,
724                                NestedNameSpecifier *Qualifier,
725                                SourceRange QualifierRange,
726                                NamedDecl *FirstQualifierFoundInScope,
727                                DeclarationNameInfo MemberNameInfo,
728                                const TemplateArgumentListInfo *TemplateArgs) {
729  if (!TemplateArgs)
730    return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
731                                               IsArrow, OperatorLoc,
732                                               Qualifier, QualifierRange,
733                                               FirstQualifierFoundInScope,
734                                               MemberNameInfo);
735
736  std::size_t size = sizeof(CXXDependentScopeMemberExpr);
737  if (TemplateArgs)
738    size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
739
740  void *Mem = C.Allocate(size, llvm::alignof<CXXDependentScopeMemberExpr>());
741  return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
742                                               IsArrow, OperatorLoc,
743                                               Qualifier, QualifierRange,
744                                               FirstQualifierFoundInScope,
745                                               MemberNameInfo, TemplateArgs);
746}
747
748CXXDependentScopeMemberExpr *
749CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
750                                         unsigned NumTemplateArgs) {
751  if (NumTemplateArgs == 0)
752    return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
753                                               0, SourceLocation(), 0,
754                                               SourceRange(), 0,
755                                               DeclarationNameInfo());
756
757  std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
758                     ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
759  void *Mem = C.Allocate(size, llvm::alignof<CXXDependentScopeMemberExpr>());
760  CXXDependentScopeMemberExpr *E
761    =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
762                                             0, SourceLocation(), 0,
763                                             SourceRange(), 0,
764                                             DeclarationNameInfo(), 0);
765  E->HasExplicitTemplateArgs = true;
766  return E;
767}
768
769Stmt::child_iterator CXXDependentScopeMemberExpr::child_begin() {
770  return child_iterator(&Base);
771}
772
773Stmt::child_iterator CXXDependentScopeMemberExpr::child_end() {
774  if (isImplicitAccess())
775    return child_iterator(&Base);
776  return child_iterator(&Base + 1);
777}
778
779UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C, QualType T,
780                                           bool Dependent,
781                                           bool HasUnresolvedUsing,
782                                           Expr *Base, QualType BaseType,
783                                           bool IsArrow,
784                                           SourceLocation OperatorLoc,
785                                           NestedNameSpecifier *Qualifier,
786                                           SourceRange QualifierRange,
787                                   const DeclarationNameInfo &MemberNameInfo,
788                                   const TemplateArgumentListInfo *TemplateArgs,
789                                           UnresolvedSetIterator Begin,
790                                           UnresolvedSetIterator End)
791  : OverloadExpr(UnresolvedMemberExprClass, C, T, Dependent,
792                 Qualifier, QualifierRange, MemberNameInfo,
793                 TemplateArgs != 0, Begin, End),
794    IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
795    Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
796  if (TemplateArgs)
797    getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
798}
799
800UnresolvedMemberExpr *
801UnresolvedMemberExpr::Create(ASTContext &C, bool Dependent,
802                             bool HasUnresolvedUsing,
803                             Expr *Base, QualType BaseType, bool IsArrow,
804                             SourceLocation OperatorLoc,
805                             NestedNameSpecifier *Qualifier,
806                             SourceRange QualifierRange,
807                             const DeclarationNameInfo &MemberNameInfo,
808                             const TemplateArgumentListInfo *TemplateArgs,
809                             UnresolvedSetIterator Begin,
810                             UnresolvedSetIterator End) {
811  std::size_t size = sizeof(UnresolvedMemberExpr);
812  if (TemplateArgs)
813    size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
814
815  void *Mem = C.Allocate(size, llvm::alignof<UnresolvedMemberExpr>());
816  return new (Mem) UnresolvedMemberExpr(C,
817                             Dependent ? C.DependentTy : C.OverloadTy,
818                             Dependent, HasUnresolvedUsing, Base, BaseType,
819                             IsArrow, OperatorLoc, Qualifier, QualifierRange,
820                             MemberNameInfo, TemplateArgs, Begin, End);
821}
822
823UnresolvedMemberExpr *
824UnresolvedMemberExpr::CreateEmpty(ASTContext &C, unsigned NumTemplateArgs) {
825  std::size_t size = sizeof(UnresolvedMemberExpr);
826  if (NumTemplateArgs != 0)
827    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
828
829  void *Mem = C.Allocate(size, llvm::alignof<UnresolvedMemberExpr>());
830  UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
831  E->HasExplicitTemplateArgs = NumTemplateArgs != 0;
832  return E;
833}
834
835CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
836  // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
837
838  // If there was a nested name specifier, it names the naming class.
839  // It can't be dependent: after all, we were actually able to do the
840  // lookup.
841  CXXRecordDecl *Record = 0;
842  if (getQualifier()) {
843    Type *T = getQualifier()->getAsType();
844    assert(T && "qualifier in member expression does not name type");
845    Record = T->getAsCXXRecordDecl();
846    assert(Record && "qualifier in member expression does not name record");
847  }
848  // Otherwise the naming class must have been the base class.
849  else {
850    QualType BaseType = getBaseType().getNonReferenceType();
851    if (isArrow()) {
852      const PointerType *PT = BaseType->getAs<PointerType>();
853      assert(PT && "base of arrow member access is not pointer");
854      BaseType = PT->getPointeeType();
855    }
856
857    Record = BaseType->getAsCXXRecordDecl();
858    assert(Record && "base of member expression does not name record");
859  }
860
861  return Record;
862}
863
864Stmt::child_iterator UnresolvedMemberExpr::child_begin() {
865  return child_iterator(&Base);
866}
867
868Stmt::child_iterator UnresolvedMemberExpr::child_end() {
869  if (isImplicitAccess())
870    return child_iterator(&Base);
871  return child_iterator(&Base + 1);
872}
873
874Stmt::child_iterator CXXNoexceptExpr::child_begin() {
875  return child_iterator(&Operand);
876}
877Stmt::child_iterator CXXNoexceptExpr::child_end() {
878  return child_iterator(&Operand + 1);
879}
880