contrib/llvm-project/clang/lib/Sema/SemaTemplateVariadic.cpp

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