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 "TypeLocBuilder.h"
  14 #include "clang/AST/Expr.h"
  15 #include "clang/AST/RecursiveASTVisitor.h"
  16 #include "clang/AST/TypeLoc.h"
  17 #include "clang/Sema/Lookup.h"
  18 #include "clang/Sema/ParsedTemplate.h"
  19 #include "clang/Sema/ScopeInfo.h"
  20 #include "clang/Sema/SemaInternal.h"
  21 #include "clang/Sema/Template.h"
  22
  23 using namespace clang;
  24
  25 //----------------------------------------------------------------------------
  26 // Visitor that collects unexpanded parameter packs
  27 //----------------------------------------------------------------------------
  28
  29 namespace {
  30   /// \brief A class that collects unexpanded parameter packs.
  31   class CollectUnexpandedParameterPacksVisitor :
  32     public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
  33   {
  34     typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor>
  35       inherited;
  36
  37     SmallVectorImpl<UnexpandedParameterPack> &Unexpanded;
  38
  39     bool InLambda;
  40
  41   public:
  42     explicit CollectUnexpandedParameterPacksVisitor(
  43                   SmallVectorImpl<UnexpandedParameterPack> &Unexpanded)
  44       : Unexpanded(Unexpanded), InLambda(false) { }
  45
  46     bool shouldWalkTypesOfTypeLocs() const { return false; }
  47
  48     //------------------------------------------------------------------------
  49     // Recording occurrences of (unexpanded) parameter packs.
  50     //------------------------------------------------------------------------
  51
  52     /// \brief Record occurrences of template type parameter packs.
  53     bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
  54       if (TL.getTypePtr()->isParameterPack())
  55         Unexpanded.push_back(std::make_pair(TL.getTypePtr(), TL.getNameLoc()));
  56       return true;
  57     }
  58
  59     /// \brief Record occurrences of template type parameter packs
  60     /// when we don't have proper source-location information for
  61     /// them.
  62     ///
  63     /// Ideally, this routine would never be used.
  64     bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
  65       if (T->isParameterPack())
  66         Unexpanded.push_back(std::make_pair(T, SourceLocation()));
  67
  68       return true;
  69     }
  70
  71     /// \brief Record occurrences of function and non-type template
  72     /// parameter packs in an expression.
  73     bool VisitDeclRefExpr(DeclRefExpr *E) {
  74       if (E->getDecl()->isParameterPack())
  75         Unexpanded.push_back(std::make_pair(E->getDecl(), E->getLocation()));
  76
  77       return true;
  78     }
  79
  80     /// \brief Record occurrences of template template parameter packs.
  81     bool TraverseTemplateName(TemplateName Template) {
  82       if (TemplateTemplateParmDecl *TTP
  83             = dyn_cast_or_null<TemplateTemplateParmDecl>(
  84                                                   Template.getAsTemplateDecl()))
  85         if (TTP->isParameterPack())
  86           Unexpanded.push_back(std::make_pair(TTP, SourceLocation()));
  87
  88       return inherited::TraverseTemplateName(Template);
  89     }
  90
  91     /// \brief Suppress traversal into Objective-C container literal
  92     /// elements that are pack expansions.
  93     bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
  94       if (!E->containsUnexpandedParameterPack())
  95         return true;
  96
  97       for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
  98         ObjCDictionaryElement Element = E->getKeyValueElement(I);
  99         if (Element.isPackExpansion())
 100           continue;
 101
 102         TraverseStmt(Element.Key);
 103         TraverseStmt(Element.Value);
 104       }
 105       return true;
 106     }
 107     //------------------------------------------------------------------------
 108     // Pruning the search for unexpanded parameter packs.
 109     //------------------------------------------------------------------------
 110
 111     /// \brief Suppress traversal into statements and expressions that
 112     /// do not contain unexpanded parameter packs.
 113     bool TraverseStmt(Stmt *S) {
 114       Expr *E = dyn_cast_or_null<Expr>(S);
 115       if ((E && E->containsUnexpandedParameterPack()) || InLambda)
 116         return inherited::TraverseStmt(S);
 117
 118       return true;
 119     }
 120
 121     /// \brief Suppress traversal into types that do not contain
 122     /// unexpanded parameter packs.
 123     bool TraverseType(QualType T) {
 124       if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda)
 125         return inherited::TraverseType(T);
 126
 127       return true;
 128     }
 129
 130     /// \brief Suppress traversel into types with location information
 131     /// that do not contain unexpanded parameter packs.
 132     bool TraverseTypeLoc(TypeLoc TL) {
 133       if ((!TL.getType().isNull() &&
 134            TL.getType()->containsUnexpandedParameterPack()) ||
 135           InLambda)
 136         return inherited::TraverseTypeLoc(TL);
 137
 138       return true;
 139     }
 140
 141     /// \brief Suppress traversal of non-parameter declarations, since
 142     /// they cannot contain unexpanded parameter packs.
 143     bool TraverseDecl(Decl *D) {
 144       if ((D && isa<ParmVarDecl>(D)) || InLambda)
 145         return inherited::TraverseDecl(D);
 146
 147       return true;
 148     }
 149
 150     /// \brief Suppress traversal of template argument pack expansions.
 151     bool TraverseTemplateArgument(const TemplateArgument &Arg) {
 152       if (Arg.isPackExpansion())
 153         return true;
 154
 155       return inherited::TraverseTemplateArgument(Arg);
 156     }
 157
 158     /// \brief Suppress traversal of template argument pack expansions.
 159     bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
 160       if (ArgLoc.getArgument().isPackExpansion())
 161         return true;
 162
 163       return inherited::TraverseTemplateArgumentLoc(ArgLoc);
 164     }
 165
 166     /// \brief Note whether we're traversing a lambda containing an unexpanded
 167     /// parameter pack. In this case, the unexpanded pack can occur anywhere,
 168     /// including all the places where we normally wouldn't look. Within a
 169     /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit
 170     /// outside an expression.
 171     bool TraverseLambdaExpr(LambdaExpr *Lambda) {
 172       // The ContainsUnexpandedParameterPack bit on a lambda is always correct,
 173       // even if it's contained within another lambda.
 174       if (!Lambda->containsUnexpandedParameterPack())
 175         return true;
 176
 177       bool WasInLambda = InLambda;
 178       InLambda = true;
 179
 180       // If any capture names a function parameter pack, that pack is expanded
 181       // when the lambda is expanded.
 182       for (LambdaExpr::capture_iterator I = Lambda->capture_begin(),
 183                                         E = Lambda->capture_end();
 184            I != E; ++I) {
 185         if (I->capturesVariable()) {
 186           VarDecl *VD = I->getCapturedVar();
 187           if (VD->isParameterPack())
 188             Unexpanded.push_back(std::make_pair(VD, I->getLocation()));
 189         }
 190       }
 191
 192       inherited::TraverseLambdaExpr(Lambda);
 193
 194       InLambda = WasInLambda;
 195       return true;
 196     }
 197   };
 198 }
 199
 200 /// \brief Determine whether it's possible for an unexpanded parameter pack to
 201 /// be valid in this location. This only happens when we're in a declaration
 202 /// that is nested within an expression that could be expanded, such as a
 203 /// lambda-expression within a function call.
 204 ///
 205 /// This is conservatively correct, but may claim that some unexpanded packs are
 206 /// permitted when they are not.
 207 bool Sema::isUnexpandedParameterPackPermitted() {
 208   for (auto *SI : FunctionScopes)
 209     if (isa<sema::LambdaScopeInfo>(SI))
 210       return true;
 211   return false;
 212 }
 213
 214 /// \brief Diagnose all of the unexpanded parameter packs in the given
 215 /// vector.
 216 bool
 217 Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
 218                                        UnexpandedParameterPackContext UPPC,
 219                                  ArrayRef<UnexpandedParameterPack> Unexpanded) {
 220   if (Unexpanded.empty())
 221     return false;
 222
 223   // If we are within a lambda expression, that lambda contains an unexpanded
 224   // parameter pack, and we are done.
 225   // FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it
 226   // later.
 227   for (unsigned N = FunctionScopes.size(); N; --N) {
 228     if (sema::LambdaScopeInfo *LSI =
 229           dyn_cast<sema::LambdaScopeInfo>(FunctionScopes[N-1])) {
 230       LSI->ContainsUnexpandedParameterPack = true;
 231       return false;
 232     }
 233   }
 234
 235   SmallVector<SourceLocation, 4> Locations;
 236   SmallVector<IdentifierInfo *, 4> Names;
 237   llvm::SmallPtrSet<IdentifierInfo *, 4> NamesKnown;
 238
 239   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
 240     IdentifierInfo *Name = nullptr;
 241     if (const TemplateTypeParmType *TTP
 242           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>())
 243       Name = TTP->getIdentifier();
 244     else
 245       Name = Unexpanded[I].first.get<NamedDecl *>()->getIdentifier();
 246
 247     if (Name && NamesKnown.insert(Name).second)
 248       Names.push_back(Name);
 249
 250     if (Unexpanded[I].second.isValid())
 251       Locations.push_back(Unexpanded[I].second);
 252   }
 253
 254   DiagnosticBuilder DB = Diag(Loc, diag::err_unexpanded_parameter_pack)
 255                          << (int)UPPC << (int)Names.size();
 256   for (size_t I = 0, E = std::min(Names.size(), (size_t)2); I != E; ++I)
 257     DB << Names[I];
 258
 259   for (unsigned I = 0, N = Locations.size(); I != N; ++I)
 260     DB << SourceRange(Locations[I]);
 261   return true;
 262 }
 263
 264 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
 265                                            TypeSourceInfo *T,
 266                                          UnexpandedParameterPackContext UPPC) {
 267   // C++0x [temp.variadic]p5:
 268   //   An appearance of a name of a parameter pack that is not expanded is
 269   //   ill-formed.
 270   if (!T->getType()->containsUnexpandedParameterPack())
 271     return false;
 272
 273   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 274   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(
 275                                                               T->getTypeLoc());
 276   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 277   return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
 278 }
 279
 280 bool Sema::DiagnoseUnexpandedParameterPack(Expr *E,
 281                                         UnexpandedParameterPackContext UPPC) {
 282   // C++0x [temp.variadic]p5:
 283   //   An appearance of a name of a parameter pack that is not expanded is
 284   //   ill-formed.
 285   if (!E->containsUnexpandedParameterPack())
 286     return false;
 287
 288   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 289   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseStmt(E);
 290   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 291   return DiagnoseUnexpandedParameterPacks(E->getLocStart(), UPPC, Unexpanded);
 292 }
 293
 294 bool Sema::DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
 295                                         UnexpandedParameterPackContext UPPC) {
 296   // C++0x [temp.variadic]p5:
 297   //   An appearance of a name of a parameter pack that is not expanded is
 298   //   ill-formed.
 299   if (!SS.getScopeRep() ||
 300       !SS.getScopeRep()->containsUnexpandedParameterPack())
 301     return false;
 302
 303   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 304   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 305     .TraverseNestedNameSpecifier(SS.getScopeRep());
 306   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 307   return DiagnoseUnexpandedParameterPacks(SS.getRange().getBegin(),
 308                                           UPPC, Unexpanded);
 309 }
 310
 311 bool Sema::DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
 312                                          UnexpandedParameterPackContext UPPC) {
 313   // C++0x [temp.variadic]p5:
 314   //   An appearance of a name of a parameter pack that is not expanded is
 315   //   ill-formed.
 316   switch (NameInfo.getName().getNameKind()) {
 317   case DeclarationName::Identifier:
 318   case DeclarationName::ObjCZeroArgSelector:
 319   case DeclarationName::ObjCOneArgSelector:
 320   case DeclarationName::ObjCMultiArgSelector:
 321   case DeclarationName::CXXOperatorName:
 322   case DeclarationName::CXXLiteralOperatorName:
 323   case DeclarationName::CXXUsingDirective:
 324     return false;
 325
 326   case DeclarationName::CXXConstructorName:
 327   case DeclarationName::CXXDestructorName:
 328   case DeclarationName::CXXConversionFunctionName:
 329     // FIXME: We shouldn't need this null check!
 330     if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
 331       return DiagnoseUnexpandedParameterPack(NameInfo.getLoc(), TSInfo, UPPC);
 332
 333     if (!NameInfo.getName().getCXXNameType()->containsUnexpandedParameterPack())
 334       return false;
 335
 336     break;
 337   }
 338
 339   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 340   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 341     .TraverseType(NameInfo.getName().getCXXNameType());
 342   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 343   return DiagnoseUnexpandedParameterPacks(NameInfo.getLoc(), UPPC, Unexpanded);
 344 }
 345
 346 bool Sema::DiagnoseUnexpandedParameterPack(SourceLocation Loc,
 347                                            TemplateName Template,
 348                                        UnexpandedParameterPackContext UPPC) {
 349
 350   if (Template.isNull() || !Template.containsUnexpandedParameterPack())
 351     return false;
 352
 353   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 354   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 355     .TraverseTemplateName(Template);
 356   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 357   return DiagnoseUnexpandedParameterPacks(Loc, UPPC, Unexpanded);
 358 }
 359
 360 bool Sema::DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
 361                                          UnexpandedParameterPackContext UPPC) {
 362   if (Arg.getArgument().isNull() ||
 363       !Arg.getArgument().containsUnexpandedParameterPack())
 364     return false;
 365
 366   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 367   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 368     .TraverseTemplateArgumentLoc(Arg);
 369   assert(!Unexpanded.empty() && "Unable to find unexpanded parameter packs");
 370   return DiagnoseUnexpandedParameterPacks(Arg.getLocation(), UPPC, Unexpanded);
 371 }
 372
 373 void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
 374                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 375   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 376     .TraverseTemplateArgument(Arg);
 377 }
 378
 379 void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
 380                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 381   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 382     .TraverseTemplateArgumentLoc(Arg);
 383 }
 384
 385 void Sema::collectUnexpandedParameterPacks(QualType T,
 386                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 387   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
 388 }
 389
 390 void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
 391                    SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 392   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
 393 }
 394
 395 void Sema::collectUnexpandedParameterPacks(CXXScopeSpec &SS,
 396                                            SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 397   NestedNameSpecifier *Qualifier = SS.getScopeRep();
 398   if (!Qualifier)
 399     return;
 400
 401   NestedNameSpecifierLoc QualifierLoc(Qualifier, SS.location_data());
 402   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 403     .TraverseNestedNameSpecifierLoc(QualifierLoc);
 404 }
 405
 406 void Sema::collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
 407                          SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
 408   CollectUnexpandedParameterPacksVisitor(Unexpanded)
 409     .TraverseDeclarationNameInfo(NameInfo);
 410 }
 411
 412
 413 ParsedTemplateArgument
 414 Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg,
 415                          SourceLocation EllipsisLoc) {
 416   if (Arg.isInvalid())
 417     return Arg;
 418
 419   switch (Arg.getKind()) {
 420   case ParsedTemplateArgument::Type: {
 421     TypeResult Result = ActOnPackExpansion(Arg.getAsType(), EllipsisLoc);
 422     if (Result.isInvalid())
 423       return ParsedTemplateArgument();
 424
 425     return ParsedTemplateArgument(Arg.getKind(), Result.get().getAsOpaquePtr(),
 426                                   Arg.getLocation());
 427   }
 428
 429   case ParsedTemplateArgument::NonType: {
 430     ExprResult Result = ActOnPackExpansion(Arg.getAsExpr(), EllipsisLoc);
 431     if (Result.isInvalid())
 432       return ParsedTemplateArgument();
 433
 434     return ParsedTemplateArgument(Arg.getKind(), Result.get(),
 435                                   Arg.getLocation());
 436   }
 437
 438   case ParsedTemplateArgument::Template:
 439     if (!Arg.getAsTemplate().get().containsUnexpandedParameterPack()) {
 440       SourceRange R(Arg.getLocation());
 441       if (Arg.getScopeSpec().isValid())
 442         R.setBegin(Arg.getScopeSpec().getBeginLoc());
 443       Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 444         << R;
 445       return ParsedTemplateArgument();
 446     }
 447
 448     return Arg.getTemplatePackExpansion(EllipsisLoc);
 449   }
 450   llvm_unreachable("Unhandled template argument kind?");
 451 }
 452
 453 TypeResult Sema::ActOnPackExpansion(ParsedType Type,
 454                                     SourceLocation EllipsisLoc) {
 455   TypeSourceInfo *TSInfo;
 456   GetTypeFromParser(Type, &TSInfo);
 457   if (!TSInfo)
 458     return true;
 459
 460   TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, None);
 461   if (!TSResult)
 462     return true;
 463
 464   return CreateParsedType(TSResult->getType(), TSResult);
 465 }
 466
 467 TypeSourceInfo *
 468 Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc,
 469                          Optional<unsigned> NumExpansions) {
 470   // Create the pack expansion type and source-location information.
 471   QualType Result = CheckPackExpansion(Pattern->getType(),
 472                                        Pattern->getTypeLoc().getSourceRange(),
 473                                        EllipsisLoc, NumExpansions);
 474   if (Result.isNull())
 475     return nullptr;
 476
 477   TypeLocBuilder TLB;
 478   TLB.pushFullCopy(Pattern->getTypeLoc());
 479   PackExpansionTypeLoc TL = TLB.push<PackExpansionTypeLoc>(Result);
 480   TL.setEllipsisLoc(EllipsisLoc);
 481
 482   return TLB.getTypeSourceInfo(Context, Result);
 483 }
 484
 485 QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange,
 486                                   SourceLocation EllipsisLoc,
 487                                   Optional<unsigned> NumExpansions) {
 488   // C++0x [temp.variadic]p5:
 489   //   The pattern of a pack expansion shall name one or more
 490   //   parameter packs that are not expanded by a nested pack
 491   //   expansion.
 492   if (!Pattern->containsUnexpandedParameterPack()) {
 493     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 494       << PatternRange;
 495     return QualType();
 496   }
 497
 498   return Context.getPackExpansionType(Pattern, NumExpansions);
 499 }
 500
 501 ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
 502   return CheckPackExpansion(Pattern, EllipsisLoc, None);
 503 }
 504
 505 ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
 506                                     Optional<unsigned> NumExpansions) {
 507   if (!Pattern)
 508     return ExprError();
 509
 510   // C++0x [temp.variadic]p5:
 511   //   The pattern of a pack expansion shall name one or more
 512   //   parameter packs that are not expanded by a nested pack
 513   //   expansion.
 514   if (!Pattern->containsUnexpandedParameterPack()) {
 515     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 516     << Pattern->getSourceRange();
 517     return ExprError();
 518   }
 519
 520   // Create the pack expansion expression and source-location information.
 521   return new (Context)
 522     PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions);
 523 }
 524
 525 /// \brief Retrieve the depth and index of a parameter pack.
 526 static std::pair<unsigned, unsigned>
 527 getDepthAndIndex(NamedDecl *ND) {
 528   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
 529     return std::make_pair(TTP->getDepth(), TTP->getIndex());
 530
 531   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
 532     return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
 533
 534   TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
 535   return std::make_pair(TTP->getDepth(), TTP->getIndex());
 536 }
 537
 538 bool Sema::CheckParameterPacksForExpansion(
 539     SourceLocation EllipsisLoc, SourceRange PatternRange,
 540     ArrayRef<UnexpandedParameterPack> Unexpanded,
 541     const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand,
 542     bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
 543   ShouldExpand = true;
 544   RetainExpansion = false;
 545   std::pair<IdentifierInfo *, SourceLocation> FirstPack;
 546   bool HaveFirstPack = false;
 547
 548   for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(),
 549                                                  end = Unexpanded.end();
 550                                                   i != end; ++i) {
 551     // Compute the depth and index for this parameter pack.
 552     unsigned Depth = 0, Index = 0;
 553     IdentifierInfo *Name;
 554     bool IsFunctionParameterPack = false;
 555
 556     if (const TemplateTypeParmType *TTP
 557         = i->first.dyn_cast<const TemplateTypeParmType *>()) {
 558       Depth = TTP->getDepth();
 559       Index = TTP->getIndex();
 560       Name = TTP->getIdentifier();
 561     } else {
 562       NamedDecl *ND = i->first.get<NamedDecl *>();
 563       if (isa<ParmVarDecl>(ND))
 564         IsFunctionParameterPack = true;
 565       else
 566         std::tie(Depth, Index) = getDepthAndIndex(ND);
 567
 568       Name = ND->getIdentifier();
 569     }
 570
 571     // Determine the size of this argument pack.
 572     unsigned NewPackSize;
 573     if (IsFunctionParameterPack) {
 574       // Figure out whether we're instantiating to an argument pack or not.
 575       typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 576
 577       llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 578         = CurrentInstantiationScope->findInstantiationOf(
 579                                         i->first.get<NamedDecl *>());
 580       if (Instantiation->is<DeclArgumentPack *>()) {
 581         // We could expand this function parameter pack.
 582         NewPackSize = Instantiation->get<DeclArgumentPack *>()->size();
 583       } else {
 584         // We can't expand this function parameter pack, so we can't expand
 585         // the pack expansion.
 586         ShouldExpand = false;
 587         continue;
 588       }
 589     } else {
 590       // If we don't have a template argument at this depth/index, then we
 591       // cannot expand the pack expansion. Make a note of this, but we still
 592       // want to check any parameter packs we *do* have arguments for.
 593       if (Depth >= TemplateArgs.getNumLevels() ||
 594           !TemplateArgs.hasTemplateArgument(Depth, Index)) {
 595         ShouldExpand = false;
 596         continue;
 597       }
 598
 599       // Determine the size of the argument pack.
 600       NewPackSize = TemplateArgs(Depth, Index).pack_size();
 601     }
 602
 603     // C++0x [temp.arg.explicit]p9:
 604     //   Template argument deduction can extend the sequence of template
 605     //   arguments corresponding to a template parameter pack, even when the
 606     //   sequence contains explicitly specified template arguments.
 607     if (!IsFunctionParameterPack) {
 608       if (NamedDecl *PartialPack
 609                     = CurrentInstantiationScope->getPartiallySubstitutedPack()){
 610         unsigned PartialDepth, PartialIndex;
 611         std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack);
 612         if (PartialDepth == Depth && PartialIndex == Index)
 613           RetainExpansion = true;
 614       }
 615     }
 616
 617     if (!NumExpansions) {
 618       // The is the first pack we've seen for which we have an argument.
 619       // Record it.
 620       NumExpansions = NewPackSize;
 621       FirstPack.first = Name;
 622       FirstPack.second = i->second;
 623       HaveFirstPack = true;
 624       continue;
 625     }
 626
 627     if (NewPackSize != *NumExpansions) {
 628       // C++0x [temp.variadic]p5:
 629       //   All of the parameter packs expanded by a pack expansion shall have
 630       //   the same number of arguments specified.
 631       if (HaveFirstPack)
 632         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict)
 633           << FirstPack.first << Name << *NumExpansions << NewPackSize
 634           << SourceRange(FirstPack.second) << SourceRange(i->second);
 635       else
 636         Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel)
 637           << Name << *NumExpansions << NewPackSize
 638           << SourceRange(i->second);
 639       return true;
 640     }
 641   }
 642
 643   return false;
 644 }
 645
 646 Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T,
 647                           const MultiLevelTemplateArgumentList &TemplateArgs) {
 648   QualType Pattern = cast<PackExpansionType>(T)->getPattern();
 649   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
 650   CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern);
 651
 652   Optional<unsigned> Result;
 653   for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
 654     // Compute the depth and index for this parameter pack.
 655     unsigned Depth;
 656     unsigned Index;
 657
 658     if (const TemplateTypeParmType *TTP
 659           = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) {
 660       Depth = TTP->getDepth();
 661       Index = TTP->getIndex();
 662     } else {
 663       NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>();
 664       if (isa<ParmVarDecl>(ND)) {
 665         // Function parameter pack.
 666         typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
 667
 668         llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation
 669           = CurrentInstantiationScope->findInstantiationOf(
 670                                         Unexpanded[I].first.get<NamedDecl *>());
 671         if (Instantiation->is<Decl*>())
 672           // The pattern refers to an unexpanded pack. We're not ready to expand
 673           // this pack yet.
 674           return None;
 675
 676         unsigned Size = Instantiation->get<DeclArgumentPack *>()->size();
 677         assert((!Result || *Result == Size) && "inconsistent pack sizes");
 678         Result = Size;
 679         continue;
 680       }
 681
 682       std::tie(Depth, Index) = getDepthAndIndex(ND);
 683     }
 684     if (Depth >= TemplateArgs.getNumLevels() ||
 685         !TemplateArgs.hasTemplateArgument(Depth, Index))
 686       // The pattern refers to an unknown template argument. We're not ready to
 687       // expand this pack yet.
 688       return None;
 689
 690     // Determine the size of the argument pack.
 691     unsigned Size = TemplateArgs(Depth, Index).pack_size();
 692     assert((!Result || *Result == Size) && "inconsistent pack sizes");
 693     Result = Size;
 694   }
 695
 696   return Result;
 697 }
 698
 699 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
 700   const DeclSpec &DS = D.getDeclSpec();
 701   switch (DS.getTypeSpecType()) {
 702   case TST_typename:
 703   case TST_typeofType:
 704   case TST_underlyingType:
 705   case TST_atomic: {
 706     QualType T = DS.getRepAsType().get();
 707     if (!T.isNull() && T->containsUnexpandedParameterPack())
 708       return true;
 709     break;
 710   }
 711
 712   case TST_typeofExpr:
 713   case TST_decltype:
 714     if (DS.getRepAsExpr() &&
 715         DS.getRepAsExpr()->containsUnexpandedParameterPack())
 716       return true;
 717     break;
 718
 719   case TST_unspecified:
 720   case TST_void:
 721   case TST_char:
 722   case TST_wchar:
 723   case TST_char16:
 724   case TST_char32:
 725   case TST_int:
 726   case TST_int128:
 727   case TST_half:
 728   case TST_float:
 729   case TST_double:
 730   case TST_bool:
 731   case TST_decimal32:
 732   case TST_decimal64:
 733   case TST_decimal128:
 734   case TST_enum:
 735   case TST_union:
 736   case TST_struct:
 737   case TST_interface:
 738   case TST_class:
 739   case TST_auto:
 740   case TST_decltype_auto:
 741   case TST_unknown_anytype:
 742   case TST_error:
 743     break;
 744   }
 745
 746   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
 747     const DeclaratorChunk &Chunk = D.getTypeObject(I);
 748     switch (Chunk.Kind) {
 749     case DeclaratorChunk::Pointer:
 750     case DeclaratorChunk::Reference:
 751     case DeclaratorChunk::Paren:
 752     case DeclaratorChunk::BlockPointer:
 753       // These declarator chunks cannot contain any parameter packs.
 754       break;
 755
 756     case DeclaratorChunk::Array:
 757       if (Chunk.Arr.NumElts &&
 758           Chunk.Arr.NumElts->containsUnexpandedParameterPack())
 759         return true;
 760       break;
 761     case DeclaratorChunk::Function:
 762       for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) {
 763         ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param);
 764         QualType ParamTy = Param->getType();
 765         assert(!ParamTy.isNull() && "Couldn't parse type?");
 766         if (ParamTy->containsUnexpandedParameterPack()) return true;
 767       }
 768
 769       if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) {
 770         for (unsigned i = 0; i != Chunk.Fun.NumExceptions; ++i) {
 771           if (Chunk.Fun.Exceptions[i]
 772                   .Ty.get()
 773                   ->containsUnexpandedParameterPack())
 774             return true;
 775         }
 776       } else if (Chunk.Fun.getExceptionSpecType() == EST_ComputedNoexcept &&
 777                  Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack())
 778         return true;
 779
 780       if (Chunk.Fun.hasTrailingReturnType()) {
 781         QualType T = Chunk.Fun.getTrailingReturnType().get();
 782         if (!T.isNull() && T->containsUnexpandedParameterPack())
 783           return true;
 784       }
 785       break;
 786
 787     case DeclaratorChunk::MemberPointer:
 788       if (Chunk.Mem.Scope().getScopeRep() &&
 789           Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack())
 790         return true;
 791       break;
 792     }
 793   }
 794
 795   return false;
 796 }
 797
 798 namespace {
 799
 800 // Callback to only accept typo corrections that refer to parameter packs.
 801 class ParameterPackValidatorCCC : public CorrectionCandidateCallback {
 802  public:
 803   bool ValidateCandidate(const TypoCorrection &candidate) override {
 804     NamedDecl *ND = candidate.getCorrectionDecl();
 805     return ND && ND->isParameterPack();
 806   }
 807 };
 808
 809 }
 810
 811 /// \brief Called when an expression computing the size of a parameter pack
 812 /// is parsed.
 813 ///
 814 /// \code
 815 /// template<typename ...Types> struct count {
 816 ///   static const unsigned value = sizeof...(Types);
 817 /// };
 818 /// \endcode
 819 ///
 820 //
 821 /// \param OpLoc The location of the "sizeof" keyword.
 822 /// \param Name The name of the parameter pack whose size will be determined.
 823 /// \param NameLoc The source location of the name of the parameter pack.
 824 /// \param RParenLoc The location of the closing parentheses.
 825 ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S,
 826                                               SourceLocation OpLoc,
 827                                               IdentifierInfo &Name,
 828                                               SourceLocation NameLoc,
 829                                               SourceLocation RParenLoc) {
 830   // C++0x [expr.sizeof]p5:
 831   //   The identifier in a sizeof... expression shall name a parameter pack.
 832   LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName);
 833   LookupName(R, S);
 834
 835   NamedDecl *ParameterPack = nullptr;
 836   switch (R.getResultKind()) {
 837   case LookupResult::Found:
 838     ParameterPack = R.getFoundDecl();
 839     break;
 840
 841   case LookupResult::NotFound:
 842   case LookupResult::NotFoundInCurrentInstantiation:
 843     if (TypoCorrection Corrected =
 844             CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr,
 845                         llvm::make_unique<ParameterPackValidatorCCC>(),
 846                         CTK_ErrorRecovery)) {
 847       diagnoseTypo(Corrected,
 848                    PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name,
 849                    PDiag(diag::note_parameter_pack_here));
 850       ParameterPack = Corrected.getCorrectionDecl();
 851     }
 852
 853   case LookupResult::FoundOverloaded:
 854   case LookupResult::FoundUnresolvedValue:
 855     break;
 856
 857   case LookupResult::Ambiguous:
 858     DiagnoseAmbiguousLookup(R);
 859     return ExprError();
 860   }
 861
 862   if (!ParameterPack || !ParameterPack->isParameterPack()) {
 863     Diag(NameLoc, diag::err_sizeof_pack_no_pack_name)
 864       << &Name;
 865     return ExprError();
 866   }
 867
 868   MarkAnyDeclReferenced(OpLoc, ParameterPack, true);
 869
 870   return new (Context) SizeOfPackExpr(Context.getSizeType(), OpLoc,
 871                                       ParameterPack, NameLoc, RParenLoc);
 872 }
 873
 874 TemplateArgumentLoc
 875 Sema::getTemplateArgumentPackExpansionPattern(
 876       TemplateArgumentLoc OrigLoc,
 877       SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
 878   const TemplateArgument &Argument = OrigLoc.getArgument();
 879   assert(Argument.isPackExpansion());
 880   switch (Argument.getKind()) {
 881   case TemplateArgument::Type: {
 882     // FIXME: We shouldn't ever have to worry about missing
 883     // type-source info!
 884     TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo();
 885     if (!ExpansionTSInfo)
 886       ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(),
 887                                                          Ellipsis);
 888     PackExpansionTypeLoc Expansion =
 889         ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>();
 890     Ellipsis = Expansion.getEllipsisLoc();
 891
 892     TypeLoc Pattern = Expansion.getPatternLoc();
 893     NumExpansions = Expansion.getTypePtr()->getNumExpansions();
 894
 895     // We need to copy the TypeLoc because TemplateArgumentLocs store a
 896     // TypeSourceInfo.
 897     // FIXME: Find some way to avoid the copy?
 898     TypeLocBuilder TLB;
 899     TLB.pushFullCopy(Pattern);
 900     TypeSourceInfo *PatternTSInfo =
 901         TLB.getTypeSourceInfo(Context, Pattern.getType());
 902     return TemplateArgumentLoc(TemplateArgument(Pattern.getType()),
 903                                PatternTSInfo);
 904   }
 905
 906   case TemplateArgument::Expression: {
 907     PackExpansionExpr *Expansion
 908       = cast<PackExpansionExpr>(Argument.getAsExpr());
 909     Expr *Pattern = Expansion->getPattern();
 910     Ellipsis = Expansion->getEllipsisLoc();
 911     NumExpansions = Expansion->getNumExpansions();
 912     return TemplateArgumentLoc(Pattern, Pattern);
 913   }
 914
 915   case TemplateArgument::TemplateExpansion:
 916     Ellipsis = OrigLoc.getTemplateEllipsisLoc();
 917     NumExpansions = Argument.getNumTemplateExpansions();
 918     return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
 919                                OrigLoc.getTemplateQualifierLoc(),
 920                                OrigLoc.getTemplateNameLoc());
 921
 922   case TemplateArgument::Declaration:
 923   case TemplateArgument::NullPtr:
 924   case TemplateArgument::Template:
 925   case TemplateArgument::Integral:
 926   case TemplateArgument::Pack:
 927   case TemplateArgument::Null:
 928     return TemplateArgumentLoc();
 929   }
 930
 931   llvm_unreachable("Invalid TemplateArgument Kind!");
 932 }
 933
 934 static void CheckFoldOperand(Sema &S, Expr *E) {
 935   if (!E)
 936     return;
 937
 938   E = E->IgnoreImpCasts();
 939   if (isa<BinaryOperator>(E) || isa<AbstractConditionalOperator>(E)) {
 940     S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand)
 941         << E->getSourceRange()
 942         << FixItHint::CreateInsertion(E->getLocStart(), "(")
 943         << FixItHint::CreateInsertion(E->getLocEnd(), ")");
 944   }
 945 }
 946
 947 ExprResult Sema::ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
 948                                   tok::TokenKind Operator,
 949                                   SourceLocation EllipsisLoc, Expr *RHS,
 950                                   SourceLocation RParenLoc) {
 951   // LHS and RHS must be cast-expressions. We allow an arbitrary expression
 952   // in the parser and reduce down to just cast-expressions here.
 953   CheckFoldOperand(*this, LHS);
 954   CheckFoldOperand(*this, RHS);
 955
 956   // [expr.prim.fold]p3:
 957   //   In a binary fold, op1 and op2 shall be the same fold-operator, and
 958   //   either e1 shall contain an unexpanded parameter pack or e2 shall contain
 959   //   an unexpanded parameter pack, but not both.
 960   if (LHS && RHS &&
 961       LHS->containsUnexpandedParameterPack() ==
 962           RHS->containsUnexpandedParameterPack()) {
 963     return Diag(EllipsisLoc,
 964                 LHS->containsUnexpandedParameterPack()
 965                     ? diag::err_fold_expression_packs_both_sides
 966                     : diag::err_pack_expansion_without_parameter_packs)
 967         << LHS->getSourceRange() << RHS->getSourceRange();
 968   }
 969
 970   // [expr.prim.fold]p2:
 971   //   In a unary fold, the cast-expression shall contain an unexpanded
 972   //   parameter pack.
 973   if (!LHS || !RHS) {
 974     Expr *Pack = LHS ? LHS : RHS;
 975     assert(Pack && "fold expression with neither LHS nor RHS");
 976     if (!Pack->containsUnexpandedParameterPack())
 977       return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
 978              << Pack->getSourceRange();
 979   }
 980
 981   BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator);
 982   return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc);
 983 }
 984
 985 ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS,
 986                                   BinaryOperatorKind Operator,
 987                                   SourceLocation EllipsisLoc, Expr *RHS,
 988                                   SourceLocation RParenLoc) {
 989   return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS,
 990                                    Operator, EllipsisLoc, RHS, RParenLoc);
 991 }
 992
 993 ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
 994                                        BinaryOperatorKind Operator) {
 995   // [temp.variadic]p9:
 996   //   If N is zero for a unary fold-expression, the value of the expression is
 997   //       *   ->  1
 998   //       +   ->  int()
 999   //       &   ->  -1
1000   //       |   ->  int()
1001   //       &&  ->  true
1002   //       ||  ->  false
1003   //       ,   ->  void()
1004   //   if the operator is not listed [above], the instantiation is ill-formed.
1005   //
1006   // Note that we need to use something like int() here, not merely 0, to
1007   // prevent the result from being a null pointer constant.
1008   QualType ScalarType;
1009   switch (Operator) {
1010   case BO_Add:
1011     ScalarType = Context.IntTy;
1012     break;
1013   case BO_Mul:
1014     return ActOnIntegerConstant(EllipsisLoc, 1);
1015   case BO_Or:
1016     ScalarType = Context.IntTy;
1017     break;
1018   case BO_And:
1019     return CreateBuiltinUnaryOp(EllipsisLoc, UO_Minus,
1020                                 ActOnIntegerConstant(EllipsisLoc, 1).get());
1021   case BO_LOr:
1022     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false);
1023   case BO_LAnd:
1024     return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true);
1025   case BO_Comma:
1026     ScalarType = Context.VoidTy;
1027     break;
1028
1029   default:
1030     return Diag(EllipsisLoc, diag::err_fold_expression_empty)
1031         << BinaryOperator::getOpcodeStr(Operator);
1032   }
1033
1034   return new (Context) CXXScalarValueInitExpr(
1035       ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc),
1036       EllipsisLoc);
1037 }