Home | History | Annotate | Download | only in Sema 
      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 }
    795