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