contrib/llvm/tools/clang/lib/Sema/SemaTemplateVariadic.cpp

   1 //===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/
   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 //  This file implements semantic analysis for C++0x variadic templates.
  10 //===----------------------------------------------------------------------===/
  11
  12 #include "clang/Sema/Sema.h"
  13 #include "clang/Sema/Lookup.h"
  14 #include "clang/Sema/ParsedTemplate.h"
  15 #include "clang/Sema/SemaInternal.h"
  16 #include "clang/Sema/Template.h"
  17 #include "clang/AST/Expr.h"
  18 #include "clang/AST/RecursiveASTVisitor.h"
  19 #include "clang/AST/TypeLoc.h"
  20
  21 using namespace clang;
  22
  23 //----------------------------------------------------------------------------
  24 // Visitor that collects unexpanded parameter packs
  25 //----------------------------------------------------------------------------
  26
  27 namespace {
  28   /// \brief A class that collects unexpanded parameter packs.
  29   class CollectUnexpandedParameterPacksVisitor :
  30     public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
  31   {
  32     typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
  33       inherited;
  34
  35     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;
  36
  37   public:
  38     explicit CollectUnexpandedParameterPacksVisitor(
  39                   SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
  40       : Unexpanded(Unexpanded) { }
  41
  42     bool shouldWalkTypesOfTypeLocs() const { return false; }
  43
  44     //------------------------------------------------------------------------
  45     // Recording occurrences of (unexpanded) parameter packs.
  46     //------------------------------------------------------------------------
  47
  48     /// \brief Record occurrences of template type parameter packs.
  49     bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
  50       if (TL.getTypePtr()->isParameterPack())
  51         Unexpanded.push_back(std::make_pair(TL.getTypePtr(), TL.getNameLoc()));
  52       return true;
  53     }
  54
  55     /// \brief Record occurrences of template type parameter packs
  56     /// when we don't have proper source-location information for
  57     /// them.
  58     ///
  59     /// Ideally, this routine would never be used.
  60     bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
  61       if (T->isParameterPack())
  62         Unexpanded.push_back(std::make_pair(T, SourceLocation()));
  63
  64       return true;
  65     }
  66
  67     /// \brief Record occurrences of function and non-type template
  68     /// parameter packs in an expression.
  69     bool VisitDeclRefExpr(DeclRefExpr *E) {
  70       if (E->getDecl()->isParameterPack())
  71         Unexpanded.push_back(std::make_pair(E->getDecl(), E->getLocation()));
  72
  73       return true;
  74     }
  75
  76     /// \brief Record occurrences of template template parameter packs.
  77     bool TraverseTemplateName(TemplateName Template) {
  78       if (TemplateTemplateParmDecl *TTP
  79             = dyn_cast_or_null<TemplateTemplateParmDecl>(
  80                                                   Template.getAsTemplateDecl()))
  81         if (TTP->isParameterPack())
  82           Unexpanded.push_back(std::make_pair(TTP, SourceLocation()));
  83
  84       return inherited::TraverseTemplateName(Template);
  85     }
  86
  87     /// \brief Suppress traversal into Objective-C container literal
  88     /// elements that are pack expansions.
  89     bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
  90       if (!E->containsUnexpandedParameterPack())
  91         return true;
  92
  93       for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
  94         ObjCDictionaryElement Element = E->getKeyValueElement(I);
  95         if (Element.isPackExpansion())
  96           continue;
  97
  98         TraverseStmt(Element.Key);
  99         TraverseStmt(Element.Value);
 100       }
 101       return true;
 102     }
 103     //------------------------------------------------------------------------
 104     // Pruning the search for unexpanded parameter packs.
 105     //------------------------------------------------------------------------
 106
 107     /// \brief Suppress traversal into statements and expressions that
 108     /// do not contain unexpanded parameter packs.
 109     bool TraverseStmt(Stmt *S) {
 110       if (Expr *E = dyn_cast_or_null<Expr>(S))
 111         if (E->containsUnexpandedParameterPack())
 112           return inherited::TraverseStmt(E);
 113
 114       return true;
 115     }
 116
 117     /// \brief Suppress traversal into types that do not contain
 118     /// unexpanded parameter packs.
 119     bool TraverseType(QualType T) {
 120       if (!T.isNull() && T->containsUnexpandedParameterPack())
 121         return inherited::TraverseType(T);
 122
 123       return true;
 124     }
 125
 126     /// \brief Suppress traversel into types with location information
 127     /// that do not contain unexpanded parameter packs.
 128     bool TraverseTypeLoc(TypeLoc TL) {
 129       if (!TL.getType().isNull() &&
 130           TL.getType()->containsUnexpandedParameterPack())
 131         return inherited::TraverseTypeLoc(TL);
 132
 133       return true;
 134     }
 135
 136     /// \brief Suppress traversal of non-parameter declarations, since
 137     /// they cannot contain unexpanded parameter packs.
 138     bool TraverseDecl(Decl *D) {
 139       if (D && isa<ParmVarDecl>(D))
 140         return inherited::TraverseDecl(D);
 141
 142       return true;
 143     }
 144
 145     /// \brief Suppress traversal of template argument pack expansions.
 146     bool TraverseTemplateArgument(const TemplateArgument &Arg) {
 147       if (Arg.isPackExpansion())
 148         return true;
 149
 150       return inherited::TraverseTemplateArgument(Arg);
 151     }
 152
 153     /// \brief Suppress traversal of template argument pack expansions.
 154     bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
 155       if (ArgLoc.getArgument().isPackExpansion())
 156         return true;
 157
 158       return inherited::TraverseTemplateArgumentLoc(ArgLoc);
 159     }
 160   };
 161 }
 162
 163 /// \brief Diagnose all of the unexpanded parameter packs in the given
 164 /// vector.
 165 void
 166 Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
 167                                        UnexpandedParameterPackContext UPPC,
 168                                  ArrayRef<UnexpandedParameterPack> Unexpanded) {
 169   if (Unexpanded.empty())
 170     return;
 171
 172   SmallVector<SourceLocation, 4> Locations;
 173   SmallVector<IdentifierInfo *, 4> Names;
 174   llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown;
 175
 176   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
 177     IdentifierInfo *Name = 0;
 178     if (const TemplateTypeParmType *TTP
 179           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>())
 180       Name = TTP->getIdentifier();
 181     else
 182       Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier();
 183
 184     if (Name && NamesKnown.insert(Name))
 185       Names.push_back(Name);
 186
 187     if (Unexpanded[I].second.isValid())
 188       Locations.push_back(Unexpanded[I].second);
 189   }
 190
 191   DiagnosticBuilder DB
 192     = Names.size() == 0? Diag(Loc, diag::err_unexpanded_parameter_pack_0)
 193                            << (int)UPPC
 194     : Names.size() == 1? Diag(Loc, diag::err_unexpanded_parameter_pack_1)
 195                            << (int)UPPC << Names[0]
 196     : Names.size() == 2? Diag(Loc, diag::err_unexpanded_parameter_pack_2)
 197                            << (int)UPPC << Names[0] << Names[1]
 198     : Diag(Loc, diag::err_unexpanded_parameter_pack_3_or_more)
 199         << (int)UPPC << Names[0] << Names[1];
 200
 201   for (unsigned I = 0, N = Locations.size(); I != N; ++I)
 202     DB << SourceRange(Locations[I]);
 203 }
 204
 205 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
 206                                            TypeSourceInfo *T,
 207                                          UnexpandedParameterPackContext UPPC) {
 208   // C++0x [temp.variadic]p5:
 209   //   An appearance of a name of a parameter pack that is not expanded is
 210   //   ill-formed.
 211   if (!T->getType()->containsUnexpandedParameterPack())
 212     return false;
 213
 214   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 215   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(
 216                                                               T->getTypeLoc());
 217   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 218   DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
 219   return true;
 220 }
 221
 222 bool Sema::DiagnoseUnexpandedParameterPack(Expr *E,
 223                                         UnexpandedParameterPackContext UPPC) {
 224   // C++0x [temp.variadic]p5:
 225   //   An appearance of a name of a parameter pack that is not expanded is
 226   //   ill-formed.
 227   if (!E->containsUnexpandedParameterPack())
 228     return false;
 229
 230   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 231   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
 232   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 233   DiagnoseUnexpandedParameterPacks(E->getLocStart(), UPPC, Unexpanded);
 234   return true;
 235 }
 236
 237 bool Sema::DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
 238                                         UnexpandedParameterPackContext UPPC) {
 239   // C++0x [temp.variadic]p5:
 240   //   An appearance of a name of a parameter pack that is not expanded is
 241   //   ill-formed.
 242   if (!SS.getScopeRep() ||
 243       !SS.getScopeRep()->containsUnexpandedParameterPack())
 244     return false;
 245
 246   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 247   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 248     .TraverseNestedNameSpecifier(SS.getScopeRep());
 249   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 250   DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(),
 251                                    UPPC, Unexpanded);
 252   return true;
 253 }
 254
 255 bool Sema::DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
 256                                          UnexpandedParameterPackContext UPPC) {
 257   // C++0x [temp.variadic]p5:
 258   //   An appearance of a name of a parameter pack that is not expanded is
 259   //   ill-formed.
 260   switch (NameInfo.getName().getNameKind()) {
 261   case DeclarationName::Identifier:
 262   case DeclarationName::ObjCZeroArgSelector:
 263   case DeclarationName::ObjCOneArgSelector:
 264   case DeclarationName::ObjCMultiArgSelector:
 265   case DeclarationName::CXXOperatorName:
 266   case DeclarationName::CXXLiteralOperatorName:
 267   case DeclarationName::CXXUsingDirective:
 268     return false;
 269
 270   case DeclarationName::CXXConstructorName:
 271   case DeclarationName::CXXDestructorName:
 272   case DeclarationName::CXXConversionFunctionName:
 273     // FIXME: We shouldn't need this null check!
 274     if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
 275       return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);
 276
 277     if (!NameInfo.getName().getCXXNameType()->containsUnexpandedParameterPack())
 278       return false;
 279
 280     break;
 281   }
 282
 283   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 284   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 285     .TraverseType(NameInfo.getName().getCXXNameType());
 286   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 287   DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
 288   return true;
 289 }
 290
 291 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
 292                                            TemplateName Template,
 293                                        UnexpandedParameterPackContext UPPC) {
 294
 295   if (Template.isNull() || !Template.containsUnexpandedParameterPack())
 296     return false;
 297
 298   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 299   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 300     .TraverseTemplateName(Template);
 301   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 302   DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
 303   return true;
 304 }
 305
 306 bool Sema::DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
 307                                          UnexpandedParameterPackContext UPPC) {
 308   if (Arg.getArgument().isNull() ||
 309       !Arg.getArgument().containsUnexpandedParameterPack())
 310     return false;
 311
 312   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 313   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 314     .TraverseTemplateArgumentLoc(Arg);
 315   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 316   DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
 317   return true;
 318 }
 319
 320 void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
 321                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 322   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 323     .TraverseTemplateArgument(Arg);
 324 }
 325
 326 void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
 327                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 328   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 329     .TraverseTemplateArgumentLoc(Arg);
 330 }
 331
 332 void Sema::collectUnexpandedParameterPacks(QualType T,
 333                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 334   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
 335 }
 336
 337 void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
 338                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 339   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
 340 }
 341
 342 void Sema::collectUnexpandedParameterPacks(CXXScopeSpec &SS,
 343                                            SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 344   NestedNameSpecifier *Qualifier = SS.getScopeRep();
 345   if (!Qualifier)
 346     return;
 347
 348   NestedNameSpecifierLoc QualifierLoc(Qualifier, SS.location_data());
 349   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 350     .TraverseNestedNameSpecifierLoc(QualifierLoc);
 351 }
 352
 353 void Sema::collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
 354                          SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 355   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 356     .TraverseDeclarationNameInfo(NameInfo);
 357 }
 358
 359
 360 ParsedTemplateArgument
 361 Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg,
 362                          SourceLocation EllipsisLoc) {
 363   if (Arg.isInvalid())
 364     return Arg;
 365
 366   switch (Arg.getKind()) {
 367   case ParsedTemplateArgument::Type: {
 368     TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
 369     if (Result.isInvalid())
 370       return ParsedTemplateArgument();
 371
 372     return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
 373                                   Arg.getLocation());
 374   }
 375
 376   case ParsedTemplateArgument::NonType: {
 377     ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
 378     if (Result.isInvalid())
 379       return ParsedTemplateArgument();
 380
 381     return ParsedTemplateArgument(Arg.getKind(), Result.get(),
 382                                   Arg.getLocation());
 383   }
 384
 385   case ParsedTemplateArgument::Template:
 386     if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) {
 387       SourceRange R(Arg.getLocation());
 388       if (Arg.getScopeSpec().isValid())
 389         R.setBegin(Arg.getScopeSpec().getBeginLoc());
 390       Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 391         << R;
 392       return ParsedTemplateArgument();
 393     }
 394
 395     return Arg.getTemplatePackExpansion(EllipsisLoc);
 396   }
 397   llvm_unreachable("Unhandled template argument kind?");
 398 }
 399
 400 TypeResult Sema::ActOnPackExpansion(ParsedType Type,
 401                                     SourceLocation EllipsisLoc) {
 402   TypeSourceInfo *TSInfo;
 403   GetTypeFromParser(Type, &TSInfo);
 404   if (!TSInfo)
 405     return true;
 406
 407   TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc,
 408                                                 llvm::Optional<unsigned>());
 409   if (!TSResult)
 410     return true;
 411
 412   return CreateParsedType(TSResult->getType(), TSResult);
 413 }
 414
 415 TypeSourceInfo *Sema::CheckPackExpansion(TypeSourceInfo *Pattern,
 416                                          SourceLocation EllipsisLoc,
 417                                        llvm::Optional<unsigned> NumExpansions) {
 418   // Create the pack expansion type and source-location information.
 419   QualType Result = CheckPackExpansion(Pattern->getType(),
 420                                        Pattern->getTypeLoc().getSourceRange(),
 421                                        EllipsisLoc, NumExpansions);
 422   if (Result.isNull())
 423     return 0;
 424
 425   TypeSourceInfo *TSResult = Context.CreateTypeSourceInfo(Result);
 426   PackExpansionTypeLoc TL = cast<PackExpansionTypeLoc>(TSResult->getTypeLoc());
 427   TL.setEllipsisLoc(EllipsisLoc);
 428
 429   // Copy over the source-location information from the type.
 430   memcpy(TL.getNextTypeLoc().getOpaqueData(),
 431          Pattern->getTypeLoc().getOpaqueData(),
 432          Pattern->getTypeLoc().getFullDataSize());
 433   return TSResult;
 434 }
 435
 436 QualType Sema::CheckPackExpansion(QualType Pattern,
 437                                   SourceRange PatternRange,
 438                                   SourceLocation EllipsisLoc,
 439                                   llvm::Optional<unsigned> NumExpansions) {
 440   // C++0x [temp.variadic]p5:
 441   //   The pattern of a pack expansion shall name one or more
 442   //   parameter packs that are not expanded by a nested pack
 443   //   expansion.
 444   if (!Pattern->containsUnexpandedParameterPack()) {
 445     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 446       << PatternRange;
 447     return QualType();
 448   }
 449
 450   return Context.getPackExpansionType(Pattern, NumExpansions);
 451 }
 452
 453 ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
 454   return CheckPackExpansion(Pattern, EllipsisLoc, llvm::Optional<unsigned>());
 455 }
 456
 457 ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
 458                                     llvm::Optional<unsigned> NumExpansions) {
 459   if (!Pattern)
 460     return ExprError();
 461
 462   // C++0x [temp.variadic]p5:
 463   //   The pattern of a pack expansion shall name one or more
 464   //   parameter packs that are not expanded by a nested pack
 465   //   expansion.
 466   if (!Pattern->containsUnexpandedParameterPack()) {
 467     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 468     << Pattern->getSourceRange();
 469     return ExprError();
 470   }
 471
 472   // Create the pack expansion expression and source-location information.
 473   return Owned(new (Context) PackExpansionExpr(Context.DependentTy, Pattern,
 474                                                EllipsisLoc, NumExpansions));
 475 }
 476
 477 /// \brief Retrieve the depth and index of a parameter pack.
 478 static std::pair<unsigned, unsigned>
 479 getDepthAndIndex(NamedDecl *ND) {
 480   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
 481     return std::make_pair(TTP->getDepth(), TTP->getIndex());
 482
 483   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
 484     return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
 485
 486   TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
 487   return std::make_pair(TTP->getDepth(), TTP->getIndex());
 488 }
 489
 490 bool Sema::CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
 491                                            SourceRange PatternRange,
 492                                    ArrayRef<UnexpandedParameterPack> Unexpanded,
 493                              const MultiLevelTemplateArgumentList &TemplateArgs,
 494                                            bool &ShouldExpand,
 495                                            bool &RetainExpansion,
 496                                      llvm::Optional<unsigned> &NumExpansions) {
 497   ShouldExpand = true;
 498   RetainExpansion = false;
 499   std::pair<IdentifierInfo *, SourceLocation> FirstPack;
 500   bool HaveFirstPack = false;
 501
 502   for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
 503                                                  end = Unexpanded.end();
 504                                                   i != end; ++i) {
 505     // Compute the depth and index for this parameter pack.
 506     unsigned Depth = 0, Index = 0;
 507     IdentifierInfo *Name;
 508     bool IsFunctionParameterPack = false;
 509
 510     if (const TemplateTypeParmType *TTP
 511         = i->first.dyn_cast<const TemplateTypeParmType *>()) {
 512       Depth = TTP->getDepth();
 513       Index = TTP->getIndex();
 514       Name = TTP->getIdentifier();
 515     } else {
 516       NamedDecl *ND = i->first.get<NamedDecl *>();
 517       if (isa<ParmVarDecl>(ND))
 518         IsFunctionParameterPack = true;
 519       else
 520         llvm::tie(Depth, Index) = getDepthAndIndex(ND);
 521
 522       Name = ND->getIdentifier();
 523     }
 524
 525     // Determine the size of this argument pack.
 526     unsigned NewPackSize;
 527     if (IsFunctionParameterPack) {
 528       // Figure out whether we're instantiating to an argument pack or not.
 529       typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 530
 531       llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 532         = CurrentInstantiationScope->findInstantiationOf(
 533                                         i->first.get<NamedDecl *>());
 534       if (Instantiation->is<DeclArgumentPack *>()) {
 535         // We could expand this function parameter pack.
 536         NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
 537       } else {
 538         // We can't expand this function parameter pack, so we can't expand
 539         // the pack expansion.
 540         ShouldExpand = false;
 541         continue;
 542       }
 543     } else {
 544       // If we don't have a template argument at this depth/index, then we
 545       // cannot expand the pack expansion. Make a note of this, but we still
 546       // want to check any parameter packs we *do* have arguments for.
 547       if (Depth >= TemplateArgs.getNumLevels() ||
 548           !TemplateArgs.hasTemplateArgument(Depth, Index)) {
 549         ShouldExpand = false;
 550         continue;
 551       }
 552
 553       // Determine the size of the argument pack.
 554       NewPackSize = TemplateArgs(Depth, Index).pack_size();
 555     }
 556
 557     // C++0x [temp.arg.explicit]p9:
 558     //   Template argument deduction can extend the sequence of template
 559     //   arguments corresponding to a template parameter pack, even when the
 560     //   sequence contains explicitly specified template arguments.
 561     if (!IsFunctionParameterPack) {
 562       if (NamedDecl *PartialPack
 563                     = CurrentInstantiationScope->getPartiallySubstitutedPack()){
 564         unsigned PartialDepth, PartialIndex;
 565         llvm::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
 566         if (PartialDepth == Depth && PartialIndex == Index)
 567           RetainExpansion = true;
 568       }
 569     }
 570
 571     if (!NumExpansions) {
 572       // The is the first pack we've seen for which we have an argument.
 573       // Record it.
 574       NumExpansions = NewPackSize;
 575       FirstPack.first = Name;
 576       FirstPack.second = i->second;
 577       HaveFirstPack = true;
 578       continue;
 579     }
 580
 581     if (NewPackSize != *NumExpansions) {
 582       // C++0x [temp.variadic]p5:
 583       //   All of the parameter packs expanded by a pack expansion shall have
 584       //   the same number of arguments specified.
 585       if (HaveFirstPack)
 586         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
 587           << FirstPack.first << Name << *NumExpansions << NewPackSize
 588           << SourceRange(FirstPack.second) << SourceRange(i->second);
 589       else
 590         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
 591           << Name << *NumExpansions << NewPackSize
 592           << SourceRange(i->second);
 593       return true;
 594     }
 595   }
 596
 597   return false;
 598 }
 599
 600 unsigned Sema::getNumArgumentsInExpansion(QualType T,
 601                           const MultiLevelTemplateArgumentList &TemplateArgs) {
 602   QualType Pattern = cast<PackExpansionType>(T)->getPattern();
 603   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 604   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
 605
 606   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
 607     // Compute the depth and index for this parameter pack.
 608     unsigned Depth;
 609     unsigned Index;
 610
 611     if (const TemplateTypeParmType *TTP
 612           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
 613       Depth = TTP->getDepth();
 614       Index = TTP->getIndex();
 615     } else {
 616       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
 617       if (isa<ParmVarDecl>(ND)) {
 618         // Function parameter pack.
 619         typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 620
 621         llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 622           = CurrentInstantiationScope->findInstantiationOf(
 623                                         Unexpanded[I].first.get<NamedDecl *>());
 624         if (Instantiation->is<DeclArgumentPack *>())
 625           return Instantiation->get<DeclArgumentPack *>()->size();
 626
 627         continue;
 628       }
 629
 630       llvm::tie(Depth, Index) = getDepthAndIndex(ND);
 631     }
 632     if (Depth >= TemplateArgs.getNumLevels() ||
 633         !TemplateArgs.hasTemplateArgument(Depth, Index))
 634       continue;
 635
 636     // Determine the size of the argument pack.
 637     return TemplateArgs(Depth, Index).pack_size();
 638   }
 639
 640   llvm_unreachable("No unexpanded parameter packs in type expansion.");
 641 }
 642
 643 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
 644   const DeclSpec &DS = D.getDeclSpec();
 645   switch (DS.getTypeSpecType()) {
 646   case TST_typename:
 647   case TST_typeofType:
 648   case TST_underlyingType:
 649   case TST_atomic: {
 650     QualType T = DS.getRepAsType().get();
 651     if (!T.isNull() && T->containsUnexpandedParameterPack())
 652       return true;
 653     break;
 654   }
 655
 656   case TST_typeofExpr:
 657   case TST_decltype:
 658     if (DS.getRepAsExpr() &&
 659         DS.getRepAsExpr()->containsUnexpandedParameterPack())
 660       return true;
 661     break;
 662
 663   case TST_unspecified:
 664   case TST_void:
 665   case TST_char:
 666   case TST_wchar:
 667   case TST_char16:
 668   case TST_char32:
 669   case TST_int:
 670   case TST_int128:
 671   case TST_half:
 672   case TST_float:
 673   case TST_double:
 674   case TST_bool:
 675   case TST_decimal32:
 676   case TST_decimal64:
 677   case TST_decimal128:
 678   case TST_enum:
 679   case TST_union:
 680   case TST_struct:
 681   case TST_class:
 682   case TST_auto:
 683   case TST_unknown_anytype:
 684   case TST_error:
 685     break;
 686   }
 687
 688   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
 689     const DeclaratorChunk &Chunk = D.getTypeObject(I);
 690     switch (Chunk.Kind) {
 691     case DeclaratorChunk::Pointer:
 692     case DeclaratorChunk::Reference:
 693     case DeclaratorChunk::Paren:
 694       // These declarator chunks cannot contain any parameter packs.
 695       break;
 696
 697     case DeclaratorChunk::Array:
 698     case DeclaratorChunk::Function:
 699     case DeclaratorChunk::BlockPointer:
 700       // Syntactically, these kinds of declarator chunks all come after the
 701       // declarator-id (conceptually), so the parser should not invoke this
 702       // routine at this time.
 703       llvm_unreachable("Could not have seen this kind of declarator chunk");
 704
 705     case DeclaratorChunk::MemberPointer:
 706       if (Chunk.Mem.Scope().getScopeRep() &&
 707           Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
 708         return true;
 709       break;
 710     }
 711   }
 712
 713   return false;
 714 }
 715
 716 namespace {
 717
 718 // Callback to only accept typo corrections that refer to parameter packs.
 719 class ParameterPackValidatorCCC : public CorrectionCandidateCallback {
 720  public:
 721   virtual bool ValidateCandidate(const TypoCorrection &candidate) {
 722     NamedDecl *ND = candidate.getCorrectionDecl();
 723     return ND && ND->isParameterPack();
 724   }
 725 };
 726
 727 }
 728
 729 /// \brief Called when an expression computing the size of a parameter pack
 730 /// is parsed.
 731 ///
 732 /// \code
 733 /// template<typename ...Types> struct count {
 734 ///   static const unsigned value = sizeof...(Types);
 735 /// };
 736 /// \endcode
 737 ///
 738 //
 739 /// \param OpLoc The location of the "sizeof" keyword.
 740 /// \param Name The name of the parameter pack whose size will be determined.
 741 /// \param NameLoc The source location of the name of the parameter pack.
 742 /// \param RParenLoc The location of the closing parentheses.
 743 ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
 744                                               SourceLocation OpLoc,
 745                                               IdentifierInfo &Name,
 746                                               SourceLocation NameLoc,
 747                                               SourceLocation RParenLoc) {
 748   // C++0x [expr.sizeof]p5:
 749   //   The identifier in a sizeof... expression shall name a parameter pack.
 750   LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
 751   LookupName(R, S);
 752
 753   NamedDecl *ParameterPack = 0;
 754   ParameterPackValidatorCCC Validator;
 755   switch (R.getResultKind()) {
 756   case LookupResult::Found:
 757     ParameterPack = R.getFoundDecl();
 758     break;
 759
 760   case LookupResult::NotFound:
 761   case LookupResult::NotFoundInCurrentInstantiation:
 762     if (TypoCorrection Corrected = CorrectTypo(R.getLookupNameInfo(),
 763                                                R.getLookupKind(), S, 0,
 764                                                Validator)) {
 765       std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts()));
 766       ParameterPack = Corrected.getCorrectionDecl();
 767       Diag(NameLoc, diag::err_sizeof_pack_no_pack_name_suggest)
 768         << &Name << CorrectedQuotedStr
 769         << FixItHint::CreateReplacement(
 770             NameLoc, Corrected.getAsString(getLangOpts()));
 771       Diag(ParameterPack->getLocation(), diag::note_parameter_pack_here)
 772         << CorrectedQuotedStr;
 773     }
 774
 775   case LookupResult::FoundOverloaded:
 776   case LookupResult::FoundUnresolvedValue:
 777     break;
 778
 779   case LookupResult::Ambiguous:
 780     DiagnoseAmbiguousLookup(R);
 781     return ExprError();
 782   }
 783
 784   if (!ParameterPack || !ParameterPack->isParameterPack()) {
 785     Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
 786       << &Name;
 787     return ExprError();
 788   }
 789
 790   MarkAnyDeclReferenced(OpLoc, ParameterPack);
 791
 792   return new (Context) SizeOfPackExpr(Context.getSizeType(), OpLoc,
 793                                       ParameterPack, NameLoc, RParenLoc);
 794 }