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