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