ExprCXX.cpp revision 1548d14f4092a817f7d90ad3e7a65266dc85fbc5 
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                       bool HadMultipleCandidates,
53                       FunctionDecl *operatorDelete,
54                       bool usualArrayDeleteWantsSize, QualType ty,
55                       TypeSourceInfo *AllocatedTypeInfo,
56                       SourceLocation startLoc, SourceLocation endLoc,
57                       SourceLocation constructorLParen,
58                       SourceLocation constructorRParen)
59  : Expr(CXXNewExprClass, ty, VK_RValue, OK_Ordinary,
60         ty->isDependentType(), ty->isDependentType(),
61         ty->isInstantiationDependentType(),
62         ty->containsUnexpandedParameterPack()),
63    GlobalNew(globalNew), Initializer(initializer),
64    UsualArrayDeleteWantsSize(usualArrayDeleteWantsSize),
65    HadMultipleCandidates(HadMultipleCandidates),
66    SubExprs(0), OperatorNew(operatorNew),
67    OperatorDelete(operatorDelete), Constructor(constructor),
68    AllocatedTypeInfo(AllocatedTypeInfo), TypeIdParens(TypeIdParens),
69    StartLoc(startLoc), EndLoc(endLoc), ConstructorLParen(constructorLParen),
70    ConstructorRParen(constructorRParen) {
71  AllocateArgsArray(C, arraySize != 0, numPlaceArgs, numConsArgs);
72  unsigned i = 0;
73  if (Array) {
74    if (arraySize->isInstantiationDependent())
75      ExprBits.InstantiationDependent = true;
76
77    if (arraySize->containsUnexpandedParameterPack())
78      ExprBits.ContainsUnexpandedParameterPack = true;
79
80    SubExprs[i++] = arraySize;
81  }
82
83  for (unsigned j = 0; j < NumPlacementArgs; ++j) {
84    if (placementArgs[j]->isInstantiationDependent())
85      ExprBits.InstantiationDependent = true;
86    if (placementArgs[j]->containsUnexpandedParameterPack())
87      ExprBits.ContainsUnexpandedParameterPack = true;
88
89    SubExprs[i++] = placementArgs[j];
90  }
91
92  for (unsigned j = 0; j < NumConstructorArgs; ++j) {
93    if (constructorArgs[j]->isInstantiationDependent())
94      ExprBits.InstantiationDependent = true;
95    if (constructorArgs[j]->containsUnexpandedParameterPack())
96      ExprBits.ContainsUnexpandedParameterPack = true;
97
98    SubExprs[i++] = constructorArgs[j];
99  }
100}
101
102void CXXNewExpr::AllocateArgsArray(ASTContext &C, bool isArray,
103                                   unsigned numPlaceArgs, unsigned numConsArgs){
104  assert(SubExprs == 0 && "SubExprs already allocated");
105  Array = isArray;
106  NumPlacementArgs = numPlaceArgs;
107  NumConstructorArgs = numConsArgs;
108
109  unsigned TotalSize = Array + NumPlacementArgs + NumConstructorArgs;
110  SubExprs = new (C) Stmt*[TotalSize];
111}
112
113bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const {
114  return getOperatorNew()->getType()->
115    castAs<FunctionProtoType>()->isNothrow(Ctx);
116}
117
118// CXXDeleteExpr
119QualType CXXDeleteExpr::getDestroyedType() const {
120  const Expr *Arg = getArgument();
121  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
122    if (ICE->getCastKind() != CK_UserDefinedConversion &&
123        ICE->getType()->isVoidPointerType())
124      Arg = ICE->getSubExpr();
125    else
126      break;
127  }
128  // The type-to-delete may not be a pointer if it's a dependent type.
129  const QualType ArgType = Arg->getType();
130
131  if (ArgType->isDependentType() && !ArgType->isPointerType())
132    return QualType();
133
134  return ArgType->getAs<PointerType>()->getPointeeType();
135}
136
137// CXXPseudoDestructorExpr
138PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
139 : Type(Info)
140{
141  Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
142}
143
144CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(ASTContext &Context,
145                Expr *Base, bool isArrow, SourceLocation OperatorLoc,
146                NestedNameSpecifierLoc QualifierLoc, TypeSourceInfo *ScopeType,
147                SourceLocation ColonColonLoc, SourceLocation TildeLoc,
148                PseudoDestructorTypeStorage DestroyedType)
149  : Expr(CXXPseudoDestructorExprClass,
150         Context.getPointerType(Context.getFunctionType(Context.VoidTy, 0, 0,
151                                         FunctionProtoType::ExtProtoInfo())),
152         VK_RValue, OK_Ordinary,
153         /*isTypeDependent=*/(Base->isTypeDependent() ||
154           (DestroyedType.getTypeSourceInfo() &&
155            DestroyedType.getTypeSourceInfo()->getType()->isDependentType())),
156         /*isValueDependent=*/Base->isValueDependent(),
157         (Base->isInstantiationDependent() ||
158          (QualifierLoc &&
159           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) ||
160          (ScopeType &&
161           ScopeType->getType()->isInstantiationDependentType()) ||
162          (DestroyedType.getTypeSourceInfo() &&
163           DestroyedType.getTypeSourceInfo()->getType()
164                                             ->isInstantiationDependentType())),
165         // ContainsUnexpandedParameterPack
166         (Base->containsUnexpandedParameterPack() ||
167          (QualifierLoc &&
168           QualifierLoc.getNestedNameSpecifier()
169                                        ->containsUnexpandedParameterPack()) ||
170          (ScopeType &&
171           ScopeType->getType()->containsUnexpandedParameterPack()) ||
172          (DestroyedType.getTypeSourceInfo() &&
173           DestroyedType.getTypeSourceInfo()->getType()
174                                   ->containsUnexpandedParameterPack()))),
175    Base(static_cast<Stmt *>(Base)), IsArrow(isArrow),
176    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
177    ScopeType(ScopeType), ColonColonLoc(ColonColonLoc), TildeLoc(TildeLoc),
178    DestroyedType(DestroyedType) { }
179
180QualType CXXPseudoDestructorExpr::getDestroyedType() const {
181  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
182    return TInfo->getType();
183
184  return QualType();
185}
186
187SourceRange CXXPseudoDestructorExpr::getSourceRange() const {
188  SourceLocation End = DestroyedType.getLocation();
189  if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
190    End = TInfo->getTypeLoc().getLocalSourceRange().getEnd();
191  return SourceRange(Base->getLocStart(), End);
192}
193
194
195// UnresolvedLookupExpr
196UnresolvedLookupExpr *
197UnresolvedLookupExpr::Create(ASTContext &C,
198                             CXXRecordDecl *NamingClass,
199                             NestedNameSpecifierLoc QualifierLoc,
200                             SourceLocation TemplateKWLoc,
201                             const DeclarationNameInfo &NameInfo,
202                             bool ADL,
203                             const TemplateArgumentListInfo *Args,
204                             UnresolvedSetIterator Begin,
205                             UnresolvedSetIterator End)
206{
207  assert(Args || TemplateKWLoc.isValid());
208  unsigned num_args = Args ? Args->size() : 0;
209  void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
210                         ASTTemplateKWAndArgsInfo::sizeFor(num_args));
211  return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
212                                        TemplateKWLoc, NameInfo,
213                                        ADL, /*Overload*/ true, Args,
214                                        Begin, End, /*StdIsAssociated=*/false);
215}
216
217UnresolvedLookupExpr *
218UnresolvedLookupExpr::CreateEmpty(ASTContext &C,
219                                  bool HasTemplateKWAndArgsInfo,
220                                  unsigned NumTemplateArgs) {
221  std::size_t size = sizeof(UnresolvedLookupExpr);
222  if (HasTemplateKWAndArgsInfo)
223    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
224
225  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
226  UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
227  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
228  return E;
229}
230
231OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
232                           NestedNameSpecifierLoc QualifierLoc,
233                           SourceLocation TemplateKWLoc,
234                           const DeclarationNameInfo &NameInfo,
235                           const TemplateArgumentListInfo *TemplateArgs,
236                           UnresolvedSetIterator Begin,
237                           UnresolvedSetIterator End,
238                           bool KnownDependent,
239                           bool KnownInstantiationDependent,
240                           bool KnownContainsUnexpandedParameterPack)
241  : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
242         KnownDependent,
243         (KnownInstantiationDependent ||
244          NameInfo.isInstantiationDependent() ||
245          (QualifierLoc &&
246           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
247         (KnownContainsUnexpandedParameterPack ||
248          NameInfo.containsUnexpandedParameterPack() ||
249          (QualifierLoc &&
250           QualifierLoc.getNestedNameSpecifier()
251                                      ->containsUnexpandedParameterPack()))),
252    Results(0), NumResults(End - Begin), NameInfo(NameInfo),
253    QualifierLoc(QualifierLoc),
254    HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid())
255{
256  NumResults = End - Begin;
257  if (NumResults) {
258    // Determine whether this expression is type-dependent.
259    for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
260      if ((*I)->getDeclContext()->isDependentContext() ||
261          isa<UnresolvedUsingValueDecl>(*I)) {
262        ExprBits.TypeDependent = true;
263        ExprBits.ValueDependent = true;
264      }
265    }
266
267    Results = static_cast<DeclAccessPair *>(
268                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
269                                           llvm::alignOf<DeclAccessPair>()));
270    memcpy(Results, &*Begin.getIterator(),
271           NumResults * sizeof(DeclAccessPair));
272  }
273
274  // If we have explicit template arguments, check for dependent
275  // template arguments and whether they contain any unexpanded pack
276  // expansions.
277  if (TemplateArgs) {
278    bool Dependent = false;
279    bool InstantiationDependent = false;
280    bool ContainsUnexpandedParameterPack = false;
281    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
282                                               Dependent,
283                                               InstantiationDependent,
284                                               ContainsUnexpandedParameterPack);
285
286    if (Dependent) {
287      ExprBits.TypeDependent = true;
288      ExprBits.ValueDependent = true;
289    }
290    if (InstantiationDependent)
291      ExprBits.InstantiationDependent = true;
292    if (ContainsUnexpandedParameterPack)
293      ExprBits.ContainsUnexpandedParameterPack = true;
294  } else if (TemplateKWLoc.isValid()) {
295    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
296  }
297
298  if (isTypeDependent())
299    setType(C.DependentTy);
300}
301
302void OverloadExpr::initializeResults(ASTContext &C,
303                                     UnresolvedSetIterator Begin,
304                                     UnresolvedSetIterator End) {
305  assert(Results == 0 && "Results already initialized!");
306  NumResults = End - Begin;
307  if (NumResults) {
308     Results = static_cast<DeclAccessPair *>(
309                               C.Allocate(sizeof(DeclAccessPair) * NumResults,
310
311                                          llvm::alignOf<DeclAccessPair>()));
312     memcpy(Results, &*Begin.getIterator(),
313            NumResults * sizeof(DeclAccessPair));
314  }
315}
316
317CXXRecordDecl *OverloadExpr::getNamingClass() const {
318  if (isa<UnresolvedLookupExpr>(this))
319    return cast<UnresolvedLookupExpr>(this)->getNamingClass();
320  else
321    return cast<UnresolvedMemberExpr>(this)->getNamingClass();
322}
323
324// DependentScopeDeclRefExpr
325DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
326                            NestedNameSpecifierLoc QualifierLoc,
327                            SourceLocation TemplateKWLoc,
328                            const DeclarationNameInfo &NameInfo,
329                            const TemplateArgumentListInfo *Args)
330  : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
331         true, true,
332         (NameInfo.isInstantiationDependent() ||
333          (QualifierLoc &&
334           QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
335         (NameInfo.containsUnexpandedParameterPack() ||
336          (QualifierLoc &&
337           QualifierLoc.getNestedNameSpecifier()
338                            ->containsUnexpandedParameterPack()))),
339    QualifierLoc(QualifierLoc), NameInfo(NameInfo),
340    HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid())
341{
342  if (Args) {
343    bool Dependent = true;
344    bool InstantiationDependent = true;
345    bool ContainsUnexpandedParameterPack
346      = ExprBits.ContainsUnexpandedParameterPack;
347    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args,
348                                               Dependent,
349                                               InstantiationDependent,
350                                               ContainsUnexpandedParameterPack);
351    ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
352  } else if (TemplateKWLoc.isValid()) {
353    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
354  }
355}
356
357DependentScopeDeclRefExpr *
358DependentScopeDeclRefExpr::Create(ASTContext &C,
359                                  NestedNameSpecifierLoc QualifierLoc,
360                                  SourceLocation TemplateKWLoc,
361                                  const DeclarationNameInfo &NameInfo,
362                                  const TemplateArgumentListInfo *Args) {
363  std::size_t size = sizeof(DependentScopeDeclRefExpr);
364  if (Args)
365    size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size());
366  else if (TemplateKWLoc.isValid())
367    size += ASTTemplateKWAndArgsInfo::sizeFor(0);
368  void *Mem = C.Allocate(size);
369  return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
370                                             TemplateKWLoc, NameInfo, Args);
371}
372
373DependentScopeDeclRefExpr *
374DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
375                                       bool HasTemplateKWAndArgsInfo,
376                                       unsigned NumTemplateArgs) {
377  std::size_t size = sizeof(DependentScopeDeclRefExpr);
378  if (HasTemplateKWAndArgsInfo)
379    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
380  void *Mem = C.Allocate(size);
381  DependentScopeDeclRefExpr *E
382    = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
383                                          SourceLocation(),
384                                          DeclarationNameInfo(), 0);
385  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
386  return E;
387}
388
389SourceRange CXXConstructExpr::getSourceRange() const {
390  if (isa<CXXTemporaryObjectExpr>(this))
391    return cast<CXXTemporaryObjectExpr>(this)->getSourceRange();
392
393  if (ParenRange.isValid())
394    return SourceRange(Loc, ParenRange.getEnd());
395
396  SourceLocation End = Loc;
397  for (unsigned I = getNumArgs(); I > 0; --I) {
398    const Expr *Arg = getArg(I-1);
399    if (!Arg->isDefaultArgument()) {
400      SourceLocation NewEnd = Arg->getLocEnd();
401      if (NewEnd.isValid()) {
402        End = NewEnd;
403        break;
404      }
405    }
406  }
407
408  return SourceRange(Loc, End);
409}
410
411SourceRange CXXOperatorCallExpr::getSourceRange() const {
412  OverloadedOperatorKind Kind = getOperator();
413  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
414    if (getNumArgs() == 1)
415      // Prefix operator
416      return SourceRange(getOperatorLoc(),
417                         getArg(0)->getSourceRange().getEnd());
418    else
419      // Postfix operator
420      return SourceRange(getArg(0)->getSourceRange().getBegin(),
421                         getOperatorLoc());
422  } else if (Kind == OO_Arrow) {
423    return getArg(0)->getSourceRange();
424  } else if (Kind == OO_Call) {
425    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
426  } else if (Kind == OO_Subscript) {
427    return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
428  } else if (getNumArgs() == 1) {
429    return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
430  } else if (getNumArgs() == 2) {
431    return SourceRange(getArg(0)->getSourceRange().getBegin(),
432                       getArg(1)->getSourceRange().getEnd());
433  } else {
434    return SourceRange();
435  }
436}
437
438Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
439  if (const MemberExpr *MemExpr =
440        dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
441    return MemExpr->getBase();
442
443  // FIXME: Will eventually need to cope with member pointers.
444  return 0;
445}
446
447CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
448  if (const MemberExpr *MemExpr =
449      dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
450    return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
451
452  // FIXME: Will eventually need to cope with member pointers.
453  return 0;
454}
455
456
457CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
458  Expr* ThisArg = getImplicitObjectArgument();
459  if (!ThisArg)
460    return 0;
461
462  if (ThisArg->getType()->isAnyPointerType())
463    return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
464
465  return ThisArg->getType()->getAsCXXRecordDecl();
466}
467
468
469//===----------------------------------------------------------------------===//
470//  Named casts
471//===----------------------------------------------------------------------===//
472
473/// getCastName - Get the name of the C++ cast being used, e.g.,
474/// "static_cast", "dynamic_cast", "reinterpret_cast", or
475/// "const_cast". The returned pointer must not be freed.
476const char *CXXNamedCastExpr::getCastName() const {
477  switch (getStmtClass()) {
478  case CXXStaticCastExprClass:      return "static_cast";
479  case CXXDynamicCastExprClass:     return "dynamic_cast";
480  case CXXReinterpretCastExprClass: return "reinterpret_cast";
481  case CXXConstCastExprClass:       return "const_cast";
482  default:                          return "<invalid cast>";
483  }
484}
485
486CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
487                                             ExprValueKind VK,
488                                             CastKind K, Expr *Op,
489                                             const CXXCastPath *BasePath,
490                                             TypeSourceInfo *WrittenTy,
491                                             SourceLocation L,
492                                             SourceLocation RParenLoc) {
493  unsigned PathSize = (BasePath ? BasePath->size() : 0);
494  void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
495                            + PathSize * sizeof(CXXBaseSpecifier*));
496  CXXStaticCastExpr *E =
497    new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
498                                   RParenLoc);
499  if (PathSize) E->setCastPath(*BasePath);
500  return E;
501}
502
503CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
504                                                  unsigned PathSize) {
505  void *Buffer =
506    C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
507  return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
508}
509
510CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
511                                               ExprValueKind VK,
512                                               CastKind K, Expr *Op,
513                                               const CXXCastPath *BasePath,
514                                               TypeSourceInfo *WrittenTy,
515                                               SourceLocation L,
516                                               SourceLocation RParenLoc) {
517  unsigned PathSize = (BasePath ? BasePath->size() : 0);
518  void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
519                            + PathSize * sizeof(CXXBaseSpecifier*));
520  CXXDynamicCastExpr *E =
521    new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
522                                    RParenLoc);
523  if (PathSize) E->setCastPath(*BasePath);
524  return E;
525}
526
527CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
528                                                    unsigned PathSize) {
529  void *Buffer =
530    C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
531  return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
532}
533
534/// isAlwaysNull - Return whether the result of the dynamic_cast is proven
535/// to always be null. For example:
536///
537/// struct A { };
538/// struct B final : A { };
539/// struct C { };
540///
541/// C *f(B* b) { return dynamic_cast<C*>(b); }
542bool CXXDynamicCastExpr::isAlwaysNull() const
543{
544  QualType SrcType = getSubExpr()->getType();
545  QualType DestType = getType();
546
547  if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) {
548    SrcType = SrcPTy->getPointeeType();
549    DestType = DestType->castAs<PointerType>()->getPointeeType();
550  }
551
552  const CXXRecordDecl *SrcRD =
553    cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
554
555  if (!SrcRD->hasAttr<FinalAttr>())
556    return false;
557
558  const CXXRecordDecl *DestRD =
559    cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
560
561  return !DestRD->isDerivedFrom(SrcRD);
562}
563
564CXXReinterpretCastExpr *
565CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
566                               CastKind K, Expr *Op,
567                               const CXXCastPath *BasePath,
568                               TypeSourceInfo *WrittenTy, SourceLocation L,
569                               SourceLocation RParenLoc) {
570  unsigned PathSize = (BasePath ? BasePath->size() : 0);
571  void *Buffer =
572    C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
573  CXXReinterpretCastExpr *E =
574    new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
575                                        RParenLoc);
576  if (PathSize) E->setCastPath(*BasePath);
577  return E;
578}
579
580CXXReinterpretCastExpr *
581CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
582  void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
583                            + PathSize * sizeof(CXXBaseSpecifier*));
584  return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
585}
586
587CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
588                                           ExprValueKind VK, Expr *Op,
589                                           TypeSourceInfo *WrittenTy,
590                                           SourceLocation L,
591                                           SourceLocation RParenLoc) {
592  return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
593}
594
595CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
596  return new (C) CXXConstCastExpr(EmptyShell());
597}
598
599CXXFunctionalCastExpr *
600CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
601                              TypeSourceInfo *Written, SourceLocation L,
602                              CastKind K, Expr *Op, const CXXCastPath *BasePath,
603                               SourceLocation R) {
604  unsigned PathSize = (BasePath ? BasePath->size() : 0);
605  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
606                            + PathSize * sizeof(CXXBaseSpecifier*));
607  CXXFunctionalCastExpr *E =
608    new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
609  if (PathSize) E->setCastPath(*BasePath);
610  return E;
611}
612
613CXXFunctionalCastExpr *
614CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
615  void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
616                            + PathSize * sizeof(CXXBaseSpecifier*));
617  return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
618}
619
620
621CXXDefaultArgExpr *
622CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
623                          ParmVarDecl *Param, Expr *SubExpr) {
624  void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
625  return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
626                                     SubExpr);
627}
628
629CXXTemporary *CXXTemporary::Create(ASTContext &C,
630                                   const CXXDestructorDecl *Destructor) {
631  return new (C) CXXTemporary(Destructor);
632}
633
634CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
635                                                   CXXTemporary *Temp,
636                                                   Expr* SubExpr) {
637  assert((SubExpr->getType()->isRecordType() ||
638          SubExpr->getType()->isArrayType()) &&
639         "Expression bound to a temporary must have record or array type!");
640
641  return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
642}
643
644CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
645                                               CXXConstructorDecl *Cons,
646                                               TypeSourceInfo *Type,
647                                               Expr **Args,
648                                               unsigned NumArgs,
649                                               SourceRange parenRange,
650                                               bool HadMultipleCandidates,
651                                               bool ZeroInitialization)
652  : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
653                     Type->getType().getNonReferenceType(),
654                     Type->getTypeLoc().getBeginLoc(),
655                     Cons, false, Args, NumArgs,
656                     HadMultipleCandidates, /*FIXME*/false, ZeroInitialization,
657                     CXXConstructExpr::CK_Complete, parenRange),
658    Type(Type) {
659}
660
661SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
662  return SourceRange(Type->getTypeLoc().getBeginLoc(),
663                     getParenRange().getEnd());
664}
665
666CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
667                                           SourceLocation Loc,
668                                           CXXConstructorDecl *D, bool Elidable,
669                                           Expr **Args, unsigned NumArgs,
670                                           bool HadMultipleCandidates,
671                                           bool ListInitialization,
672                                           bool ZeroInitialization,
673                                           ConstructionKind ConstructKind,
674                                           SourceRange ParenRange) {
675  return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
676                                  Elidable, Args, NumArgs,
677                                  HadMultipleCandidates, ListInitialization,
678                                  ZeroInitialization, ConstructKind,
679                                  ParenRange);
680}
681
682CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
683                                   SourceLocation Loc,
684                                   CXXConstructorDecl *D, bool elidable,
685                                   Expr **args, unsigned numargs,
686                                   bool HadMultipleCandidates,
687                                   bool ListInitialization,
688                                   bool ZeroInitialization,
689                                   ConstructionKind ConstructKind,
690                                   SourceRange ParenRange)
691  : Expr(SC, T, VK_RValue, OK_Ordinary,
692         T->isDependentType(), T->isDependentType(),
693         T->isInstantiationDependentType(),
694         T->containsUnexpandedParameterPack()),
695    Constructor(D), Loc(Loc), ParenRange(ParenRange),  NumArgs(numargs),
696    Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
697    ListInitialization(ListInitialization),
698    ZeroInitialization(ZeroInitialization),
699    ConstructKind(ConstructKind), Args(0)
700{
701  if (NumArgs) {
702    Args = new (C) Stmt*[NumArgs];
703
704    for (unsigned i = 0; i != NumArgs; ++i) {
705      assert(args[i] && "NULL argument in CXXConstructExpr");
706
707      if (args[i]->isValueDependent())
708        ExprBits.ValueDependent = true;
709      if (args[i]->isInstantiationDependent())
710        ExprBits.InstantiationDependent = true;
711      if (args[i]->containsUnexpandedParameterPack())
712        ExprBits.ContainsUnexpandedParameterPack = true;
713
714      Args[i] = args[i];
715    }
716  }
717}
718
719LambdaExpr::Capture::Capture(SourceLocation Loc, bool Implicit,
720                             LambdaCaptureKind Kind, VarDecl *Var,
721                             SourceLocation EllipsisLoc)
722  : VarAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc)
723{
724  unsigned Bits = 0;
725  if (Implicit)
726    Bits |= Capture_Implicit;
727
728  switch (Kind) {
729  case LCK_This:
730    assert(Var == 0 && "'this' capture cannot have a variable!");
731    break;
732
733  case LCK_ByCopy:
734    Bits |= Capture_ByCopy;
735    // Fall through
736  case LCK_ByRef:
737    assert(Var && "capture must have a variable!");
738    break;
739  }
740  VarAndBits.setInt(Bits);
741}
742
743LambdaCaptureKind LambdaExpr::Capture::getCaptureKind() const {
744  if (capturesThis())
745    return LCK_This;
746
747  return (VarAndBits.getInt() & Capture_ByCopy)? LCK_ByCopy : LCK_ByRef;
748}
749
750LambdaExpr::LambdaExpr(QualType T,
751                       SourceRange IntroducerRange,
752                       LambdaCaptureDefault CaptureDefault,
753                       ArrayRef<Capture> Captures,
754                       bool ExplicitParams,
755                       bool ExplicitResultType,
756                       ArrayRef<Expr *> CaptureInits,
757                       ArrayRef<VarDecl *> ArrayIndexVars,
758                       ArrayRef<unsigned> ArrayIndexStarts,
759                       SourceLocation ClosingBrace)
760  : Expr(LambdaExprClass, T, VK_RValue, OK_Ordinary,
761         T->isDependentType(), T->isDependentType(), T->isDependentType(),
762         /*ContainsUnexpandedParameterPack=*/false),
763    IntroducerRange(IntroducerRange),
764    NumCaptures(Captures.size()),
765    CaptureDefault(CaptureDefault),
766    ExplicitParams(ExplicitParams),
767    ExplicitResultType(ExplicitResultType),
768    ClosingBrace(ClosingBrace)
769{
770  assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments");
771  CXXRecordDecl *Class = getLambdaClass();
772  CXXRecordDecl::LambdaDefinitionData &Data = Class->getLambdaData();
773
774  // FIXME: Propagate "has unexpanded parameter pack" bit.
775
776  // Copy captures.
777  ASTContext &Context = Class->getASTContext();
778  Data.NumCaptures = NumCaptures;
779  Data.NumExplicitCaptures = 0;
780  Data.Captures = (Capture *)Context.Allocate(sizeof(Capture) * NumCaptures);
781  Capture *ToCapture = Data.Captures;
782  for (unsigned I = 0, N = Captures.size(); I != N; ++I) {
783    if (Captures[I].isExplicit())
784      ++Data.NumExplicitCaptures;
785
786    *ToCapture++ = Captures[I];
787  }
788
789  // Copy initialization expressions for the non-static data members.
790  Stmt **Stored = getStoredStmts();
791  for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
792    *Stored++ = CaptureInits[I];
793
794  // Copy the body of the lambda.
795  *Stored++ = getCallOperator()->getBody();
796
797  // Copy the array index variables, if any.
798  HasArrayIndexVars = !ArrayIndexVars.empty();
799  if (HasArrayIndexVars) {
800    assert(ArrayIndexStarts.size() == NumCaptures);
801    memcpy(getArrayIndexVars(), ArrayIndexVars.data(),
802           sizeof(VarDecl *) * ArrayIndexVars.size());
803    memcpy(getArrayIndexStarts(), ArrayIndexStarts.data(),
804           sizeof(unsigned) * Captures.size());
805    getArrayIndexStarts()[Captures.size()] = ArrayIndexVars.size();
806  }
807}
808
809LambdaExpr *LambdaExpr::Create(ASTContext &Context,
810                               CXXRecordDecl *Class,
811                               SourceRange IntroducerRange,
812                               LambdaCaptureDefault CaptureDefault,
813                               ArrayRef<Capture> Captures,
814                               bool ExplicitParams,
815                               bool ExplicitResultType,
816                               ArrayRef<Expr *> CaptureInits,
817                               ArrayRef<VarDecl *> ArrayIndexVars,
818                               ArrayRef<unsigned> ArrayIndexStarts,
819                               SourceLocation ClosingBrace) {
820  // Determine the type of the expression (i.e., the type of the
821  // function object we're creating).
822  QualType T = Context.getTypeDeclType(Class);
823
824  unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (Captures.size() + 1);
825  if (!ArrayIndexVars.empty())
826    Size += sizeof(VarDecl *) * ArrayIndexVars.size()
827          + sizeof(unsigned) * (Captures.size() + 1);
828  void *Mem = Context.Allocate(Size);
829  return new (Mem) LambdaExpr(T, IntroducerRange, CaptureDefault,
830                              Captures, ExplicitParams, ExplicitResultType,
831                              CaptureInits, ArrayIndexVars, ArrayIndexStarts,
832                              ClosingBrace);
833}
834
835LambdaExpr *LambdaExpr::CreateDeserialized(ASTContext &C, unsigned NumCaptures,
836                                           unsigned NumArrayIndexVars) {
837  unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1);
838  if (NumArrayIndexVars)
839    Size += sizeof(VarDecl) * NumArrayIndexVars
840          + sizeof(unsigned) * (NumCaptures + 1);
841  void *Mem = C.Allocate(Size);
842  return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0);
843}
844
845LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
846  return getLambdaClass()->getLambdaData().Captures;
847}
848
849LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
850  return capture_begin() + NumCaptures;
851}
852
853LambdaExpr::capture_iterator LambdaExpr::explicit_capture_begin() const {
854  return capture_begin();
855}
856
857LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const {
858  struct CXXRecordDecl::LambdaDefinitionData &Data
859    = getLambdaClass()->getLambdaData();
860  return Data.Captures + Data.NumExplicitCaptures;
861}
862
863LambdaExpr::capture_iterator LambdaExpr::implicit_capture_begin() const {
864  return explicit_capture_end();
865}
866
867LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const {
868  return capture_end();
869}
870
871ArrayRef<VarDecl *>
872LambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const {
873  assert(HasArrayIndexVars && "No array index-var data?");
874
875  unsigned Index = Iter - capture_init_begin();
876  assert(Index < getLambdaClass()->getLambdaData().NumCaptures &&
877         "Capture index out-of-range");
878  VarDecl **IndexVars = getArrayIndexVars();
879  unsigned *IndexStarts = getArrayIndexStarts();
880  return ArrayRef<VarDecl *>(IndexVars + IndexStarts[Index],
881                             IndexVars + IndexStarts[Index + 1]);
882}
883
884CXXRecordDecl *LambdaExpr::getLambdaClass() const {
885  return getType()->getAsCXXRecordDecl();
886}
887
888CXXMethodDecl *LambdaExpr::getCallOperator() const {
889  CXXRecordDecl *Record = getLambdaClass();
890  DeclarationName Name
891    = Record->getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
892  DeclContext::lookup_result Calls = Record->lookup(Name);
893  assert(Calls.first != Calls.second && "Missing lambda call operator!");
894  CXXMethodDecl *Result = cast<CXXMethodDecl>(*Calls.first++);
895  assert(Calls.first == Calls.second && "More than lambda one call operator?");
896  return Result;
897}
898
899CompoundStmt *LambdaExpr::getBody() const {
900  if (!getStoredStmts()[NumCaptures])
901    getStoredStmts()[NumCaptures] = getCallOperator()->getBody();
902
903  return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]);
904}
905
906bool LambdaExpr::isMutable() const {
907  return (getCallOperator()->getTypeQualifiers() & Qualifiers::Const) == 0;
908}
909
910ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
911                                   ArrayRef<CleanupObject> objects)
912  : Expr(ExprWithCleanupsClass, subexpr->getType(),
913         subexpr->getValueKind(), subexpr->getObjectKind(),
914         subexpr->isTypeDependent(), subexpr->isValueDependent(),
915         subexpr->isInstantiationDependent(),
916         subexpr->containsUnexpandedParameterPack()),
917    SubExpr(subexpr) {
918  ExprWithCleanupsBits.NumObjects = objects.size();
919  for (unsigned i = 0, e = objects.size(); i != e; ++i)
920    getObjectsBuffer()[i] = objects[i];
921}
922
923ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr,
924                                           ArrayRef<CleanupObject> objects) {
925  size_t size = sizeof(ExprWithCleanups)
926              + objects.size() * sizeof(CleanupObject);
927  void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
928  return new (buffer) ExprWithCleanups(subexpr, objects);
929}
930
931ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
932  : Expr(ExprWithCleanupsClass, empty) {
933  ExprWithCleanupsBits.NumObjects = numObjects;
934}
935
936ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty,
937                                           unsigned numObjects) {
938  size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject);
939  void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
940  return new (buffer) ExprWithCleanups(empty, numObjects);
941}
942
943CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
944                                                 SourceLocation LParenLoc,
945                                                 Expr **Args,
946                                                 unsigned NumArgs,
947                                                 SourceLocation RParenLoc)
948  : Expr(CXXUnresolvedConstructExprClass,
949         Type->getType().getNonReferenceType(),
950         (Type->getType()->isLValueReferenceType() ? VK_LValue
951          :Type->getType()->isRValueReferenceType()? VK_XValue
952          :VK_RValue),
953         OK_Ordinary,
954         Type->getType()->isDependentType(), true, true,
955         Type->getType()->containsUnexpandedParameterPack()),
956    Type(Type),
957    LParenLoc(LParenLoc),
958    RParenLoc(RParenLoc),
959    NumArgs(NumArgs) {
960  Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
961  for (unsigned I = 0; I != NumArgs; ++I) {
962    if (Args[I]->containsUnexpandedParameterPack())
963      ExprBits.ContainsUnexpandedParameterPack = true;
964
965    StoredArgs[I] = Args[I];
966  }
967}
968
969CXXUnresolvedConstructExpr *
970CXXUnresolvedConstructExpr::Create(ASTContext &C,
971                                   TypeSourceInfo *Type,
972                                   SourceLocation LParenLoc,
973                                   Expr **Args,
974                                   unsigned NumArgs,
975                                   SourceLocation RParenLoc) {
976  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
977                         sizeof(Expr *) * NumArgs);
978  return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
979                                              Args, NumArgs, RParenLoc);
980}
981
982CXXUnresolvedConstructExpr *
983CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
984  Stmt::EmptyShell Empty;
985  void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
986                         sizeof(Expr *) * NumArgs);
987  return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
988}
989
990SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
991  return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
992}
993
994CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
995                                                 Expr *Base, QualType BaseType,
996                                                 bool IsArrow,
997                                                 SourceLocation OperatorLoc,
998                                          NestedNameSpecifierLoc QualifierLoc,
999                                          SourceLocation TemplateKWLoc,
1000                                          NamedDecl *FirstQualifierFoundInScope,
1001                                          DeclarationNameInfo MemberNameInfo,
1002                                   const TemplateArgumentListInfo *TemplateArgs)
1003  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
1004         VK_LValue, OK_Ordinary, true, true, true,
1005         ((Base && Base->containsUnexpandedParameterPack()) ||
1006          (QualifierLoc &&
1007           QualifierLoc.getNestedNameSpecifier()
1008                                       ->containsUnexpandedParameterPack()) ||
1009          MemberNameInfo.containsUnexpandedParameterPack())),
1010    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
1011    HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()),
1012    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
1013    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
1014    MemberNameInfo(MemberNameInfo) {
1015  if (TemplateArgs) {
1016    bool Dependent = true;
1017    bool InstantiationDependent = true;
1018    bool ContainsUnexpandedParameterPack = false;
1019    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
1020                                               Dependent,
1021                                               InstantiationDependent,
1022                                               ContainsUnexpandedParameterPack);
1023    if (ContainsUnexpandedParameterPack)
1024      ExprBits.ContainsUnexpandedParameterPack = true;
1025  } else if (TemplateKWLoc.isValid()) {
1026    getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
1027  }
1028}
1029
1030CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
1031                          Expr *Base, QualType BaseType,
1032                          bool IsArrow,
1033                          SourceLocation OperatorLoc,
1034                          NestedNameSpecifierLoc QualifierLoc,
1035                          NamedDecl *FirstQualifierFoundInScope,
1036                          DeclarationNameInfo MemberNameInfo)
1037  : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
1038         VK_LValue, OK_Ordinary, true, true, true,
1039         ((Base && Base->containsUnexpandedParameterPack()) ||
1040          (QualifierLoc &&
1041           QualifierLoc.getNestedNameSpecifier()->
1042                                         containsUnexpandedParameterPack()) ||
1043          MemberNameInfo.containsUnexpandedParameterPack())),
1044    Base(Base), BaseType(BaseType), IsArrow(IsArrow),
1045    HasTemplateKWAndArgsInfo(false),
1046    OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
1047    FirstQualifierFoundInScope(FirstQualifierFoundInScope),
1048    MemberNameInfo(MemberNameInfo) { }
1049
1050CXXDependentScopeMemberExpr *
1051CXXDependentScopeMemberExpr::Create(ASTContext &C,
1052                                Expr *Base, QualType BaseType, bool IsArrow,
1053                                SourceLocation OperatorLoc,
1054                                NestedNameSpecifierLoc QualifierLoc,
1055                                SourceLocation TemplateKWLoc,
1056                                NamedDecl *FirstQualifierFoundInScope,
1057                                DeclarationNameInfo MemberNameInfo,
1058                                const TemplateArgumentListInfo *TemplateArgs) {
1059  if (!TemplateArgs && !TemplateKWLoc.isValid())
1060    return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
1061                                               IsArrow, OperatorLoc,
1062                                               QualifierLoc,
1063                                               FirstQualifierFoundInScope,
1064                                               MemberNameInfo);
1065
1066  unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
1067  std::size_t size = sizeof(CXXDependentScopeMemberExpr)
1068    + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1069
1070  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
1071  return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
1072                                               IsArrow, OperatorLoc,
1073                                               QualifierLoc,
1074                                               TemplateKWLoc,
1075                                               FirstQualifierFoundInScope,
1076                                               MemberNameInfo, TemplateArgs);
1077}
1078
1079CXXDependentScopeMemberExpr *
1080CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
1081                                         bool HasTemplateKWAndArgsInfo,
1082                                         unsigned NumTemplateArgs) {
1083  if (!HasTemplateKWAndArgsInfo)
1084    return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
1085                                               0, SourceLocation(),
1086                                               NestedNameSpecifierLoc(), 0,
1087                                               DeclarationNameInfo());
1088
1089  std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
1090                     ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1091  void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
1092  CXXDependentScopeMemberExpr *E
1093    =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
1094                                             0, SourceLocation(),
1095                                             NestedNameSpecifierLoc(),
1096                                             SourceLocation(), 0,
1097                                             DeclarationNameInfo(), 0);
1098  E->HasTemplateKWAndArgsInfo = true;
1099  return E;
1100}
1101
1102bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
1103  if (Base == 0)
1104    return true;
1105
1106  return cast<Expr>(Base)->isImplicitCXXThis();
1107}
1108
1109static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
1110                                            UnresolvedSetIterator end) {
1111  do {
1112    NamedDecl *decl = *begin;
1113    if (isa<UnresolvedUsingValueDecl>(decl))
1114      return false;
1115    if (isa<UsingShadowDecl>(decl))
1116      decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
1117
1118    // Unresolved member expressions should only contain methods and
1119    // method templates.
1120    assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
1121
1122    if (isa<FunctionTemplateDecl>(decl))
1123      decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
1124    if (cast<CXXMethodDecl>(decl)->isStatic())
1125      return false;
1126  } while (++begin != end);
1127
1128  return true;
1129}
1130
1131UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
1132                                           bool HasUnresolvedUsing,
1133                                           Expr *Base, QualType BaseType,
1134                                           bool IsArrow,
1135                                           SourceLocation OperatorLoc,
1136                                           NestedNameSpecifierLoc QualifierLoc,
1137                                           SourceLocation TemplateKWLoc,
1138                                   const DeclarationNameInfo &MemberNameInfo,
1139                                   const TemplateArgumentListInfo *TemplateArgs,
1140                                           UnresolvedSetIterator Begin,
1141                                           UnresolvedSetIterator End)
1142  : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc,
1143                 MemberNameInfo, TemplateArgs, Begin, End,
1144                 // Dependent
1145                 ((Base && Base->isTypeDependent()) ||
1146                  BaseType->isDependentType()),
1147                 ((Base && Base->isInstantiationDependent()) ||
1148                   BaseType->isInstantiationDependentType()),
1149                 // Contains unexpanded parameter pack
1150                 ((Base && Base->containsUnexpandedParameterPack()) ||
1151                  BaseType->containsUnexpandedParameterPack())),
1152    IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
1153    Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
1154
1155  // Check whether all of the members are non-static member functions,
1156  // and if so, mark give this bound-member type instead of overload type.
1157  if (hasOnlyNonStaticMemberFunctions(Begin, End))
1158    setType(C.BoundMemberTy);
1159}
1160
1161bool UnresolvedMemberExpr::isImplicitAccess() const {
1162  if (Base == 0)
1163    return true;
1164
1165  return cast<Expr>(Base)->isImplicitCXXThis();
1166}
1167
1168UnresolvedMemberExpr *
1169UnresolvedMemberExpr::Create(ASTContext &C,
1170                             bool HasUnresolvedUsing,
1171                             Expr *Base, QualType BaseType, bool IsArrow,
1172                             SourceLocation OperatorLoc,
1173                             NestedNameSpecifierLoc QualifierLoc,
1174                             SourceLocation TemplateKWLoc,
1175                             const DeclarationNameInfo &MemberNameInfo,
1176                             const TemplateArgumentListInfo *TemplateArgs,
1177                             UnresolvedSetIterator Begin,
1178                             UnresolvedSetIterator End) {
1179  std::size_t size = sizeof(UnresolvedMemberExpr);
1180  if (TemplateArgs)
1181    size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
1182  else if (TemplateKWLoc.isValid())
1183    size += ASTTemplateKWAndArgsInfo::sizeFor(0);
1184
1185  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
1186  return new (Mem) UnresolvedMemberExpr(C,
1187                             HasUnresolvedUsing, Base, BaseType,
1188                             IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
1189                             MemberNameInfo, TemplateArgs, Begin, End);
1190}
1191
1192UnresolvedMemberExpr *
1193UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo,
1194                                  unsigned NumTemplateArgs) {
1195  std::size_t size = sizeof(UnresolvedMemberExpr);
1196  if (HasTemplateKWAndArgsInfo)
1197    size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1198
1199  void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
1200  UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
1201  E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
1202  return E;
1203}
1204
1205CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
1206  // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
1207
1208  // If there was a nested name specifier, it names the naming class.
1209  // It can't be dependent: after all, we were actually able to do the
1210  // lookup.
1211  CXXRecordDecl *Record = 0;
1212  if (getQualifier()) {
1213    const Type *T = getQualifier()->getAsType();
1214    assert(T && "qualifier in member expression does not name type");
1215    Record = T->getAsCXXRecordDecl();
1216    assert(Record && "qualifier in member expression does not name record");
1217  }
1218  // Otherwise the naming class must have been the base class.
1219  else {
1220    QualType BaseType = getBaseType().getNonReferenceType();
1221    if (isArrow()) {
1222      const PointerType *PT = BaseType->getAs<PointerType>();
1223      assert(PT && "base of arrow member access is not pointer");
1224      BaseType = PT->getPointeeType();
1225    }
1226
1227    Record = BaseType->getAsCXXRecordDecl();
1228    assert(Record && "base of member expression does not name record");
1229  }
1230
1231  return Record;
1232}
1233
1234SubstNonTypeTemplateParmPackExpr::
1235SubstNonTypeTemplateParmPackExpr(QualType T,
1236                                 NonTypeTemplateParmDecl *Param,
1237                                 SourceLocation NameLoc,
1238                                 const TemplateArgument &ArgPack)
1239  : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1240         true, true, true, true),
1241    Param(Param), Arguments(ArgPack.pack_begin()),
1242    NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1243
1244TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1245  return TemplateArgument(Arguments, NumArguments);
1246}
1247
1248void ArrayTypeTraitExpr::anchor() { }
1249