ExprCXX.cpp revision 6ec278d1a354517e20f13a877481453ee7940c78 
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,
115                       bool usualArrayDeleteWantsSize, QualType ty,
116                       TypeSourceInfo *AllocatedTypeInfo,
117                       SourceLocation startLoc, SourceLocation endLoc,
118                       SourceLocation constructorLParen,
119                       SourceLocation constructorRParen)
120  : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary,
121         ty->isDependentType(), ty->isDependentType(),
122         ty->containsUnexpandedParameterPack()),
123    GlobalNew(globalNew), Initializer(initializer),
124    UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize),
125    SubExprs(0), OperatorNew(operatorNew),
126    OperatorDelete(operatorDelete), Constructor(constructor),
127    AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens),
128    StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen),
129    ConstructorRParen(constructorRParen) {
130  AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs);
131  unsigned i = 0;
132  if (Array) {
133    if (arraySize->containsUnexpandedParameterPack())
134      ExprBits.ContainsUnexpandedParameterPack = true;
135
136    SubExprs[i++] = arraySize;
137  }
138
139  for (unsigned j = 0; j < NumPlacementArgs; ++j) {
140    if (placementArgs[j]->containsUnexpandedParameterPack())
141      ExprBits.ContainsUnexpandedParameterPack = true;
142
143    SubExprs[i++] = placementArgs[j];
144  }
145
146  for (unsigned j = 0; j < NumConstructorArgs; ++j) {
147    if (constructorArgs[j]->containsUnexpandedParameterPack())
148      ExprBits.ContainsUnexpandedParameterPack = true;
149
150    SubExprs[i++] = constructorArgs[j];
151  }
152}
153
154void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
155                                   unsigned numPlaceArgs, unsigned numConsArgs){
156  assert(SubExprs == 0 && "SubExprs already allocated");
157  Array = isArray;
158  NumPlacementArgs = numPlaceArgs;
159  NumConstructorArgs = numConsArgs;
160
161  unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
162  SubExprs = new (C) Stmt*[TotalSize];
163}
164
165
166Stmt::child_iterator CXXNewExpr::child_begin() { return &SubExprs[0]; }
167Stmt::child_iterator CXXNewExpr::child_end() {
168  return &SubExprs[0] + Array + getNumPlacementArgs() + getNumConstructorArgs();
169}
170
171// CXXDeleteExpr
172QualType CXXDeleteExpr::getDestroyedType() const {
173  const Expr *Arg = getArgument();
174  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
175    if (ICE->getCastKind() != CK_UserDefinedConversion &&
176        ICE->getType()->isVoidPointerType())
177      Arg = ICE->getSubExpr();
178    else
179      break;
180  }
181  // The type-to-delete may not be a pointer if it's a dependent type.
182  const QualType ArgType = Arg->getType();
183
184  if (ArgType->isDependentType() && !ArgType->isPointerType())
185    return QualType();
186
187  return ArgType->getAs<PointerType>()->getPointeeType();
188}
189
190Stmt::child_iterator CXXDeleteExpr::child_begin() { return &Argument; }
191Stmt::child_iterator CXXDeleteExpr::child_end() { return &Argument+1; }
192
193// CXXPseudoDestructorExpr
194Stmt::child_iterator CXXPseudoDestructorExpr::child_begin() { return &Base; }
195Stmt::child_iterator CXXPseudoDestructorExpr::child_end() {
196  return &Base + 1;
197}
198
199PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
200 : Type(Info)
201{
202  Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
203}
204
205CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context,
206    Expr *Base, bool isArrow, SourceLocation OperatorLoc,
207    NestedNameSpecifier *Qualifier, SourceRange QualifierRange,
208    TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,
209    SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
210  : Expr(CXXPseudoDestructorExprClass,
211         Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0,
212                                         FunctionProtoType::ExtProtoInfo())),
213         VK_RValue, OK_Ordinary,
214         /*isTypeDependent=*/(Base->isTypeDependent() ||
215           (DestroyedType.getTypeSourceInfo() &&
216            DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
217         /*isValueDependent=*/Base->isValueDependent(),
218         // ContainsUnexpandedParameterPack
219         (Base->containsUnexpandedParameterPack() ||
220          (Qualifier && Qualifier->containsUnexpandedParameterPack()) ||
221          (ScopeType &&
222           ScopeType->getType()->containsUnexpandedParameterPack()) ||
223          (DestroyedType.getTypeSourceInfo() &&
224           DestroyedType.getTypeSourceInfo()->getType()
225                                   ->containsUnexpandedParameterPack()))),
226    Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
227    OperatorLoc(OperatorLoc), Qualifier(Qualifier),
228    QualifierRange(QualifierRange),
229    ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
230    DestroyedType(DestroyedType) { }
231
232QualType CXXPseudoDestructorExpr::getDestroyedType() const {
233  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
234    return TInfo->getType();
235
236  return QualType();
237}
238
239SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
240  SourceLocation End = DestroyedType.getLocation();
241  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
242    End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
243  return SourceRange(Base->getLocStart(), End);
244}
245
246
247// UnresolvedLookupExpr
248UnresolvedLookupExpr *
249UnresolvedLookupExpr::Create(ASTContext &C,
250                             CXXRecordDecl *NamingClass,
251                             NestedNameSpecifier *Qualifier,
252                             SourceRange QualifierRange,
253                             const DeclarationNameInfo &NameInfo,
254                             bool ADL,
255                             const TemplateArgumentListInfo &Args,
256                             UnresolvedSetIterator Begin,
257                             UnresolvedSetIterator End)
258{
259  void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
260                         ExplicitTemplateArgumentList::sizeFor(Args));
261  return new (Mem) UnresolvedLookupExpr(C, NamingClass,
262                                        Qualifier, QualifierRange, NameInfo,
263                                        ADL, /*Overload*/ true, &Args,
264                                        Begin, End);
265}
266
267UnresolvedLookupExpr *
268UnresolvedLookupExpr::CreateEmpty(ASTContext &C, unsigned NumTemplateArgs) {
269  std::size_t size = sizeof(UnresolvedLookupExpr);
270  if (NumTemplateArgs != 0)
271    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
272
273  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
274  UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
275  E->HasExplicitTemplateArgs = NumTemplateArgs != 0;
276  return E;
277}
278
279OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
280                           NestedNameSpecifier *Qualifier, SourceRange QRange,
281                           const DeclarationNameInfo &NameInfo,
282                           const TemplateArgumentListInfo *TemplateArgs,
283                           UnresolvedSetIterator Begin,
284                           UnresolvedSetIterator End,
285                           bool KnownDependent,
286                           bool KnownContainsUnexpandedParameterPack)
287  : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
288         KnownDependent,
289         (KnownContainsUnexpandedParameterPack ||
290          NameInfo.containsUnexpandedParameterPack() ||
291          (Qualifier && Qualifier->containsUnexpandedParameterPack()))),
292    Results(0), NumResults(End - Begin), NameInfo(NameInfo),
293    Qualifier(Qualifier), QualifierRange(QRange),
294    HasExplicitTemplateArgs(TemplateArgs != 0)
295{
296  NumResults = End - Begin;
297  if (NumResults) {
298    // Determine whether this expression is type-dependent.
299    for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
300      if ((*I)->getDeclContext()->isDependentContext() ||
301          isa<UnresolvedUsingValueDecl>(*I)) {
302        ExprBits.TypeDependent = true;
303        ExprBits.ValueDependent = true;
304      }
305    }
306
307    Results = static_cast<DeclAccessPair *>(
308                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
309                                           llvm::alignOf<DeclAccessPair>()));
310    memcpy(Results, &*Begin.getIterator(),
311           NumResults * sizeof(DeclAccessPair));
312  }
313
314  // If we have explicit template arguments, check for dependent
315  // template arguments and whether they contain any unexpanded pack
316  // expansions.
317  if (TemplateArgs) {
318    bool Dependent = false;
319    bool ContainsUnexpandedParameterPack = false;
320    getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
321                                             ContainsUnexpandedParameterPack);
322
323    if (Dependent) {
324        ExprBits.TypeDependent = true;
325        ExprBits.ValueDependent = true;
326    }
327    if (ContainsUnexpandedParameterPack)
328      ExprBits.ContainsUnexpandedParameterPack = true;
329  }
330
331  if (isTypeDependent())
332    setType(C.DependentTy);
333}
334
335void OverloadExpr::initializeResults(ASTContext &C,
336                                     UnresolvedSetIterator Begin,
337                                     UnresolvedSetIterator End) {
338  assert(Results == 0 && "Results already initialized!");
339  NumResults = End - Begin;
340  if (NumResults) {
341     Results = static_cast<DeclAccessPair *>(
342                               C.Allocate(sizeof(DeclAccessPair) * NumResults,
343
344                                          llvm::alignOf<DeclAccessPair>()));
345     memcpy(Results, &*Begin.getIterator(),
346            NumResults * sizeof(DeclAccessPair));
347  }
348}
349
350CXXRecordDecl *OverloadExpr::getNamingClass() const {
351  if (isa<UnresolvedLookupExpr>(this))
352    return cast<UnresolvedLookupExpr>(this)->getNamingClass();
353  else
354    return cast<UnresolvedMemberExpr>(this)->getNamingClass();
355}
356
357Stmt::child_iterator UnresolvedLookupExpr::child_begin() {
358  return child_iterator();
359}
360Stmt::child_iterator UnresolvedLookupExpr::child_end() {
361  return child_iterator();
362}
363// UnaryTypeTraitExpr
364Stmt::child_iterator UnaryTypeTraitExpr::child_begin() {
365  return child_iterator();
366}
367Stmt::child_iterator UnaryTypeTraitExpr::child_end() {
368  return child_iterator();
369}
370
371//BinaryTypeTraitExpr
372Stmt::child_iterator BinaryTypeTraitExpr::child_begin() {
373  return child_iterator();
374}
375Stmt::child_iterator BinaryTypeTraitExpr::child_end() {
376  return child_iterator();
377}
378
379// DependentScopeDeclRefExpr
380DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
381                            NestedNameSpecifier *Qualifier,
382                            SourceRange QualifierRange,
383                            const DeclarationNameInfo &NameInfo,
384                            const TemplateArgumentListInfo *Args)
385  : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
386         true, true,
387         (NameInfo.containsUnexpandedParameterPack() ||
388          (Qualifier && Qualifier->containsUnexpandedParameterPack()))),
389    NameInfo(NameInfo), QualifierRange(QualifierRange), Qualifier(Qualifier),
390    HasExplicitTemplateArgs(Args != 0)
391{
392  if (Args) {
393    bool Dependent = true;
394    bool ContainsUnexpandedParameterPack
395      = ExprBits.ContainsUnexpandedParameterPack;
396
397    reinterpret_cast<ExplicitTemplateArgumentList*>(this+1)
398      ->initializeFrom(*Args, Dependent, ContainsUnexpandedParameterPack);
399    ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
400  }
401}
402
403DependentScopeDeclRefExpr *
404DependentScopeDeclRefExpr::Create(ASTContext &C,
405                                  NestedNameSpecifier *Qualifier,
406                                  SourceRange QualifierRange,
407                                  const DeclarationNameInfo &NameInfo,
408                                  const TemplateArgumentListInfo *Args) {
409  std::size_t size = sizeof(DependentScopeDeclRefExpr);
410  if (Args)
411    size += ExplicitTemplateArgumentList::sizeFor(*Args);
412  void *Mem = C.Allocate(size);
413  return new (Mem) DependentScopeDeclRefExpr(C.DependentTy,
414                                             Qualifier, QualifierRange,
415                                             NameInfo, Args);
416}
417
418DependentScopeDeclRefExpr *
419DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
420                                       unsigned NumTemplateArgs) {
421  std::size_t size = sizeof(DependentScopeDeclRefExpr);
422  if (NumTemplateArgs)
423    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
424  void *Mem = C.Allocate(size);
425  return new (Mem) DependentScopeDeclRefExpr(QualType(), 0, SourceRange(),
426                                             DeclarationNameInfo(), 0);
427}
428
429StmtIterator DependentScopeDeclRefExpr::child_begin() {
430  return child_iterator();
431}
432
433StmtIterator DependentScopeDeclRefExpr::child_end() {
434  return child_iterator();
435}
436
437SourceRange CXXConstructExpr::getSourceRange() const {
438  if (ParenRange.isValid())
439    return SourceRange(Loc, ParenRange.getEnd());
440
441  SourceLocation End = Loc;
442  for (unsigned I = getNumArgs(); I > 0; --I) {
443    const Expr *Arg = getArg(I-1);
444    if (!Arg->isDefaultArgument()) {
445      SourceLocation NewEnd = Arg->getLocEnd();
446      if (NewEnd.isValid()) {
447        End = NewEnd;
448        break;
449      }
450    }
451  }
452
453  return SourceRange(Loc, End);
454}
455
456SourceRange CXXOperatorCallExpr::getSourceRange() const {
457  OverloadedOperatorKind Kind = getOperator();
458  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
459    if (getNumArgs() == 1)
460      // Prefix operator
461      return SourceRange(getOperatorLoc(),
462                         getArg(0)->getSourceRange().getEnd());
463    else
464      // Postfix operator
465      return SourceRange(getArg(0)->getSourceRange().getEnd(),
466                         getOperatorLoc());
467  } else if (Kind == OO_Call) {
468    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
469  } else if (Kind == OO_Subscript) {
470    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
471  } else if (getNumArgs() == 1) {
472    return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
473  } else if (getNumArgs() == 2) {
474    return SourceRange(getArg(0)->getSourceRange().getBegin(),
475                       getArg(1)->getSourceRange().getEnd());
476  } else {
477    return SourceRange();
478  }
479}
480
481Expr *CXXMemberCallExpr::getImplicitObjectArgument() {
482  if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
483    return MemExpr->getBase();
484
485  // FIXME: Will eventually need to cope with member pointers.
486  return 0;
487}
488
489CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
490  Expr* ThisArg = getImplicitObjectArgument();
491  if (!ThisArg)
492    return 0;
493
494  if (ThisArg->getType()->isAnyPointerType())
495    return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
496
497  return ThisArg->getType()->getAsCXXRecordDecl();
498}
499
500SourceRange CXXMemberCallExpr::getSourceRange() const {
501  SourceLocation LocStart = getCallee()->getLocStart();
502  if (LocStart.isInvalid() && getNumArgs() > 0)
503    LocStart = getArg(0)->getLocStart();
504  return SourceRange(LocStart, getRParenLoc());
505}
506
507
508//===----------------------------------------------------------------------===//
509//  Named casts
510//===----------------------------------------------------------------------===//
511
512/// getCastName - Get the name of the C++ cast being used, e.g.,
513/// "static_cast", "dynamic_cast", "reinterpret_cast", or
514/// "const_cast". The returned pointer must not be freed.
515const char *CXXNamedCastExpr::getCastName() const {
516  switch (getStmtClass()) {
517  case CXXStaticCastExprClass:      return "static_cast";
518  case CXXDynamicCastExprClass:     return "dynamic_cast";
519  case CXXReinterpretCastExprClass: return "reinterpret_cast";
520  case CXXConstCastExprClass:       return "const_cast";
521  default:                          return "<invalid cast>";
522  }
523}
524
525CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
526                                             ExprValueKind VK,
527                                             CastKind K, Expr *Op,
528                                             const CXXCastPath *BasePath,
529                                             TypeSourceInfo *WrittenTy,
530                                             SourceLocation L,
531                                             SourceLocation RParenLoc) {
532  unsigned PathSize = (BasePath ? BasePath->size() : 0);
533  void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
534                            + PathSize * sizeof(CXXBaseSpecifier*));
535  CXXStaticCastExpr *E =
536    new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
537                                   RParenLoc);
538  if (PathSize) E->setCastPath(*BasePath);
539  return E;
540}
541
542CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
543                                                  unsigned PathSize) {
544  void *Buffer =
545    C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
546  return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
547}
548
549CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
550                                               ExprValueKind VK,
551                                               CastKind K, Expr *Op,
552                                               const CXXCastPath *BasePath,
553                                               TypeSourceInfo *WrittenTy,
554                                               SourceLocation L,
555                                               SourceLocation RParenLoc) {
556  unsigned PathSize = (BasePath ? BasePath->size() : 0);
557  void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
558                            + PathSize * sizeof(CXXBaseSpecifier*));
559  CXXDynamicCastExpr *E =
560    new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
561                                    RParenLoc);
562  if (PathSize) E->setCastPath(*BasePath);
563  return E;
564}
565
566CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
567                                                    unsigned PathSize) {
568  void *Buffer =
569    C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
570  return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
571}
572
573CXXReinterpretCastExpr *
574CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
575                               CastKind K, Expr *Op,
576                               const CXXCastPath *BasePath,
577                               TypeSourceInfo *WrittenTy, SourceLocation L,
578                               SourceLocation RParenLoc) {
579  unsigned PathSize = (BasePath ? BasePath->size() : 0);
580  void *Buffer =
581    C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
582  CXXReinterpretCastExpr *E =
583    new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
584                                        RParenLoc);
585  if (PathSize) E->setCastPath(*BasePath);
586  return E;
587}
588
589CXXReinterpretCastExpr *
590CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
591  void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
592                            + PathSize * sizeof(CXXBaseSpecifier*));
593  return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
594}
595
596CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
597                                           ExprValueKind VK, Expr *Op,
598                                           TypeSourceInfo *WrittenTy,
599                                           SourceLocation L,
600                                           SourceLocation RParenLoc) {
601  return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
602}
603
604CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
605  return new (C) CXXConstCastExpr(EmptyShell());
606}
607
608CXXFunctionalCastExpr *
609CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
610                              TypeSourceInfo *Written, SourceLocation L,
611                              CastKind K, Expr *Op, const CXXCastPath *BasePath,
612                               SourceLocation R) {
613  unsigned PathSize = (BasePath ? BasePath->size() : 0);
614  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
615                            + PathSize * sizeof(CXXBaseSpecifier*));
616  CXXFunctionalCastExpr *E =
617    new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
618  if (PathSize) E->setCastPath(*BasePath);
619  return E;
620}
621
622CXXFunctionalCastExpr *
623CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
624  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
625                            + PathSize * sizeof(CXXBaseSpecifier*));
626  return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
627}
628
629
630CXXDefaultArgExpr *
631CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
632                          ParmVarDecl *Param, Expr *SubExpr) {
633  void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
634  return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
635                                     SubExpr);
636}
637
638CXXTemporary *CXXTemporary::Create(ASTContext &C,
639                                   const CXXDestructorDecl *Destructor) {
640  return new (C) CXXTemporary(Destructor);
641}
642
643CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
644                                                   CXXTemporary *Temp,
645                                                   Expr* SubExpr) {
646  assert(SubExpr->getType()->isRecordType() &&
647         "Expression bound to a temporary must have record type!");
648
649  return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
650}
651
652CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
653                                               CXXConstructorDecl *Cons,
654                                               TypeSourceInfo *Type,
655                                               Expr **Args,
656                                               unsigned NumArgs,
657                                               SourceRange parenRange,
658                                               bool ZeroInitialization)
659  : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
660                     Type->getType().getNonReferenceType(),
661                     Type->getTypeLoc().getBeginLoc(),
662                     Cons, false, Args, NumArgs, ZeroInitialization,
663                     CXXConstructExpr::CK_Complete, parenRange),
664    Type(Type) {
665}
666
667SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
668  return SourceRange(Type->getTypeLoc().getBeginLoc(),
669                     getParenRange().getEnd());
670}
671
672CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
673                                           SourceLocation Loc,
674                                           CXXConstructorDecl *D, bool Elidable,
675                                           Expr **Args, unsigned NumArgs,
676                                           bool ZeroInitialization,
677                                           ConstructionKind ConstructKind,
678                                           SourceRange ParenRange) {
679  return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
680                                  Elidable, Args, NumArgs, ZeroInitialization,
681                                  ConstructKind, ParenRange);
682}
683
684CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
685                                   SourceLocation Loc,
686                                   CXXConstructorDecl *D, bool elidable,
687                                   Expr **args, unsigned numargs,
688                                   bool ZeroInitialization,
689                                   ConstructionKind ConstructKind,
690                                   SourceRange ParenRange)
691  : Expr(SC, T, VK_RValue, OK_Ordinary,
692         T->isDependentType(), T->isDependentType(),
693         T->containsUnexpandedParameterPack()),
694    Constructor(D), Loc(Loc), ParenRange(ParenRange), Elidable(elidable),
695    ZeroInitialization(ZeroInitialization), ConstructKind(ConstructKind),
696    Args(0), NumArgs(numargs)
697{
698  if (NumArgs) {
699    Args = new (C) Stmt*[NumArgs];
700
701    for (unsigned i = 0; i != NumArgs; ++i) {
702      assert(args[i] && "NULL argument in CXXConstructExpr");
703
704      if (args[i]->isValueDependent())
705        ExprBits.ValueDependent = true;
706      if (args[i]->containsUnexpandedParameterPack())
707        ExprBits.ContainsUnexpandedParameterPack = true;
708
709      Args[i] = args[i];
710    }
711  }
712}
713
714ExprWithCleanups::ExprWithCleanups(ASTContext &C,
715                                   Expr *subexpr,
716                                   CXXTemporary **temps,
717                                   unsigned numtemps)
718  : Expr(ExprWithCleanupsClass, subexpr->getType(),
719         subexpr->getValueKind(), subexpr->getObjectKind(),
720         subexpr->isTypeDependent(), subexpr->isValueDependent(),
721         subexpr->containsUnexpandedParameterPack()),
722    SubExpr(subexpr), Temps(0), NumTemps(0) {
723  if (numtemps) {
724    setNumTemporaries(C, numtemps);
725    for (unsigned i = 0; i != numtemps; ++i)
726      Temps[i] = temps[i];
727  }
728}
729
730void ExprWithCleanups::setNumTemporaries(ASTContext &C, unsigned N) {
731  assert(Temps == 0 && "Cannot resize with this");
732  NumTemps = N;
733  Temps = new (C) CXXTemporary*[NumTemps];
734}
735
736
737ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C,
738                                           Expr *SubExpr,
739                                           CXXTemporary **Temps,
740                                           unsigned NumTemps) {
741  return new (C) ExprWithCleanups(C, SubExpr, Temps, NumTemps);
742}
743
744// CXXBindTemporaryExpr
745Stmt::child_iterator CXXBindTemporaryExpr::child_begin() {
746  return &SubExpr;
747}
748
749Stmt::child_iterator CXXBindTemporaryExpr::child_end() {
750  return &SubExpr + 1;
751}
752
753// CXXConstructExpr
754Stmt::child_iterator CXXConstructExpr::child_begin() {
755  return &Args[0];
756}
757Stmt::child_iterator CXXConstructExpr::child_end() {
758  return &Args[0]+NumArgs;
759}
760
761// ExprWithCleanups
762Stmt::child_iterator ExprWithCleanups::child_begin() {
763  return &SubExpr;
764}
765
766Stmt::child_iterator ExprWithCleanups::child_end() {
767  return &SubExpr + 1;
768}
769
770CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
771                                                 SourceLocation LParenLoc,
772                                                 Expr **Args,
773                                                 unsigned NumArgs,
774                                                 SourceLocation RParenLoc)
775  : Expr(CXXUnresolvedConstructExprClass,
776         Type->getType().getNonReferenceType(),
777         VK_LValue, OK_Ordinary,
778         Type->getType()->isDependentType(), true,
779         Type->getType()->containsUnexpandedParameterPack()),
780    Type(Type),
781    LParenLoc(LParenLoc),
782    RParenLoc(RParenLoc),
783    NumArgs(NumArgs) {
784  Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
785  for (unsigned I = 0; I != NumArgs; ++I) {
786    if (Args[I]->containsUnexpandedParameterPack())
787      ExprBits.ContainsUnexpandedParameterPack = true;
788
789    StoredArgs[I] = Args[I];
790  }
791}
792
793CXXUnresolvedConstructExpr *
794CXXUnresolvedConstructExpr::Create(ASTContext &C,
795                                   TypeSourceInfo *Type,
796                                   SourceLocation LParenLoc,
797                                   Expr **Args,
798                                   unsigned NumArgs,
799                                   SourceLocation RParenLoc) {
800  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
801                         sizeof(Expr *) * NumArgs);
802  return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
803                                              Args, NumArgs, RParenLoc);
804}
805
806CXXUnresolvedConstructExpr *
807CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
808  Stmt::EmptyShell Empty;
809  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
810                         sizeof(Expr *) * NumArgs);
811  return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
812}
813
814SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
815  return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
816}
817
818Stmt::child_iterator CXXUnresolvedConstructExpr::child_begin() {
819  return child_iterator(reinterpret_cast<Stmt **>(this + 1));
820}
821
822Stmt::child_iterator CXXUnresolvedConstructExpr::child_end() {
823  return child_iterator(reinterpret_cast<Stmt **>(this + 1) + NumArgs);
824}
825
826CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
827                                                 Expr *Base, QualType BaseType,
828                                                 bool IsArrow,
829                                                 SourceLocation OperatorLoc,
830                                                 NestedNameSpecifier *Qualifier,
831                                                 SourceRange QualifierRange,
832                                          NamedDecl *FirstQualifierFoundInScope,
833                                          DeclarationNameInfo MemberNameInfo,
834                                   const TemplateArgumentListInfo *TemplateArgs)
835  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
836         VK_LValue, OK_Ordinary, true, true,
837         ((Base && Base->containsUnexpandedParameterPack()) ||
838          (Qualifier && Qualifier->containsUnexpandedParameterPack()) ||
839          MemberNameInfo.containsUnexpandedParameterPack())),
840    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
841    HasExplicitTemplateArgs(TemplateArgs != 0),
842    OperatorLoc(OperatorLoc),
843    Qualifier(Qualifier), QualifierRange(QualifierRange),
844    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
845    MemberNameInfo(MemberNameInfo) {
846  if (TemplateArgs) {
847    bool Dependent = true;
848    bool ContainsUnexpandedParameterPack = false;
849    getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
850                                             ContainsUnexpandedParameterPack);
851    if (ContainsUnexpandedParameterPack)
852      ExprBits.ContainsUnexpandedParameterPack = true;
853  }
854}
855
856CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
857                          Expr *Base, QualType BaseType,
858                          bool IsArrow,
859                          SourceLocation OperatorLoc,
860                          NestedNameSpecifier *Qualifier,
861                          SourceRange QualifierRange,
862                          NamedDecl *FirstQualifierFoundInScope,
863                          DeclarationNameInfo MemberNameInfo)
864  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
865         VK_LValue, OK_Ordinary, true, true,
866         ((Base && Base->containsUnexpandedParameterPack()) ||
867          (Qualifier && Qualifier->containsUnexpandedParameterPack()) ||
868          MemberNameInfo.containsUnexpandedParameterPack())),
869    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
870    HasExplicitTemplateArgs(false), OperatorLoc(OperatorLoc),
871    Qualifier(Qualifier), QualifierRange(QualifierRange),
872    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
873    MemberNameInfo(MemberNameInfo) { }
874
875CXXDependentScopeMemberExpr *
876CXXDependentScopeMemberExpr::Create(ASTContext &C,
877                                Expr *Base, QualType BaseType, bool IsArrow,
878                                SourceLocation OperatorLoc,
879                                NestedNameSpecifier *Qualifier,
880                                SourceRange QualifierRange,
881                                NamedDecl *FirstQualifierFoundInScope,
882                                DeclarationNameInfo MemberNameInfo,
883                                const TemplateArgumentListInfo *TemplateArgs) {
884  if (!TemplateArgs)
885    return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
886                                               IsArrow, OperatorLoc,
887                                               Qualifier, QualifierRange,
888                                               FirstQualifierFoundInScope,
889                                               MemberNameInfo);
890
891  std::size_t size = sizeof(CXXDependentScopeMemberExpr);
892  if (TemplateArgs)
893    size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
894
895  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
896  return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
897                                               IsArrow, OperatorLoc,
898                                               Qualifier, QualifierRange,
899                                               FirstQualifierFoundInScope,
900                                               MemberNameInfo, TemplateArgs);
901}
902
903CXXDependentScopeMemberExpr *
904CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
905                                         unsigned NumTemplateArgs) {
906  if (NumTemplateArgs == 0)
907    return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
908                                               0, SourceLocation(), 0,
909                                               SourceRange(), 0,
910                                               DeclarationNameInfo());
911
912  std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
913                     ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
914  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
915  CXXDependentScopeMemberExpr *E
916    =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
917                                             0, SourceLocation(), 0,
918                                             SourceRange(), 0,
919                                             DeclarationNameInfo(), 0);
920  E->HasExplicitTemplateArgs = true;
921  return E;
922}
923
924Stmt::child_iterator CXXDependentScopeMemberExpr::child_begin() {
925  return child_iterator(&Base);
926}
927
928Stmt::child_iterator CXXDependentScopeMemberExpr::child_end() {
929  if (isImplicitAccess())
930    return child_iterator(&Base);
931  return child_iterator(&Base + 1);
932}
933
934UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
935                                           bool HasUnresolvedUsing,
936                                           Expr *Base, QualType BaseType,
937                                           bool IsArrow,
938                                           SourceLocation OperatorLoc,
939                                           NestedNameSpecifier *Qualifier,
940                                           SourceRange QualifierRange,
941                                   const DeclarationNameInfo &MemberNameInfo,
942                                   const TemplateArgumentListInfo *TemplateArgs,
943                                           UnresolvedSetIterator Begin,
944                                           UnresolvedSetIterator End)
945  : OverloadExpr(UnresolvedMemberExprClass, C,
946                 Qualifier, QualifierRange, MemberNameInfo,
947                 TemplateArgs, Begin, End,
948                 // Dependent
949                 ((Base && Base->isTypeDependent()) ||
950                  BaseType->isDependentType()),
951                 // Contains unexpanded parameter pack
952                 ((Base && Base->containsUnexpandedParameterPack()) ||
953                  BaseType->containsUnexpandedParameterPack())),
954    IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
955    Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
956}
957
958UnresolvedMemberExpr *
959UnresolvedMemberExpr::Create(ASTContext &C,
960                             bool HasUnresolvedUsing,
961                             Expr *Base, QualType BaseType, bool IsArrow,
962                             SourceLocation OperatorLoc,
963                             NestedNameSpecifier *Qualifier,
964                             SourceRange QualifierRange,
965                             const DeclarationNameInfo &MemberNameInfo,
966                             const TemplateArgumentListInfo *TemplateArgs,
967                             UnresolvedSetIterator Begin,
968                             UnresolvedSetIterator End) {
969  std::size_t size = sizeof(UnresolvedMemberExpr);
970  if (TemplateArgs)
971    size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
972
973  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
974  return new (Mem) UnresolvedMemberExpr(C,
975                             HasUnresolvedUsing, Base, BaseType,
976                             IsArrow, OperatorLoc, Qualifier, QualifierRange,
977                             MemberNameInfo, TemplateArgs, Begin, End);
978}
979
980UnresolvedMemberExpr *
981UnresolvedMemberExpr::CreateEmpty(ASTContext &C, unsigned NumTemplateArgs) {
982  std::size_t size = sizeof(UnresolvedMemberExpr);
983  if (NumTemplateArgs != 0)
984    size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
985
986  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
987  UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
988  E->HasExplicitTemplateArgs = NumTemplateArgs != 0;
989  return E;
990}
991
992CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
993  // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
994
995  // If there was a nested name specifier, it names the naming class.
996  // It can't be dependent: after all, we were actually able to do the
997  // lookup.
998  CXXRecordDecl *Record = 0;
999  if (getQualifier()) {
1000    const Type *T = getQualifier()->getAsType();
1001    assert(T && "qualifier in member expression does not name type");
1002    Record = T->getAsCXXRecordDecl();
1003    assert(Record && "qualifier in member expression does not name record");
1004  }
1005  // Otherwise the naming class must have been the base class.
1006  else {
1007    QualType BaseType = getBaseType().getNonReferenceType();
1008    if (isArrow()) {
1009      const PointerType *PT = BaseType->getAs<PointerType>();
1010      assert(PT && "base of arrow member access is not pointer");
1011      BaseType = PT->getPointeeType();
1012    }
1013
1014    Record = BaseType->getAsCXXRecordDecl();
1015    assert(Record && "base of member expression does not name record");
1016  }
1017
1018  return Record;
1019}
1020
1021Stmt::child_iterator UnresolvedMemberExpr::child_begin() {
1022  return child_iterator(&Base);
1023}
1024
1025Stmt::child_iterator UnresolvedMemberExpr::child_end() {
1026  if (isImplicitAccess())
1027    return child_iterator(&Base);
1028  return child_iterator(&Base + 1);
1029}
1030
1031Stmt::child_iterator CXXNoexceptExpr::child_begin() {
1032  return child_iterator(&Operand);
1033}
1034Stmt::child_iterator CXXNoexceptExpr::child_end() {
1035  return child_iterator(&Operand + 1);
1036}
1037
1038SourceRange PackExpansionExpr::getSourceRange() const {
1039  return SourceRange(Pattern->getLocStart(), EllipsisLoc);
1040}
1041
1042Stmt::child_iterator PackExpansionExpr::child_begin() {
1043  return child_iterator(&Pattern);
1044}
1045
1046Stmt::child_iterator PackExpansionExpr::child_end() {
1047  return child_iterator(&Pattern + 1);
1048}
1049
1050SourceRange SizeOfPackExpr::getSourceRange() const {
1051  return SourceRange(OperatorLoc, RParenLoc);
1052}
1053
1054Stmt::child_iterator SizeOfPackExpr::child_begin() {
1055  return child_iterator();
1056}
1057
1058Stmt::child_iterator SizeOfPackExpr::child_end() {
1059  return child_iterator();
1060}
1061
1062SubstNonTypeTemplateParmPackExpr::
1063SubstNonTypeTemplateParmPackExpr(QualType T,
1064                                 NonTypeTemplateParmDecl *Param,
1065                                 SourceLocation NameLoc,
1066                                 const TemplateArgument &ArgPack)
1067  : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1068         true, false, true),
1069    Param(Param), Arguments(ArgPack.pack_begin()),
1070    NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1071
1072TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1073  return TemplateArgument(Arguments, NumArguments);
1074}
1075
1076SourceRange SubstNonTypeTemplateParmPackExpr::getSourceRange() const {
1077  return NameLoc;
1078}
1079
1080Stmt::child_iterator SubstNonTypeTemplateParmPackExpr::child_begin() {
1081  return child_iterator();
1082}
1083
1084Stmt::child_iterator SubstNonTypeTemplateParmPackExpr::child_end() {
1085  return child_iterator();
1086}
1087
1088
1089