contrib/llvm/tools/clang/lib/AST/ExprCXX.cpp

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