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