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