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