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