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     llvm::SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;
  36
  37   public:
  38     explicit CollectUnexpandedParameterPacksVisitor(
  39                   llvm::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 llvm::SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 162   llvm::SmallVector<SourceLocation, 4> Locations;
 163   llvm::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   llvm::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   llvm::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   llvm::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   llvm::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   llvm::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   llvm::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                    llvm::SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 312   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 313     .TraverseTemplateArgument(Arg);
 314 }
 315
 316 void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
 317                    llvm::SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 318   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 319     .TraverseTemplateArgumentLoc(Arg);
 320 }
 321
 322 void Sema::collectUnexpandedParameterPacks(QualType T,
 323                    llvm::SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 324   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
 325 }
 326
 327 void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
 328                    llvm::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                                      const UnexpandedParameterPack *Unexpanded,
 466                                            unsigned NumUnexpanded,
 467                              const MultiLevelTemplateArgumentList &TemplateArgs,
 468                                            bool &ShouldExpand,
 469                                            bool &RetainExpansion,
 470                                      llvm::Optional<unsigned> &NumExpansions) {
 471   ShouldExpand = true;
 472   RetainExpansion = false;
 473   std::pair<IdentifierInfo *, SourceLocation> FirstPack;
 474   bool HaveFirstPack = false;
 475
 476   for (unsigned I = 0; I != NumUnexpanded; ++I) {
 477     // Compute the depth and index for this parameter pack.
 478     unsigned Depth = 0, Index = 0;
 479     IdentifierInfo *Name;
 480     bool IsFunctionParameterPack = false;
 481
 482     if (const TemplateTypeParmType *TTP
 483         = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
 484       Depth = TTP->getDepth();
 485       Index = TTP->getIndex();
 486       Name = TTP->getIdentifier();
 487     } else {
 488       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
 489       if (isa<ParmVarDecl>(ND))
 490         IsFunctionParameterPack = true;
 491       else
 492         llvm::tie(Depth, Index) = getDepthAndIndex(ND);
 493
 494       Name = ND->getIdentifier();
 495     }
 496
 497     // Determine the size of this argument pack.
 498     unsigned NewPackSize;
 499     if (IsFunctionParameterPack) {
 500       // Figure out whether we're instantiating to an argument pack or not.
 501       typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 502
 503       llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 504         = CurrentInstantiationScope->findInstantiationOf(
 505                                         Unexpanded[I].first.get<NamedDecl *>());
 506       if (Instantiation->is<DeclArgumentPack *>()) {
 507         // We could expand this function parameter pack.
 508         NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
 509       } else {
 510         // We can't expand this function parameter pack, so we can't expand
 511         // the pack expansion.
 512         ShouldExpand = false;
 513         continue;
 514       }
 515     } else {
 516       // If we don't have a template argument at this depth/index, then we
 517       // cannot expand the pack expansion. Make a note of this, but we still
 518       // want to check any parameter packs we *do* have arguments for.
 519       if (Depth >= TemplateArgs.getNumLevels() ||
 520           !TemplateArgs.hasTemplateArgument(Depth, Index)) {
 521         ShouldExpand = false;
 522         continue;
 523       }
 524
 525       // Determine the size of the argument pack.
 526       NewPackSize = TemplateArgs(Depth, Index).pack_size();
 527     }
 528
 529     // C++0x [temp.arg.explicit]p9:
 530     //   Template argument deduction can extend the sequence of template
 531     //   arguments corresponding to a template parameter pack, even when the
 532     //   sequence contains explicitly specified template arguments.
 533     if (!IsFunctionParameterPack) {
 534       if (NamedDecl *PartialPack
 535                     = CurrentInstantiationScope->getPartiallySubstitutedPack()){
 536         unsigned PartialDepth, PartialIndex;
 537         llvm::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
 538         if (PartialDepth == Depth && PartialIndex == Index)
 539           RetainExpansion = true;
 540       }
 541     }
 542
 543     if (!NumExpansions) {
 544       // The is the first pack we've seen for which we have an argument.
 545       // Record it.
 546       NumExpansions = NewPackSize;
 547       FirstPack.first = Name;
 548       FirstPack.second = Unexpanded[I].second;
 549       HaveFirstPack = true;
 550       continue;
 551     }
 552
 553     if (NewPackSize != *NumExpansions) {
 554       // C++0x [temp.variadic]p5:
 555       //   All of the parameter packs expanded by a pack expansion shall have
 556       //   the same number of arguments specified.
 557       if (HaveFirstPack)
 558         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
 559           << FirstPack.first << Name << *NumExpansions << NewPackSize
 560           << SourceRange(FirstPack.second) << SourceRange(Unexpanded[I].second);
 561       else
 562         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
 563           << Name << *NumExpansions << NewPackSize
 564           << SourceRange(Unexpanded[I].second);
 565       return true;
 566     }
 567   }
 568
 569   return false;
 570 }
 571
 572 unsigned Sema::getNumArgumentsInExpansion(QualType T,
 573                           const MultiLevelTemplateArgumentList &TemplateArgs) {
 574   QualType Pattern = cast<PackExpansionType>(T)->getPattern();
 575   llvm::SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 576   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
 577
 578   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
 579     // Compute the depth and index for this parameter pack.
 580     unsigned Depth;
 581     unsigned Index;
 582
 583     if (const TemplateTypeParmType *TTP
 584           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
 585       Depth = TTP->getDepth();
 586       Index = TTP->getIndex();
 587     } else {
 588       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
 589       if (isa<ParmVarDecl>(ND)) {
 590         // Function parameter pack.
 591         typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 592
 593         llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 594           = CurrentInstantiationScope->findInstantiationOf(
 595                                         Unexpanded[I].first.get<NamedDecl *>());
 596         if (Instantiation->is<DeclArgumentPack *>())
 597           return Instantiation->get<DeclArgumentPack *>()->size();
 598
 599         continue;
 600       }
 601
 602       llvm::tie(Depth, Index) = getDepthAndIndex(ND);
 603     }
 604     if (Depth >= TemplateArgs.getNumLevels() ||
 605         !TemplateArgs.hasTemplateArgument(Depth, Index))
 606       continue;
 607
 608     // Determine the size of the argument pack.
 609     return TemplateArgs(Depth, Index).pack_size();
 610   }
 611
 612   llvm_unreachable("No unexpanded parameter packs in type expansion.");
 613   return 0;
 614 }
 615
 616 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
 617   const DeclSpec &DS = D.getDeclSpec();
 618   switch (DS.getTypeSpecType()) {
 619   case TST_typename:
 620   case TST_typeofType:
 621   case TST_underlyingType: {
 622     QualType T = DS.getRepAsType().get();
 623     if (!T.isNull() && T->containsUnexpandedParameterPack())
 624       return true;
 625     break;
 626   }
 627
 628   case TST_typeofExpr:
 629   case TST_decltype:
 630     if (DS.getRepAsExpr() &&
 631         DS.getRepAsExpr()->containsUnexpandedParameterPack())
 632       return true;
 633     break;
 634
 635   case TST_unspecified:
 636   case TST_void:
 637   case TST_char:
 638   case TST_wchar:
 639   case TST_char16:
 640   case TST_char32:
 641   case TST_int:
 642   case TST_float:
 643   case TST_double:
 644   case TST_bool:
 645   case TST_decimal32:
 646   case TST_decimal64:
 647   case TST_decimal128:
 648   case TST_enum:
 649   case TST_union:
 650   case TST_struct:
 651   case TST_class:
 652   case TST_auto:
 653   case TST_unknown_anytype:
 654   case TST_error:
 655     break;
 656   }
 657
 658   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
 659     const DeclaratorChunk &Chunk = D.getTypeObject(I);
 660     switch (Chunk.Kind) {
 661     case DeclaratorChunk::Pointer:
 662     case DeclaratorChunk::Reference:
 663     case DeclaratorChunk::Paren:
 664       // These declarator chunks cannot contain any parameter packs.
 665       break;
 666
 667     case DeclaratorChunk::Array:
 668     case DeclaratorChunk::Function:
 669     case DeclaratorChunk::BlockPointer:
 670       // Syntactically, these kinds of declarator chunks all come after the
 671       // declarator-id (conceptually), so the parser should not invoke this
 672       // routine at this time.
 673       llvm_unreachable("Could not have seen this kind of declarator chunk");
 674       break;
 675
 676     case DeclaratorChunk::MemberPointer:
 677       if (Chunk.Mem.Scope().getScopeRep() &&
 678           Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
 679         return true;
 680       break;
 681     }
 682   }
 683
 684   return false;
 685 }
 686
 687 /// \brief Called when an expression computing the size of a parameter pack
 688 /// is parsed.
 689 ///
 690 /// \code
 691 /// template<typename ...Types> struct count {
 692 ///   static const unsigned value = sizeof...(Types);
 693 /// };
 694 /// \endcode
 695 ///
 696 //
 697 /// \param OpLoc The location of the "sizeof" keyword.
 698 /// \param Name The name of the parameter pack whose size will be determined.
 699 /// \param NameLoc The source location of the name of the parameter pack.
 700 /// \param RParenLoc The location of the closing parentheses.
 701 ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
 702                                               SourceLocation OpLoc,
 703                                               IdentifierInfo &Name,
 704                                               SourceLocation NameLoc,
 705                                               SourceLocation RParenLoc) {
 706   // C++0x [expr.sizeof]p5:
 707   //   The identifier in a sizeof... expression shall name a parameter pack.
 708   LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
 709   LookupName(R, S);
 710
 711   NamedDecl *ParameterPack = 0;
 712   switch (R.getResultKind()) {
 713   case LookupResult::Found:
 714     ParameterPack = R.getFoundDecl();
 715     break;
 716
 717   case LookupResult::NotFound:
 718   case LookupResult::NotFoundInCurrentInstantiation:
 719     if (TypoCorrection Corrected = CorrectTypo(R.getLookupNameInfo(),
 720                                                R.getLookupKind(), S, 0, 0,
 721                                                false, CTC_NoKeywords)) {
 722       if (NamedDecl *CorrectedResult = Corrected.getCorrectionDecl())
 723         if (CorrectedResult->isParameterPack()) {
 724           std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOptions()));
 725           ParameterPack = CorrectedResult;
 726           Diag(NameLoc, diag::err_sizeof_pack_no_pack_name_suggest)
 727             << &Name << CorrectedQuotedStr
 728             << FixItHint::CreateReplacement(
 729                 NameLoc, Corrected.getAsString(getLangOptions()));
 730           Diag(ParameterPack->getLocation(), diag::note_parameter_pack_here)
 731             << CorrectedQuotedStr;
 732         }
 733     }
 734
 735   case LookupResult::FoundOverloaded:
 736   case LookupResult::FoundUnresolvedValue:
 737     break;
 738
 739   case LookupResult::Ambiguous:
 740     DiagnoseAmbiguousLookup(R);
 741     return ExprError();
 742   }
 743
 744   if (!ParameterPack || !ParameterPack->isParameterPack()) {
 745     Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
 746       << &Name;
 747     return ExprError();
 748   }
 749
 750   return new (Context) SizeOfPackExpr(Context.getSizeType(), OpLoc,
 751                                       ParameterPack, NameLoc, RParenLoc);
 752 }