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