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"
19 using namespace clang;
20 
21 
22 //===----------------------------------------------------------------------===//
23 //  Child Iterators for iterating over subexpressions/substatements
24 //===----------------------------------------------------------------------===//
25 
26 QualType CXXTypeidExpr::getTypeOperand() const {
27   assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)");
28   return Operand.get<TypeSourceInfo *>()->getType().getNonReferenceType()
29                                                         .getUnqualifiedType();
30 }
31 
32 QualType 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
39 SourceRange CXXScalarValueInitExpr::getSourceRange() const {
40   SourceLocation Start = RParenLoc;
41   if (TypeInfo)
42     Start = TypeInfo->getTypeLoc().getBeginLoc();
43   return SourceRange(Start, RParenLoc);
44 }
45 
46 // CXXNewExpr
47 CXXNewExpr::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 
102 void 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 
113 bool CXXNewExpr::shouldNullCheckAllocation(ASTContext &Ctx) const {
114   return getOperatorNew()->getType()->
115     castAs<FunctionProtoType>()->isNothrow(Ctx);
116 }
117 
118 // CXXDeleteExpr
119 QualType 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
138 PseudoDestructorTypeStorage::PseudoDestructorTypeStorage(TypeSourceInfo *Info)
139  : Type(Info)
140 {
141   Location = Info->getTypeLoc().getLocalSourceRange().getBegin();
142 }
143 
144 CXXPseudoDestructorExpr::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 
180 QualType CXXPseudoDestructorExpr::getDestroyedType() const {
181   if (TypeSourceInfo *TInfo = DestroyedType.getTypeSourceInfo())
182     return TInfo->getType();
183 
184   return QualType();
185 }
186 
187 SourceRange 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
196 UnresolvedLookupExpr *
197 UnresolvedLookupExpr::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   void *Mem = C.Allocate(sizeof(UnresolvedLookupExpr) +
208                          ASTTemplateKWAndArgsInfo::sizeFor(Args.size()));
209   return new (Mem) UnresolvedLookupExpr(C, NamingClass, QualifierLoc,
210                                         TemplateKWLoc, NameInfo,
211                                         ADL, /*Overload*/ true, &Args,
212                                         Begin, End, /*StdIsAssociated=*/false);
213 }
214 
215 UnresolvedLookupExpr *
216 UnresolvedLookupExpr::CreateEmpty(ASTContext &C,
217                                   bool HasTemplateKWAndArgsInfo,
218                                   unsigned NumTemplateArgs) {
219   std::size_t size = sizeof(UnresolvedLookupExpr);
220   if (HasTemplateKWAndArgsInfo)
221     size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
222 
223   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedLookupExpr>());
224   UnresolvedLookupExpr *E = new (Mem) UnresolvedLookupExpr(EmptyShell());
225   E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
226   return E;
227 }
228 
229 OverloadExpr::OverloadExpr(StmtClass K, ASTContext &C,
230                            NestedNameSpecifierLoc QualifierLoc,
231                            SourceLocation TemplateKWLoc,
232                            const DeclarationNameInfo &NameInfo,
233                            const TemplateArgumentListInfo *TemplateArgs,
234                            UnresolvedSetIterator Begin,
235                            UnresolvedSetIterator End,
236                            bool KnownDependent,
237                            bool KnownInstantiationDependent,
238                            bool KnownContainsUnexpandedParameterPack)
239   : Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
240          KnownDependent,
241          (KnownInstantiationDependent ||
242           NameInfo.isInstantiationDependent() ||
243           (QualifierLoc &&
244            QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
245          (KnownContainsUnexpandedParameterPack ||
246           NameInfo.containsUnexpandedParameterPack() ||
247           (QualifierLoc &&
248            QualifierLoc.getNestedNameSpecifier()
249                                       ->containsUnexpandedParameterPack()))),
250     Results(0), NumResults(End - Begin), NameInfo(NameInfo),
251     QualifierLoc(QualifierLoc),
252     HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid())
253 {
254   NumResults = End - Begin;
255   if (NumResults) {
256     // Determine whether this expression is type-dependent.
257     for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
258       if ((*I)->getDeclContext()->isDependentContext() ||
259           isa<UnresolvedUsingValueDecl>(*I)) {
260         ExprBits.TypeDependent = true;
261         ExprBits.ValueDependent = true;
262       }
263     }
264 
265     Results = static_cast<DeclAccessPair *>(
266                                 C.Allocate(sizeof(DeclAccessPair) * NumResults,
267                                            llvm::alignOf<DeclAccessPair>()));
268     memcpy(Results, &*Begin.getIterator(),
269            NumResults * sizeof(DeclAccessPair));
270   }
271 
272   // If we have explicit template arguments, check for dependent
273   // template arguments and whether they contain any unexpanded pack
274   // expansions.
275   if (TemplateArgs) {
276     bool Dependent = false;
277     bool InstantiationDependent = false;
278     bool ContainsUnexpandedParameterPack = false;
279     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
280                                                Dependent,
281                                                InstantiationDependent,
282                                                ContainsUnexpandedParameterPack);
283 
284     if (Dependent) {
285       ExprBits.TypeDependent = true;
286       ExprBits.ValueDependent = true;
287     }
288     if (InstantiationDependent)
289       ExprBits.InstantiationDependent = true;
290     if (ContainsUnexpandedParameterPack)
291       ExprBits.ContainsUnexpandedParameterPack = true;
292   } else if (TemplateKWLoc.isValid()) {
293     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
294   }
295 
296   if (isTypeDependent())
297     setType(C.DependentTy);
298 }
299 
300 void OverloadExpr::initializeResults(ASTContext &C,
301                                      UnresolvedSetIterator Begin,
302                                      UnresolvedSetIterator End) {
303   assert(Results == 0 && "Results already initialized!");
304   NumResults = End - Begin;
305   if (NumResults) {
306      Results = static_cast<DeclAccessPair *>(
307                                C.Allocate(sizeof(DeclAccessPair) * NumResults,
308 
309                                           llvm::alignOf<DeclAccessPair>()));
310      memcpy(Results, &*Begin.getIterator(),
311             NumResults * sizeof(DeclAccessPair));
312   }
313 }
314 
315 CXXRecordDecl *OverloadExpr::getNamingClass() const {
316   if (isa<UnresolvedLookupExpr>(this))
317     return cast<UnresolvedLookupExpr>(this)->getNamingClass();
318   else
319     return cast<UnresolvedMemberExpr>(this)->getNamingClass();
320 }
321 
322 // DependentScopeDeclRefExpr
323 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(QualType T,
324                             NestedNameSpecifierLoc QualifierLoc,
325                             SourceLocation TemplateKWLoc,
326                             const DeclarationNameInfo &NameInfo,
327                             const TemplateArgumentListInfo *Args)
328   : Expr(DependentScopeDeclRefExprClass, T, VK_LValue, OK_Ordinary,
329          true, true,
330          (NameInfo.isInstantiationDependent() ||
331           (QualifierLoc &&
332            QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())),
333          (NameInfo.containsUnexpandedParameterPack() ||
334           (QualifierLoc &&
335            QualifierLoc.getNestedNameSpecifier()
336                             ->containsUnexpandedParameterPack()))),
337     QualifierLoc(QualifierLoc), NameInfo(NameInfo),
338     HasTemplateKWAndArgsInfo(Args != 0 || TemplateKWLoc.isValid())
339 {
340   if (Args) {
341     bool Dependent = true;
342     bool InstantiationDependent = true;
343     bool ContainsUnexpandedParameterPack
344       = ExprBits.ContainsUnexpandedParameterPack;
345     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *Args,
346                                                Dependent,
347                                                InstantiationDependent,
348                                                ContainsUnexpandedParameterPack);
349     ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
350   } else if (TemplateKWLoc.isValid()) {
351     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
352   }
353 }
354 
355 DependentScopeDeclRefExpr *
356 DependentScopeDeclRefExpr::Create(ASTContext &C,
357                                   NestedNameSpecifierLoc QualifierLoc,
358                                   SourceLocation TemplateKWLoc,
359                                   const DeclarationNameInfo &NameInfo,
360                                   const TemplateArgumentListInfo *Args) {
361   std::size_t size = sizeof(DependentScopeDeclRefExpr);
362   if (Args)
363     size += ASTTemplateKWAndArgsInfo::sizeFor(Args->size());
364   else if (TemplateKWLoc.isValid())
365     size += ASTTemplateKWAndArgsInfo::sizeFor(0);
366   void *Mem = C.Allocate(size);
367   return new (Mem) DependentScopeDeclRefExpr(C.DependentTy, QualifierLoc,
368                                              TemplateKWLoc, NameInfo, Args);
369 }
370 
371 DependentScopeDeclRefExpr *
372 DependentScopeDeclRefExpr::CreateEmpty(ASTContext &C,
373                                        bool HasTemplateKWAndArgsInfo,
374                                        unsigned NumTemplateArgs) {
375   std::size_t size = sizeof(DependentScopeDeclRefExpr);
376   if (HasTemplateKWAndArgsInfo)
377     size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
378   void *Mem = C.Allocate(size);
379   DependentScopeDeclRefExpr *E
380     = new (Mem) DependentScopeDeclRefExpr(QualType(), NestedNameSpecifierLoc(),
381                                           SourceLocation(),
382                                           DeclarationNameInfo(), 0);
383   E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
384   return E;
385 }
386 
387 SourceRange CXXConstructExpr::getSourceRange() const {
388   if (isa<CXXTemporaryObjectExpr>(this))
389     return cast<CXXTemporaryObjectExpr>(this)->getSourceRange();
390 
391   if (ParenRange.isValid())
392     return SourceRange(Loc, ParenRange.getEnd());
393 
394   SourceLocation End = Loc;
395   for (unsigned I = getNumArgs(); I > 0; --I) {
396     const Expr *Arg = getArg(I-1);
397     if (!Arg->isDefaultArgument()) {
398       SourceLocation NewEnd = Arg->getLocEnd();
399       if (NewEnd.isValid()) {
400         End = NewEnd;
401         break;
402       }
403     }
404   }
405 
406   return SourceRange(Loc, End);
407 }
408 
409 SourceRange CXXOperatorCallExpr::getSourceRange() const {
410   OverloadedOperatorKind Kind = getOperator();
411   if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
412     if (getNumArgs() == 1)
413       // Prefix operator
414       return SourceRange(getOperatorLoc(),
415                          getArg(0)->getSourceRange().getEnd());
416     else
417       // Postfix operator
418       return SourceRange(getArg(0)->getSourceRange().getBegin(),
419                          getOperatorLoc());
420   } else if (Kind == OO_Arrow) {
421     return getArg(0)->getSourceRange();
422   } else if (Kind == OO_Call) {
423     return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
424   } else if (Kind == OO_Subscript) {
425     return SourceRange(getArg(0)->getSourceRange().getBegin(), getRParenLoc());
426   } else if (getNumArgs() == 1) {
427     return SourceRange(getOperatorLoc(), getArg(0)->getSourceRange().getEnd());
428   } else if (getNumArgs() == 2) {
429     return SourceRange(getArg(0)->getSourceRange().getBegin(),
430                        getArg(1)->getSourceRange().getEnd());
431   } else {
432     return SourceRange();
433   }
434 }
435 
436 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
437   if (const MemberExpr *MemExpr =
438         dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
439     return MemExpr->getBase();
440 
441   // FIXME: Will eventually need to cope with member pointers.
442   return 0;
443 }
444 
445 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
446   if (const MemberExpr *MemExpr =
447       dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
448     return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
449 
450   // FIXME: Will eventually need to cope with member pointers.
451   return 0;
452 }
453 
454 
455 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() {
456   Expr* ThisArg = getImplicitObjectArgument();
457   if (!ThisArg)
458     return 0;
459 
460   if (ThisArg->getType()->isAnyPointerType())
461     return ThisArg->getType()->getPointeeType()->getAsCXXRecordDecl();
462 
463   return ThisArg->getType()->getAsCXXRecordDecl();
464 }
465 
466 
467 //===----------------------------------------------------------------------===//
468 //  Named casts
469 //===----------------------------------------------------------------------===//
470 
471 /// getCastName - Get the name of the C++ cast being used, e.g.,
472 /// "static_cast", "dynamic_cast", "reinterpret_cast", or
473 /// "const_cast". The returned pointer must not be freed.
474 const char *CXXNamedCastExpr::getCastName() const {
475   switch (getStmtClass()) {
476   case CXXStaticCastExprClass:      return "static_cast";
477   case CXXDynamicCastExprClass:     return "dynamic_cast";
478   case CXXReinterpretCastExprClass: return "reinterpret_cast";
479   case CXXConstCastExprClass:       return "const_cast";
480   default:                          return "<invalid cast>";
481   }
482 }
483 
484 CXXStaticCastExpr *CXXStaticCastExpr::Create(ASTContext &C, QualType T,
485                                              ExprValueKind VK,
486                                              CastKind K, Expr *Op,
487                                              const CXXCastPath *BasePath,
488                                              TypeSourceInfo *WrittenTy,
489                                              SourceLocation L,
490                                              SourceLocation RParenLoc) {
491   unsigned PathSize = (BasePath ? BasePath->size() : 0);
492   void *Buffer = C.Allocate(sizeof(CXXStaticCastExpr)
493                             + PathSize * sizeof(CXXBaseSpecifier*));
494   CXXStaticCastExpr *E =
495     new (Buffer) CXXStaticCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
496                                    RParenLoc);
497   if (PathSize) E->setCastPath(*BasePath);
498   return E;
499 }
500 
501 CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext &C,
502                                                   unsigned PathSize) {
503   void *Buffer =
504     C.Allocate(sizeof(CXXStaticCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
505   return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize);
506 }
507 
508 CXXDynamicCastExpr *CXXDynamicCastExpr::Create(ASTContext &C, QualType T,
509                                                ExprValueKind VK,
510                                                CastKind K, Expr *Op,
511                                                const CXXCastPath *BasePath,
512                                                TypeSourceInfo *WrittenTy,
513                                                SourceLocation L,
514                                                SourceLocation RParenLoc) {
515   unsigned PathSize = (BasePath ? BasePath->size() : 0);
516   void *Buffer = C.Allocate(sizeof(CXXDynamicCastExpr)
517                             + PathSize * sizeof(CXXBaseSpecifier*));
518   CXXDynamicCastExpr *E =
519     new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
520                                     RParenLoc);
521   if (PathSize) E->setCastPath(*BasePath);
522   return E;
523 }
524 
525 CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext &C,
526                                                     unsigned PathSize) {
527   void *Buffer =
528     C.Allocate(sizeof(CXXDynamicCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
529   return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
530 }
531 
532 /// isAlwaysNull - Return whether the result of the dynamic_cast is proven
533 /// to always be null. For example:
534 ///
535 /// struct A { };
536 /// struct B final : A { };
537 /// struct C { };
538 ///
539 /// C *f(B* b) { return dynamic_cast<C*>(b); }
540 bool CXXDynamicCastExpr::isAlwaysNull() const
541 {
542   QualType SrcType = getSubExpr()->getType();
543   QualType DestType = getType();
544 
545   if (const PointerType *SrcPTy = SrcType->getAs<PointerType>()) {
546     SrcType = SrcPTy->getPointeeType();
547     DestType = DestType->castAs<PointerType>()->getPointeeType();
548   }
549 
550   const CXXRecordDecl *SrcRD =
551     cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
552 
553   if (!SrcRD->hasAttr<FinalAttr>())
554     return false;
555 
556   const CXXRecordDecl *DestRD =
557     cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
558 
559   return !DestRD->isDerivedFrom(SrcRD);
560 }
561 
562 CXXReinterpretCastExpr *
563 CXXReinterpretCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
564                                CastKind K, Expr *Op,
565                                const CXXCastPath *BasePath,
566                                TypeSourceInfo *WrittenTy, SourceLocation L,
567                                SourceLocation RParenLoc) {
568   unsigned PathSize = (BasePath ? BasePath->size() : 0);
569   void *Buffer =
570     C.Allocate(sizeof(CXXReinterpretCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
571   CXXReinterpretCastExpr *E =
572     new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
573                                         RParenLoc);
574   if (PathSize) E->setCastPath(*BasePath);
575   return E;
576 }
577 
578 CXXReinterpretCastExpr *
579 CXXReinterpretCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
580   void *Buffer = C.Allocate(sizeof(CXXReinterpretCastExpr)
581                             + PathSize * sizeof(CXXBaseSpecifier*));
582   return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
583 }
584 
585 CXXConstCastExpr *CXXConstCastExpr::Create(ASTContext &C, QualType T,
586                                            ExprValueKind VK, Expr *Op,
587                                            TypeSourceInfo *WrittenTy,
588                                            SourceLocation L,
589                                            SourceLocation RParenLoc) {
590   return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc);
591 }
592 
593 CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext &C) {
594   return new (C) CXXConstCastExpr(EmptyShell());
595 }
596 
597 CXXFunctionalCastExpr *
598 CXXFunctionalCastExpr::Create(ASTContext &C, QualType T, ExprValueKind VK,
599                               TypeSourceInfo *Written, SourceLocation L,
600                               CastKind K, Expr *Op, const CXXCastPath *BasePath,
601                                SourceLocation R) {
602   unsigned PathSize = (BasePath ? BasePath->size() : 0);
603   void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
604                             + PathSize * sizeof(CXXBaseSpecifier*));
605   CXXFunctionalCastExpr *E =
606     new (Buffer) CXXFunctionalCastExpr(T, VK, Written, L, K, Op, PathSize, R);
607   if (PathSize) E->setCastPath(*BasePath);
608   return E;
609 }
610 
611 CXXFunctionalCastExpr *
612 CXXFunctionalCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
613   void *Buffer = C.Allocate(sizeof(CXXFunctionalCastExpr)
614                             + PathSize * sizeof(CXXBaseSpecifier*));
615   return new (Buffer) CXXFunctionalCastExpr(EmptyShell(), PathSize);
616 }
617 
618 
619 CXXDefaultArgExpr *
620 CXXDefaultArgExpr::Create(ASTContext &C, SourceLocation Loc,
621                           ParmVarDecl *Param, Expr *SubExpr) {
622   void *Mem = C.Allocate(sizeof(CXXDefaultArgExpr) + sizeof(Stmt *));
623   return new (Mem) CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param,
624                                      SubExpr);
625 }
626 
627 CXXTemporary *CXXTemporary::Create(ASTContext &C,
628                                    const CXXDestructorDecl *Destructor) {
629   return new (C) CXXTemporary(Destructor);
630 }
631 
632 CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext &C,
633                                                    CXXTemporary *Temp,
634                                                    Expr* SubExpr) {
635   assert((SubExpr->getType()->isRecordType() ||
636           SubExpr->getType()->isArrayType()) &&
637          "Expression bound to a temporary must have record or array type!");
638 
639   return new (C) CXXBindTemporaryExpr(Temp, SubExpr);
640 }
641 
642 CXXTemporaryObjectExpr::CXXTemporaryObjectExpr(ASTContext &C,
643                                                CXXConstructorDecl *Cons,
644                                                TypeSourceInfo *Type,
645                                                Expr **Args,
646                                                unsigned NumArgs,
647                                                SourceRange parenRange,
648                                                bool HadMultipleCandidates,
649                                                bool ZeroInitialization)
650   : CXXConstructExpr(C, CXXTemporaryObjectExprClass,
651                      Type->getType().getNonReferenceType(),
652                      Type->getTypeLoc().getBeginLoc(),
653                      Cons, false, Args, NumArgs,
654                      HadMultipleCandidates, ZeroInitialization,
655                      CXXConstructExpr::CK_Complete, parenRange),
656     Type(Type) {
657 }
658 
659 SourceRange CXXTemporaryObjectExpr::getSourceRange() const {
660   return SourceRange(Type->getTypeLoc().getBeginLoc(),
661                      getParenRange().getEnd());
662 }
663 
664 CXXConstructExpr *CXXConstructExpr::Create(ASTContext &C, QualType T,
665                                            SourceLocation Loc,
666                                            CXXConstructorDecl *D, bool Elidable,
667                                            Expr **Args, unsigned NumArgs,
668                                            bool HadMultipleCandidates,
669                                            bool ZeroInitialization,
670                                            ConstructionKind ConstructKind,
671                                            SourceRange ParenRange) {
672   return new (C) CXXConstructExpr(C, CXXConstructExprClass, T, Loc, D,
673                                   Elidable, Args, NumArgs,
674                                   HadMultipleCandidates, ZeroInitialization,
675                                   ConstructKind, ParenRange);
676 }
677 
678 CXXConstructExpr::CXXConstructExpr(ASTContext &C, StmtClass SC, QualType T,
679                                    SourceLocation Loc,
680                                    CXXConstructorDecl *D, bool elidable,
681                                    Expr **args, unsigned numargs,
682                                    bool HadMultipleCandidates,
683                                    bool ZeroInitialization,
684                                    ConstructionKind ConstructKind,
685                                    SourceRange ParenRange)
686   : Expr(SC, T, VK_RValue, OK_Ordinary,
687          T->isDependentType(), T->isDependentType(),
688          T->isInstantiationDependentType(),
689          T->containsUnexpandedParameterPack()),
690     Constructor(D), Loc(Loc), ParenRange(ParenRange),  NumArgs(numargs),
691     Elidable(elidable), HadMultipleCandidates(HadMultipleCandidates),
692     ZeroInitialization(ZeroInitialization),
693     ConstructKind(ConstructKind), Args(0)
694 {
695   if (NumArgs) {
696     Args = new (C) Stmt*[NumArgs];
697 
698     for (unsigned i = 0; i != NumArgs; ++i) {
699       assert(args[i] && "NULL argument in CXXConstructExpr");
700 
701       if (args[i]->isValueDependent())
702         ExprBits.ValueDependent = true;
703       if (args[i]->isInstantiationDependent())
704         ExprBits.InstantiationDependent = true;
705       if (args[i]->containsUnexpandedParameterPack())
706         ExprBits.ContainsUnexpandedParameterPack = true;
707 
708       Args[i] = args[i];
709     }
710   }
711 }
712 
713 ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
714                                    ArrayRef<CleanupObject> objects)
715   : Expr(ExprWithCleanupsClass, subexpr->getType(),
716          subexpr->getValueKind(), subexpr->getObjectKind(),
717          subexpr->isTypeDependent(), subexpr->isValueDependent(),
718          subexpr->isInstantiationDependent(),
719          subexpr->containsUnexpandedParameterPack()),
720     SubExpr(subexpr) {
721   ExprWithCleanupsBits.NumObjects = objects.size();
722   for (unsigned i = 0, e = objects.size(); i != e; ++i)
723     getObjectsBuffer()[i] = objects[i];
724 }
725 
726 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, Expr *subexpr,
727                                            ArrayRef<CleanupObject> objects) {
728   size_t size = sizeof(ExprWithCleanups)
729               + objects.size() * sizeof(CleanupObject);
730   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
731   return new (buffer) ExprWithCleanups(subexpr, objects);
732 }
733 
734 ExprWithCleanups::ExprWithCleanups(EmptyShell empty, unsigned numObjects)
735   : Expr(ExprWithCleanupsClass, empty) {
736   ExprWithCleanupsBits.NumObjects = numObjects;
737 }
738 
739 ExprWithCleanups *ExprWithCleanups::Create(ASTContext &C, EmptyShell empty,
740                                            unsigned numObjects) {
741   size_t size = sizeof(ExprWithCleanups) + numObjects * sizeof(CleanupObject);
742   void *buffer = C.Allocate(size, llvm::alignOf<ExprWithCleanups>());
743   return new (buffer) ExprWithCleanups(empty, numObjects);
744 }
745 
746 CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(TypeSourceInfo *Type,
747                                                  SourceLocation LParenLoc,
748                                                  Expr **Args,
749                                                  unsigned NumArgs,
750                                                  SourceLocation RParenLoc)
751   : Expr(CXXUnresolvedConstructExprClass,
752          Type->getType().getNonReferenceType(),
753          (Type->getType()->isLValueReferenceType() ? VK_LValue
754           :Type->getType()->isRValueReferenceType()? VK_XValue
755           :VK_RValue),
756          OK_Ordinary,
757          Type->getType()->isDependentType(), true, true,
758          Type->getType()->containsUnexpandedParameterPack()),
759     Type(Type),
760     LParenLoc(LParenLoc),
761     RParenLoc(RParenLoc),
762     NumArgs(NumArgs) {
763   Stmt **StoredArgs = reinterpret_cast<Stmt **>(this + 1);
764   for (unsigned I = 0; I != NumArgs; ++I) {
765     if (Args[I]->containsUnexpandedParameterPack())
766       ExprBits.ContainsUnexpandedParameterPack = true;
767 
768     StoredArgs[I] = Args[I];
769   }
770 }
771 
772 CXXUnresolvedConstructExpr *
773 CXXUnresolvedConstructExpr::Create(ASTContext &C,
774                                    TypeSourceInfo *Type,
775                                    SourceLocation LParenLoc,
776                                    Expr **Args,
777                                    unsigned NumArgs,
778                                    SourceLocation RParenLoc) {
779   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
780                          sizeof(Expr *) * NumArgs);
781   return new (Mem) CXXUnresolvedConstructExpr(Type, LParenLoc,
782                                               Args, NumArgs, RParenLoc);
783 }
784 
785 CXXUnresolvedConstructExpr *
786 CXXUnresolvedConstructExpr::CreateEmpty(ASTContext &C, unsigned NumArgs) {
787   Stmt::EmptyShell Empty;
788   void *Mem = C.Allocate(sizeof(CXXUnresolvedConstructExpr) +
789                          sizeof(Expr *) * NumArgs);
790   return new (Mem) CXXUnresolvedConstructExpr(Empty, NumArgs);
791 }
792 
793 SourceRange CXXUnresolvedConstructExpr::getSourceRange() const {
794   return SourceRange(Type->getTypeLoc().getBeginLoc(), RParenLoc);
795 }
796 
797 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
798                                                  Expr *Base, QualType BaseType,
799                                                  bool IsArrow,
800                                                  SourceLocation OperatorLoc,
801                                           NestedNameSpecifierLoc QualifierLoc,
802                                           SourceLocation TemplateKWLoc,
803                                           NamedDecl *FirstQualifierFoundInScope,
804                                           DeclarationNameInfo MemberNameInfo,
805                                    const TemplateArgumentListInfo *TemplateArgs)
806   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
807          VK_LValue, OK_Ordinary, true, true, true,
808          ((Base && Base->containsUnexpandedParameterPack()) ||
809           (QualifierLoc &&
810            QualifierLoc.getNestedNameSpecifier()
811                                        ->containsUnexpandedParameterPack()) ||
812           MemberNameInfo.containsUnexpandedParameterPack())),
813     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
814     HasTemplateKWAndArgsInfo(TemplateArgs != 0 || TemplateKWLoc.isValid()),
815     OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
816     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
817     MemberNameInfo(MemberNameInfo) {
818   if (TemplateArgs) {
819     bool Dependent = true;
820     bool InstantiationDependent = true;
821     bool ContainsUnexpandedParameterPack = false;
822     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
823                                                Dependent,
824                                                InstantiationDependent,
825                                                ContainsUnexpandedParameterPack);
826     if (ContainsUnexpandedParameterPack)
827       ExprBits.ContainsUnexpandedParameterPack = true;
828   } else if (TemplateKWLoc.isValid()) {
829     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
830   }
831 }
832 
833 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(ASTContext &C,
834                           Expr *Base, QualType BaseType,
835                           bool IsArrow,
836                           SourceLocation OperatorLoc,
837                           NestedNameSpecifierLoc QualifierLoc,
838                           NamedDecl *FirstQualifierFoundInScope,
839                           DeclarationNameInfo MemberNameInfo)
840   : Expr(CXXDependentScopeMemberExprClass, C.DependentTy,
841          VK_LValue, OK_Ordinary, true, true, true,
842          ((Base && Base->containsUnexpandedParameterPack()) ||
843           (QualifierLoc &&
844            QualifierLoc.getNestedNameSpecifier()->
845                                          containsUnexpandedParameterPack()) ||
846           MemberNameInfo.containsUnexpandedParameterPack())),
847     Base(Base), BaseType(BaseType), IsArrow(IsArrow),
848     HasTemplateKWAndArgsInfo(false),
849     OperatorLoc(OperatorLoc), QualifierLoc(QualifierLoc),
850     FirstQualifierFoundInScope(FirstQualifierFoundInScope),
851     MemberNameInfo(MemberNameInfo) { }
852 
853 CXXDependentScopeMemberExpr *
854 CXXDependentScopeMemberExpr::Create(ASTContext &C,
855                                 Expr *Base, QualType BaseType, bool IsArrow,
856                                 SourceLocation OperatorLoc,
857                                 NestedNameSpecifierLoc QualifierLoc,
858                                 SourceLocation TemplateKWLoc,
859                                 NamedDecl *FirstQualifierFoundInScope,
860                                 DeclarationNameInfo MemberNameInfo,
861                                 const TemplateArgumentListInfo *TemplateArgs) {
862   if (!TemplateArgs && !TemplateKWLoc.isValid())
863     return new (C) CXXDependentScopeMemberExpr(C, Base, BaseType,
864                                                IsArrow, OperatorLoc,
865                                                QualifierLoc,
866                                                FirstQualifierFoundInScope,
867                                                MemberNameInfo);
868 
869   unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
870   std::size_t size = sizeof(CXXDependentScopeMemberExpr)
871     + ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
872 
873   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
874   return new (Mem) CXXDependentScopeMemberExpr(C, Base, BaseType,
875                                                IsArrow, OperatorLoc,
876                                                QualifierLoc,
877                                                TemplateKWLoc,
878                                                FirstQualifierFoundInScope,
879                                                MemberNameInfo, TemplateArgs);
880 }
881 
882 CXXDependentScopeMemberExpr *
883 CXXDependentScopeMemberExpr::CreateEmpty(ASTContext &C,
884                                          bool HasTemplateKWAndArgsInfo,
885                                          unsigned NumTemplateArgs) {
886   if (!HasTemplateKWAndArgsInfo)
887     return new (C) CXXDependentScopeMemberExpr(C, 0, QualType(),
888                                                0, SourceLocation(),
889                                                NestedNameSpecifierLoc(), 0,
890                                                DeclarationNameInfo());
891 
892   std::size_t size = sizeof(CXXDependentScopeMemberExpr) +
893                      ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
894   void *Mem = C.Allocate(size, llvm::alignOf<CXXDependentScopeMemberExpr>());
895   CXXDependentScopeMemberExpr *E
896     =  new (Mem) CXXDependentScopeMemberExpr(C, 0, QualType(),
897                                              0, SourceLocation(),
898                                              NestedNameSpecifierLoc(),
899                                              SourceLocation(), 0,
900                                              DeclarationNameInfo(), 0);
901   E->HasTemplateKWAndArgsInfo = true;
902   return E;
903 }
904 
905 bool CXXDependentScopeMemberExpr::isImplicitAccess() const {
906   if (Base == 0)
907     return true;
908 
909   return cast<Expr>(Base)->isImplicitCXXThis();
910 }
911 
912 static bool hasOnlyNonStaticMemberFunctions(UnresolvedSetIterator begin,
913                                             UnresolvedSetIterator end) {
914   do {
915     NamedDecl *decl = *begin;
916     if (isa<UnresolvedUsingValueDecl>(decl))
917       return false;
918     if (isa<UsingShadowDecl>(decl))
919       decl = cast<UsingShadowDecl>(decl)->getUnderlyingDecl();
920 
921     // Unresolved member expressions should only contain methods and
922     // method templates.
923     assert(isa<CXXMethodDecl>(decl) || isa<FunctionTemplateDecl>(decl));
924 
925     if (isa<FunctionTemplateDecl>(decl))
926       decl = cast<FunctionTemplateDecl>(decl)->getTemplatedDecl();
927     if (cast<CXXMethodDecl>(decl)->isStatic())
928       return false;
929   } while (++begin != end);
930 
931   return true;
932 }
933 
934 UnresolvedMemberExpr::UnresolvedMemberExpr(ASTContext &C,
935                                            bool HasUnresolvedUsing,
936                                            Expr *Base, QualType BaseType,
937                                            bool IsArrow,
938                                            SourceLocation OperatorLoc,
939                                            NestedNameSpecifierLoc QualifierLoc,
940                                            SourceLocation TemplateKWLoc,
941                                    const DeclarationNameInfo &MemberNameInfo,
942                                    const TemplateArgumentListInfo *TemplateArgs,
943                                            UnresolvedSetIterator Begin,
944                                            UnresolvedSetIterator End)
945   : OverloadExpr(UnresolvedMemberExprClass, C, QualifierLoc, TemplateKWLoc,
946                  MemberNameInfo, TemplateArgs, Begin, End,
947                  // Dependent
948                  ((Base && Base->isTypeDependent()) ||
949                   BaseType->isDependentType()),
950                  ((Base && Base->isInstantiationDependent()) ||
951                    BaseType->isInstantiationDependentType()),
952                  // Contains unexpanded parameter pack
953                  ((Base && Base->containsUnexpandedParameterPack()) ||
954                   BaseType->containsUnexpandedParameterPack())),
955     IsArrow(IsArrow), HasUnresolvedUsing(HasUnresolvedUsing),
956     Base(Base), BaseType(BaseType), OperatorLoc(OperatorLoc) {
957 
958   // Check whether all of the members are non-static member functions,
959   // and if so, mark give this bound-member type instead of overload type.
960   if (hasOnlyNonStaticMemberFunctions(Begin, End))
961     setType(C.BoundMemberTy);
962 }
963 
964 bool UnresolvedMemberExpr::isImplicitAccess() const {
965   if (Base == 0)
966     return true;
967 
968   return cast<Expr>(Base)->isImplicitCXXThis();
969 }
970 
971 UnresolvedMemberExpr *
972 UnresolvedMemberExpr::Create(ASTContext &C,
973                              bool HasUnresolvedUsing,
974                              Expr *Base, QualType BaseType, bool IsArrow,
975                              SourceLocation OperatorLoc,
976                              NestedNameSpecifierLoc QualifierLoc,
977                              SourceLocation TemplateKWLoc,
978                              const DeclarationNameInfo &MemberNameInfo,
979                              const TemplateArgumentListInfo *TemplateArgs,
980                              UnresolvedSetIterator Begin,
981                              UnresolvedSetIterator End) {
982   std::size_t size = sizeof(UnresolvedMemberExpr);
983   if (TemplateArgs)
984     size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
985   else if (TemplateKWLoc.isValid())
986     size += ASTTemplateKWAndArgsInfo::sizeFor(0);
987 
988   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
989   return new (Mem) UnresolvedMemberExpr(C,
990                              HasUnresolvedUsing, Base, BaseType,
991                              IsArrow, OperatorLoc, QualifierLoc, TemplateKWLoc,
992                              MemberNameInfo, TemplateArgs, Begin, End);
993 }
994 
995 UnresolvedMemberExpr *
996 UnresolvedMemberExpr::CreateEmpty(ASTContext &C, bool HasTemplateKWAndArgsInfo,
997                                   unsigned NumTemplateArgs) {
998   std::size_t size = sizeof(UnresolvedMemberExpr);
999   if (HasTemplateKWAndArgsInfo)
1000     size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
1001 
1002   void *Mem = C.Allocate(size, llvm::alignOf<UnresolvedMemberExpr>());
1003   UnresolvedMemberExpr *E = new (Mem) UnresolvedMemberExpr(EmptyShell());
1004   E->HasTemplateKWAndArgsInfo = HasTemplateKWAndArgsInfo;
1005   return E;
1006 }
1007 
1008 CXXRecordDecl *UnresolvedMemberExpr::getNamingClass() const {
1009   // Unlike for UnresolvedLookupExpr, it is very easy to re-derive this.
1010 
1011   // If there was a nested name specifier, it names the naming class.
1012   // It can't be dependent: after all, we were actually able to do the
1013   // lookup.
1014   CXXRecordDecl *Record = 0;
1015   if (getQualifier()) {
1016     const Type *T = getQualifier()->getAsType();
1017     assert(T && "qualifier in member expression does not name type");
1018     Record = T->getAsCXXRecordDecl();
1019     assert(Record && "qualifier in member expression does not name record");
1020   }
1021   // Otherwise the naming class must have been the base class.
1022   else {
1023     QualType BaseType = getBaseType().getNonReferenceType();
1024     if (isArrow()) {
1025       const PointerType *PT = BaseType->getAs<PointerType>();
1026       assert(PT && "base of arrow member access is not pointer");
1027       BaseType = PT->getPointeeType();
1028     }
1029 
1030     Record = BaseType->getAsCXXRecordDecl();
1031     assert(Record && "base of member expression does not name record");
1032   }
1033 
1034   return Record;
1035 }
1036 
1037 SubstNonTypeTemplateParmPackExpr::
1038 SubstNonTypeTemplateParmPackExpr(QualType T,
1039                                  NonTypeTemplateParmDecl *Param,
1040                                  SourceLocation NameLoc,
1041                                  const TemplateArgument &ArgPack)
1042   : Expr(SubstNonTypeTemplateParmPackExprClass, T, VK_RValue, OK_Ordinary,
1043          true, true, true, true),
1044     Param(Param), Arguments(ArgPack.pack_begin()),
1045     NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) { }
1046 
1047 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1048   return TemplateArgument(Arguments, NumArguments);
1049 }
1050 
1051 void ArrayTypeTraitExpr::anchor() { }
1052