File: | tools/clang/lib/Sema/SemaTemplateVariadic.cpp |
Warning: | line 680, column 11 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===------- SemaTemplateVariadic.cpp - C++ Variadic Templates ------------===/ | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | //===----------------------------------------------------------------------===/ | |||
8 | // | |||
9 | // This file implements semantic analysis for C++0x variadic templates. | |||
10 | //===----------------------------------------------------------------------===/ | |||
11 | ||||
12 | #include "clang/Sema/Sema.h" | |||
13 | #include "TypeLocBuilder.h" | |||
14 | #include "clang/AST/Expr.h" | |||
15 | #include "clang/AST/RecursiveASTVisitor.h" | |||
16 | #include "clang/AST/TypeLoc.h" | |||
17 | #include "clang/Sema/Lookup.h" | |||
18 | #include "clang/Sema/ParsedTemplate.h" | |||
19 | #include "clang/Sema/ScopeInfo.h" | |||
20 | #include "clang/Sema/SemaInternal.h" | |||
21 | #include "clang/Sema/Template.h" | |||
22 | ||||
23 | using namespace clang; | |||
24 | ||||
25 | //---------------------------------------------------------------------------- | |||
26 | // Visitor that collects unexpanded parameter packs | |||
27 | //---------------------------------------------------------------------------- | |||
28 | ||||
29 | /// Retrieve the depth and index of a parameter pack. | |||
30 | static std::pair<unsigned, unsigned> | |||
31 | getDepthAndIndex(NamedDecl *ND) { | |||
32 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) | |||
33 | return std::make_pair(TTP->getDepth(), TTP->getIndex()); | |||
34 | ||||
35 | if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND)) | |||
36 | return std::make_pair(NTTP->getDepth(), NTTP->getIndex()); | |||
37 | ||||
38 | TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND); | |||
39 | return std::make_pair(TTP->getDepth(), TTP->getIndex()); | |||
40 | } | |||
41 | ||||
42 | namespace { | |||
43 | /// A class that collects unexpanded parameter packs. | |||
44 | class CollectUnexpandedParameterPacksVisitor : | |||
45 | public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor> | |||
46 | { | |||
47 | typedef RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor> | |||
48 | inherited; | |||
49 | ||||
50 | SmallVectorImpl<UnexpandedParameterPack> &Unexpanded; | |||
51 | ||||
52 | bool InLambda = false; | |||
53 | unsigned DepthLimit = (unsigned)-1; | |||
54 | ||||
55 | void addUnexpanded(NamedDecl *ND, SourceLocation Loc = SourceLocation()) { | |||
56 | if (auto *PVD = dyn_cast<ParmVarDecl>(ND)) { | |||
57 | // For now, the only problematic case is a generic lambda's templated | |||
58 | // call operator, so we don't need to look for all the other ways we | |||
59 | // could have reached a dependent parameter pack. | |||
60 | auto *FD = dyn_cast<FunctionDecl>(PVD->getDeclContext()); | |||
61 | auto *FTD = FD ? FD->getDescribedFunctionTemplate() : nullptr; | |||
62 | if (FTD && FTD->getTemplateParameters()->getDepth() >= DepthLimit) | |||
63 | return; | |||
64 | } else if (getDepthAndIndex(ND).first >= DepthLimit) | |||
65 | return; | |||
66 | ||||
67 | Unexpanded.push_back({ND, Loc}); | |||
68 | } | |||
69 | void addUnexpanded(const TemplateTypeParmType *T, | |||
70 | SourceLocation Loc = SourceLocation()) { | |||
71 | if (T->getDepth() < DepthLimit) | |||
72 | Unexpanded.push_back({T, Loc}); | |||
73 | } | |||
74 | ||||
75 | public: | |||
76 | explicit CollectUnexpandedParameterPacksVisitor( | |||
77 | SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) | |||
78 | : Unexpanded(Unexpanded) {} | |||
79 | ||||
80 | bool shouldWalkTypesOfTypeLocs() const { return false; } | |||
81 | ||||
82 | //------------------------------------------------------------------------ | |||
83 | // Recording occurrences of (unexpanded) parameter packs. | |||
84 | //------------------------------------------------------------------------ | |||
85 | ||||
86 | /// Record occurrences of template type parameter packs. | |||
87 | bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { | |||
88 | if (TL.getTypePtr()->isParameterPack()) | |||
89 | addUnexpanded(TL.getTypePtr(), TL.getNameLoc()); | |||
90 | return true; | |||
91 | } | |||
92 | ||||
93 | /// Record occurrences of template type parameter packs | |||
94 | /// when we don't have proper source-location information for | |||
95 | /// them. | |||
96 | /// | |||
97 | /// Ideally, this routine would never be used. | |||
98 | bool VisitTemplateTypeParmType(TemplateTypeParmType *T) { | |||
99 | if (T->isParameterPack()) | |||
100 | addUnexpanded(T); | |||
101 | ||||
102 | return true; | |||
103 | } | |||
104 | ||||
105 | /// Record occurrences of function and non-type template | |||
106 | /// parameter packs in an expression. | |||
107 | bool VisitDeclRefExpr(DeclRefExpr *E) { | |||
108 | if (E->getDecl()->isParameterPack()) | |||
109 | addUnexpanded(E->getDecl(), E->getLocation()); | |||
110 | ||||
111 | return true; | |||
112 | } | |||
113 | ||||
114 | /// Record occurrences of template template parameter packs. | |||
115 | bool TraverseTemplateName(TemplateName Template) { | |||
116 | if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>( | |||
117 | Template.getAsTemplateDecl())) { | |||
118 | if (TTP->isParameterPack()) | |||
119 | addUnexpanded(TTP); | |||
120 | } | |||
121 | ||||
122 | return inherited::TraverseTemplateName(Template); | |||
123 | } | |||
124 | ||||
125 | /// Suppress traversal into Objective-C container literal | |||
126 | /// elements that are pack expansions. | |||
127 | bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { | |||
128 | if (!E->containsUnexpandedParameterPack()) | |||
129 | return true; | |||
130 | ||||
131 | for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { | |||
132 | ObjCDictionaryElement Element = E->getKeyValueElement(I); | |||
133 | if (Element.isPackExpansion()) | |||
134 | continue; | |||
135 | ||||
136 | TraverseStmt(Element.Key); | |||
137 | TraverseStmt(Element.Value); | |||
138 | } | |||
139 | return true; | |||
140 | } | |||
141 | //------------------------------------------------------------------------ | |||
142 | // Pruning the search for unexpanded parameter packs. | |||
143 | //------------------------------------------------------------------------ | |||
144 | ||||
145 | /// Suppress traversal into statements and expressions that | |||
146 | /// do not contain unexpanded parameter packs. | |||
147 | bool TraverseStmt(Stmt *S) { | |||
148 | Expr *E = dyn_cast_or_null<Expr>(S); | |||
149 | if ((E && E->containsUnexpandedParameterPack()) || InLambda) | |||
150 | return inherited::TraverseStmt(S); | |||
151 | ||||
152 | return true; | |||
153 | } | |||
154 | ||||
155 | /// Suppress traversal into types that do not contain | |||
156 | /// unexpanded parameter packs. | |||
157 | bool TraverseType(QualType T) { | |||
158 | if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda) | |||
159 | return inherited::TraverseType(T); | |||
160 | ||||
161 | return true; | |||
162 | } | |||
163 | ||||
164 | /// Suppress traversal into types with location information | |||
165 | /// that do not contain unexpanded parameter packs. | |||
166 | bool TraverseTypeLoc(TypeLoc TL) { | |||
167 | if ((!TL.getType().isNull() && | |||
168 | TL.getType()->containsUnexpandedParameterPack()) || | |||
169 | InLambda) | |||
170 | return inherited::TraverseTypeLoc(TL); | |||
171 | ||||
172 | return true; | |||
173 | } | |||
174 | ||||
175 | /// Suppress traversal of parameter packs. | |||
176 | bool TraverseDecl(Decl *D) { | |||
177 | // A function parameter pack is a pack expansion, so cannot contain | |||
178 | // an unexpanded parameter pack. Likewise for a template parameter | |||
179 | // pack that contains any references to other packs. | |||
180 | if (D->isParameterPack()) | |||
181 | return true; | |||
182 | ||||
183 | return inherited::TraverseDecl(D); | |||
184 | } | |||
185 | ||||
186 | /// Suppress traversal of pack-expanded attributes. | |||
187 | bool TraverseAttr(Attr *A) { | |||
188 | if (A->isPackExpansion()) | |||
189 | return true; | |||
190 | ||||
191 | return inherited::TraverseAttr(A); | |||
192 | } | |||
193 | ||||
194 | /// Suppress traversal of pack expansion expressions and types. | |||
195 | ///@{ | |||
196 | bool TraversePackExpansionType(PackExpansionType *T) { return true; } | |||
197 | bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; } | |||
198 | bool TraversePackExpansionExpr(PackExpansionExpr *E) { return true; } | |||
199 | bool TraverseCXXFoldExpr(CXXFoldExpr *E) { return true; } | |||
200 | ||||
201 | ///@} | |||
202 | ||||
203 | /// Suppress traversal of using-declaration pack expansion. | |||
204 | bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { | |||
205 | if (D->isPackExpansion()) | |||
206 | return true; | |||
207 | ||||
208 | return inherited::TraverseUnresolvedUsingValueDecl(D); | |||
209 | } | |||
210 | ||||
211 | /// Suppress traversal of using-declaration pack expansion. | |||
212 | bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { | |||
213 | if (D->isPackExpansion()) | |||
214 | return true; | |||
215 | ||||
216 | return inherited::TraverseUnresolvedUsingTypenameDecl(D); | |||
217 | } | |||
218 | ||||
219 | /// Suppress traversal of template argument pack expansions. | |||
220 | bool TraverseTemplateArgument(const TemplateArgument &Arg) { | |||
221 | if (Arg.isPackExpansion()) | |||
222 | return true; | |||
223 | ||||
224 | return inherited::TraverseTemplateArgument(Arg); | |||
225 | } | |||
226 | ||||
227 | /// Suppress traversal of template argument pack expansions. | |||
228 | bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) { | |||
229 | if (ArgLoc.getArgument().isPackExpansion()) | |||
230 | return true; | |||
231 | ||||
232 | return inherited::TraverseTemplateArgumentLoc(ArgLoc); | |||
233 | } | |||
234 | ||||
235 | /// Suppress traversal of base specifier pack expansions. | |||
236 | bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base) { | |||
237 | if (Base.isPackExpansion()) | |||
238 | return true; | |||
239 | ||||
240 | return inherited::TraverseCXXBaseSpecifier(Base); | |||
241 | } | |||
242 | ||||
243 | /// Suppress traversal of mem-initializer pack expansions. | |||
244 | bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { | |||
245 | if (Init->isPackExpansion()) | |||
246 | return true; | |||
247 | ||||
248 | return inherited::TraverseConstructorInitializer(Init); | |||
249 | } | |||
250 | ||||
251 | /// Note whether we're traversing a lambda containing an unexpanded | |||
252 | /// parameter pack. In this case, the unexpanded pack can occur anywhere, | |||
253 | /// including all the places where we normally wouldn't look. Within a | |||
254 | /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit | |||
255 | /// outside an expression. | |||
256 | bool TraverseLambdaExpr(LambdaExpr *Lambda) { | |||
257 | // The ContainsUnexpandedParameterPack bit on a lambda is always correct, | |||
258 | // even if it's contained within another lambda. | |||
259 | if (!Lambda->containsUnexpandedParameterPack()) | |||
260 | return true; | |||
261 | ||||
262 | bool WasInLambda = InLambda; | |||
263 | unsigned OldDepthLimit = DepthLimit; | |||
264 | ||||
265 | InLambda = true; | |||
266 | if (auto *TPL = Lambda->getTemplateParameterList()) | |||
267 | DepthLimit = TPL->getDepth(); | |||
268 | ||||
269 | inherited::TraverseLambdaExpr(Lambda); | |||
270 | ||||
271 | InLambda = WasInLambda; | |||
272 | DepthLimit = OldDepthLimit; | |||
273 | return true; | |||
274 | } | |||
275 | ||||
276 | /// Suppress traversal within pack expansions in lambda captures. | |||
277 | bool TraverseLambdaCapture(LambdaExpr *Lambda, const LambdaCapture *C, | |||
278 | Expr *Init) { | |||
279 | if (C->isPackExpansion()) | |||
280 | return true; | |||
281 | ||||
282 | return inherited::TraverseLambdaCapture(Lambda, C, Init); | |||
283 | } | |||
284 | }; | |||
285 | } | |||
286 | ||||
287 | /// Determine whether it's possible for an unexpanded parameter pack to | |||
288 | /// be valid in this location. This only happens when we're in a declaration | |||
289 | /// that is nested within an expression that could be expanded, such as a | |||
290 | /// lambda-expression within a function call. | |||
291 | /// | |||
292 | /// This is conservatively correct, but may claim that some unexpanded packs are | |||
293 | /// permitted when they are not. | |||
294 | bool Sema::isUnexpandedParameterPackPermitted() { | |||
295 | for (auto *SI : FunctionScopes) | |||
296 | if (isa<sema::LambdaScopeInfo>(SI)) | |||
297 | return true; | |||
298 | return false; | |||
299 | } | |||
300 | ||||
301 | /// Diagnose all of the unexpanded parameter packs in the given | |||
302 | /// vector. | |||
303 | bool | |||
304 | Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc, | |||
305 | UnexpandedParameterPackContext UPPC, | |||
306 | ArrayRef<UnexpandedParameterPack> Unexpanded) { | |||
307 | if (Unexpanded.empty()) | |||
308 | return false; | |||
309 | ||||
310 | // If we are within a lambda expression and referencing a pack that is not | |||
311 | // a parameter of the lambda itself, that lambda contains an unexpanded | |||
312 | // parameter pack, and we are done. | |||
313 | // FIXME: Store 'Unexpanded' on the lambda so we don't need to recompute it | |||
314 | // later. | |||
315 | SmallVector<UnexpandedParameterPack, 4> LambdaParamPackReferences; | |||
316 | for (unsigned N = FunctionScopes.size(); N; --N) { | |||
317 | sema::FunctionScopeInfo *Func = FunctionScopes[N-1]; | |||
318 | // We do not permit pack expansion that would duplicate a statement | |||
319 | // expression, not even within a lambda. | |||
320 | // FIXME: We could probably support this for statement expressions that do | |||
321 | // not contain labels, and for pack expansions that expand both the stmt | |||
322 | // expr and the enclosing lambda. | |||
323 | if (std::any_of( | |||
324 | Func->CompoundScopes.begin(), Func->CompoundScopes.end(), | |||
325 | [](sema::CompoundScopeInfo &CSI) { return CSI.IsStmtExpr; })) | |||
326 | break; | |||
327 | ||||
328 | if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Func)) { | |||
329 | if (N == FunctionScopes.size()) { | |||
330 | for (auto &Param : Unexpanded) { | |||
331 | auto *PD = dyn_cast_or_null<ParmVarDecl>( | |||
332 | Param.first.dyn_cast<NamedDecl *>()); | |||
333 | if (PD && PD->getDeclContext() == LSI->CallOperator) | |||
334 | LambdaParamPackReferences.push_back(Param); | |||
335 | } | |||
336 | } | |||
337 | ||||
338 | // If we have references to a parameter pack of the innermost enclosing | |||
339 | // lambda, only diagnose those ones. We don't know whether any other | |||
340 | // unexpanded parameters referenced herein are actually unexpanded; | |||
341 | // they might be expanded at an outer level. | |||
342 | if (!LambdaParamPackReferences.empty()) { | |||
343 | Unexpanded = LambdaParamPackReferences; | |||
344 | break; | |||
345 | } | |||
346 | ||||
347 | LSI->ContainsUnexpandedParameterPack = true; | |||
348 | return false; | |||
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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 393, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 407, __extension__ __PRETTY_FUNCTION__)); | |||
408 | return DiagnoseUnexpandedParameterPacks(E->getLocStart(), 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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 423, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 460, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 474, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (!Unexpanded.empty() && "Unable to find unexpanded parameter packs" ) ? void (0) : __assert_fail ("!Unexpanded.empty() && \"Unable to find unexpanded parameter packs\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 487, __extension__ __PRETTY_FUNCTION__)); | |||
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?")::llvm::llvm_unreachable_internal("Unhandled template argument kind?" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 565); | |||
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++0x [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 | if (!Pattern->containsUnexpandedParameterPack()) { | |||
608 | Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) | |||
609 | << PatternRange; | |||
610 | return QualType(); | |||
611 | } | |||
612 | ||||
613 | return Context.getPackExpansionType(Pattern, NumExpansions); | |||
614 | } | |||
615 | ||||
616 | ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { | |||
617 | return CheckPackExpansion(Pattern, EllipsisLoc, None); | |||
618 | } | |||
619 | ||||
620 | ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, | |||
621 | Optional<unsigned> NumExpansions) { | |||
622 | if (!Pattern) | |||
623 | return ExprError(); | |||
624 | ||||
625 | // C++0x [temp.variadic]p5: | |||
626 | // The pattern of a pack expansion shall name one or more | |||
627 | // parameter packs that are not expanded by a nested pack | |||
628 | // expansion. | |||
629 | if (!Pattern->containsUnexpandedParameterPack()) { | |||
630 | Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) | |||
631 | << Pattern->getSourceRange(); | |||
632 | return ExprError(); | |||
633 | } | |||
634 | ||||
635 | // Create the pack expansion expression and source-location information. | |||
636 | return new (Context) | |||
637 | PackExpansionExpr(Context.DependentTy, Pattern, EllipsisLoc, NumExpansions); | |||
638 | } | |||
639 | ||||
640 | bool Sema::CheckParameterPacksForExpansion( | |||
641 | SourceLocation EllipsisLoc, SourceRange PatternRange, | |||
642 | ArrayRef<UnexpandedParameterPack> Unexpanded, | |||
643 | const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, | |||
644 | bool &RetainExpansion, Optional<unsigned> &NumExpansions) { | |||
645 | ShouldExpand = true; | |||
646 | RetainExpansion = false; | |||
647 | std::pair<IdentifierInfo *, SourceLocation> FirstPack; | |||
648 | bool HaveFirstPack = false; | |||
649 | ||||
650 | for (ArrayRef<UnexpandedParameterPack>::iterator i = Unexpanded.begin(), | |||
651 | end = Unexpanded.end(); | |||
652 | i != end; ++i) { | |||
| ||||
653 | // Compute the depth and index for this parameter pack. | |||
654 | unsigned Depth = 0, Index = 0; | |||
655 | IdentifierInfo *Name; | |||
656 | bool IsFunctionParameterPack = false; | |||
657 | ||||
658 | if (const TemplateTypeParmType *TTP | |||
659 | = i->first.dyn_cast<const TemplateTypeParmType *>()) { | |||
660 | Depth = TTP->getDepth(); | |||
661 | Index = TTP->getIndex(); | |||
662 | Name = TTP->getIdentifier(); | |||
663 | } else { | |||
664 | NamedDecl *ND = i->first.get<NamedDecl *>(); | |||
665 | if (isa<ParmVarDecl>(ND)) | |||
666 | IsFunctionParameterPack = true; | |||
667 | else | |||
668 | std::tie(Depth, Index) = getDepthAndIndex(ND); | |||
669 | ||||
670 | Name = ND->getIdentifier(); | |||
671 | } | |||
672 | ||||
673 | // Determine the size of this argument pack. | |||
674 | unsigned NewPackSize; | |||
675 | if (IsFunctionParameterPack) { | |||
676 | // Figure out whether we're instantiating to an argument pack or not. | |||
677 | typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; | |||
678 | ||||
679 | llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation | |||
680 | = CurrentInstantiationScope->findInstantiationOf( | |||
| ||||
681 | i->first.get<NamedDecl *>()); | |||
682 | if (Instantiation->is<DeclArgumentPack *>()) { | |||
683 | // We could expand this function parameter pack. | |||
684 | NewPackSize = Instantiation->get<DeclArgumentPack *>()->size(); | |||
685 | } else { | |||
686 | // We can't expand this function parameter pack, so we can't expand | |||
687 | // the pack expansion. | |||
688 | ShouldExpand = false; | |||
689 | continue; | |||
690 | } | |||
691 | } else { | |||
692 | // If we don't have a template argument at this depth/index, then we | |||
693 | // cannot expand the pack expansion. Make a note of this, but we still | |||
694 | // want to check any parameter packs we *do* have arguments for. | |||
695 | if (Depth >= TemplateArgs.getNumLevels() || | |||
696 | !TemplateArgs.hasTemplateArgument(Depth, Index)) { | |||
697 | ShouldExpand = false; | |||
698 | continue; | |||
699 | } | |||
700 | ||||
701 | // Determine the size of the argument pack. | |||
702 | NewPackSize = TemplateArgs(Depth, Index).pack_size(); | |||
703 | } | |||
704 | ||||
705 | // C++0x [temp.arg.explicit]p9: | |||
706 | // Template argument deduction can extend the sequence of template | |||
707 | // arguments corresponding to a template parameter pack, even when the | |||
708 | // sequence contains explicitly specified template arguments. | |||
709 | if (!IsFunctionParameterPack && CurrentInstantiationScope) { | |||
710 | if (NamedDecl *PartialPack | |||
711 | = CurrentInstantiationScope->getPartiallySubstitutedPack()){ | |||
712 | unsigned PartialDepth, PartialIndex; | |||
713 | std::tie(PartialDepth, PartialIndex) = getDepthAndIndex(PartialPack); | |||
714 | if (PartialDepth == Depth && PartialIndex == Index) | |||
715 | RetainExpansion = true; | |||
716 | } | |||
717 | } | |||
718 | ||||
719 | if (!NumExpansions) { | |||
720 | // The is the first pack we've seen for which we have an argument. | |||
721 | // Record it. | |||
722 | NumExpansions = NewPackSize; | |||
723 | FirstPack.first = Name; | |||
724 | FirstPack.second = i->second; | |||
725 | HaveFirstPack = true; | |||
726 | continue; | |||
727 | } | |||
728 | ||||
729 | if (NewPackSize != *NumExpansions) { | |||
730 | // C++0x [temp.variadic]p5: | |||
731 | // All of the parameter packs expanded by a pack expansion shall have | |||
732 | // the same number of arguments specified. | |||
733 | if (HaveFirstPack) | |||
734 | Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict) | |||
735 | << FirstPack.first << Name << *NumExpansions << NewPackSize | |||
736 | << SourceRange(FirstPack.second) << SourceRange(i->second); | |||
737 | else | |||
738 | Diag(EllipsisLoc, diag::err_pack_expansion_length_conflict_multilevel) | |||
739 | << Name << *NumExpansions << NewPackSize | |||
740 | << SourceRange(i->second); | |||
741 | return true; | |||
742 | } | |||
743 | } | |||
744 | ||||
745 | return false; | |||
746 | } | |||
747 | ||||
748 | Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, | |||
749 | const MultiLevelTemplateArgumentList &TemplateArgs) { | |||
750 | QualType Pattern = cast<PackExpansionType>(T)->getPattern(); | |||
751 | SmallVector<UnexpandedParameterPack, 2> Unexpanded; | |||
752 | CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern); | |||
753 | ||||
754 | Optional<unsigned> Result; | |||
755 | for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { | |||
756 | // Compute the depth and index for this parameter pack. | |||
757 | unsigned Depth; | |||
758 | unsigned Index; | |||
759 | ||||
760 | if (const TemplateTypeParmType *TTP | |||
761 | = Unexpanded[I].first.dyn_cast<const TemplateTypeParmType *>()) { | |||
762 | Depth = TTP->getDepth(); | |||
763 | Index = TTP->getIndex(); | |||
764 | } else { | |||
765 | NamedDecl *ND = Unexpanded[I].first.get<NamedDecl *>(); | |||
766 | if (isa<ParmVarDecl>(ND)) { | |||
767 | // Function parameter pack. | |||
768 | typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack; | |||
769 | ||||
770 | llvm::PointerUnion<Decl *, DeclArgumentPack *> *Instantiation | |||
771 | = CurrentInstantiationScope->findInstantiationOf( | |||
772 | Unexpanded[I].first.get<NamedDecl *>()); | |||
773 | if (Instantiation->is<Decl*>()) | |||
774 | // The pattern refers to an unexpanded pack. We're not ready to expand | |||
775 | // this pack yet. | |||
776 | return None; | |||
777 | ||||
778 | unsigned Size = Instantiation->get<DeclArgumentPack *>()->size(); | |||
779 | assert((!Result || *Result == Size) && "inconsistent pack sizes")(static_cast <bool> ((!Result || *Result == Size) && "inconsistent pack sizes") ? void (0) : __assert_fail ("(!Result || *Result == Size) && \"inconsistent pack sizes\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 779, __extension__ __PRETTY_FUNCTION__)); | |||
780 | Result = Size; | |||
781 | continue; | |||
782 | } | |||
783 | ||||
784 | std::tie(Depth, Index) = getDepthAndIndex(ND); | |||
785 | } | |||
786 | if (Depth >= TemplateArgs.getNumLevels() || | |||
787 | !TemplateArgs.hasTemplateArgument(Depth, Index)) | |||
788 | // The pattern refers to an unknown template argument. We're not ready to | |||
789 | // expand this pack yet. | |||
790 | return None; | |||
791 | ||||
792 | // Determine the size of the argument pack. | |||
793 | unsigned Size = TemplateArgs(Depth, Index).pack_size(); | |||
794 | assert((!Result || *Result == Size) && "inconsistent pack sizes")(static_cast <bool> ((!Result || *Result == Size) && "inconsistent pack sizes") ? void (0) : __assert_fail ("(!Result || *Result == Size) && \"inconsistent pack sizes\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 794, __extension__ __PRETTY_FUNCTION__)); | |||
795 | Result = Size; | |||
796 | } | |||
797 | ||||
798 | return Result; | |||
799 | } | |||
800 | ||||
801 | bool Sema::containsUnexpandedParameterPacks(Declarator &D) { | |||
802 | const DeclSpec &DS = D.getDeclSpec(); | |||
803 | switch (DS.getTypeSpecType()) { | |||
804 | case TST_typename: | |||
805 | case TST_typeofType: | |||
806 | case TST_underlyingType: | |||
807 | case TST_atomic: { | |||
808 | QualType T = DS.getRepAsType().get(); | |||
809 | if (!T.isNull() && T->containsUnexpandedParameterPack()) | |||
810 | return true; | |||
811 | break; | |||
812 | } | |||
813 | ||||
814 | case TST_typeofExpr: | |||
815 | case TST_decltype: | |||
816 | if (DS.getRepAsExpr() && | |||
817 | DS.getRepAsExpr()->containsUnexpandedParameterPack()) | |||
818 | return true; | |||
819 | break; | |||
820 | ||||
821 | case TST_unspecified: | |||
822 | case TST_void: | |||
823 | case TST_char: | |||
824 | case TST_wchar: | |||
825 | case TST_char8: | |||
826 | case TST_char16: | |||
827 | case TST_char32: | |||
828 | case TST_int: | |||
829 | case TST_int128: | |||
830 | case TST_half: | |||
831 | case TST_float: | |||
832 | case TST_double: | |||
833 | case TST_Accum: | |||
834 | case TST_Fract: | |||
835 | case TST_Float16: | |||
836 | case TST_float128: | |||
837 | case TST_bool: | |||
838 | case TST_decimal32: | |||
839 | case TST_decimal64: | |||
840 | case TST_decimal128: | |||
841 | case TST_enum: | |||
842 | case TST_union: | |||
843 | case TST_struct: | |||
844 | case TST_interface: | |||
845 | case TST_class: | |||
846 | case TST_auto: | |||
847 | case TST_auto_type: | |||
848 | case TST_decltype_auto: | |||
849 | #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t: | |||
850 | #include "clang/Basic/OpenCLImageTypes.def" | |||
851 | case TST_unknown_anytype: | |||
852 | case TST_error: | |||
853 | break; | |||
854 | } | |||
855 | ||||
856 | for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) { | |||
857 | const DeclaratorChunk &Chunk = D.getTypeObject(I); | |||
858 | switch (Chunk.Kind) { | |||
859 | case DeclaratorChunk::Pointer: | |||
860 | case DeclaratorChunk::Reference: | |||
861 | case DeclaratorChunk::Paren: | |||
862 | case DeclaratorChunk::Pipe: | |||
863 | case DeclaratorChunk::BlockPointer: | |||
864 | // These declarator chunks cannot contain any parameter packs. | |||
865 | break; | |||
866 | ||||
867 | case DeclaratorChunk::Array: | |||
868 | if (Chunk.Arr.NumElts && | |||
869 | Chunk.Arr.NumElts->containsUnexpandedParameterPack()) | |||
870 | return true; | |||
871 | break; | |||
872 | case DeclaratorChunk::Function: | |||
873 | for (unsigned i = 0, e = Chunk.Fun.NumParams; i != e; ++i) { | |||
874 | ParmVarDecl *Param = cast<ParmVarDecl>(Chunk.Fun.Params[i].Param); | |||
875 | QualType ParamTy = Param->getType(); | |||
876 | assert(!ParamTy.isNull() && "Couldn't parse type?")(static_cast <bool> (!ParamTy.isNull() && "Couldn't parse type?" ) ? void (0) : __assert_fail ("!ParamTy.isNull() && \"Couldn't parse type?\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 876, __extension__ __PRETTY_FUNCTION__)); | |||
877 | if (ParamTy->containsUnexpandedParameterPack()) return true; | |||
878 | } | |||
879 | ||||
880 | if (Chunk.Fun.getExceptionSpecType() == EST_Dynamic) { | |||
881 | for (unsigned i = 0; i != Chunk.Fun.getNumExceptions(); ++i) { | |||
882 | if (Chunk.Fun.Exceptions[i] | |||
883 | .Ty.get() | |||
884 | ->containsUnexpandedParameterPack()) | |||
885 | return true; | |||
886 | } | |||
887 | } else if (isComputedNoexcept(Chunk.Fun.getExceptionSpecType()) && | |||
888 | Chunk.Fun.NoexceptExpr->containsUnexpandedParameterPack()) | |||
889 | return true; | |||
890 | ||||
891 | if (Chunk.Fun.hasTrailingReturnType()) { | |||
892 | QualType T = Chunk.Fun.getTrailingReturnType().get(); | |||
893 | if (!T.isNull() && T->containsUnexpandedParameterPack()) | |||
894 | return true; | |||
895 | } | |||
896 | break; | |||
897 | ||||
898 | case DeclaratorChunk::MemberPointer: | |||
899 | if (Chunk.Mem.Scope().getScopeRep() && | |||
900 | Chunk.Mem.Scope().getScopeRep()->containsUnexpandedParameterPack()) | |||
901 | return true; | |||
902 | break; | |||
903 | } | |||
904 | } | |||
905 | ||||
906 | return false; | |||
907 | } | |||
908 | ||||
909 | namespace { | |||
910 | ||||
911 | // Callback to only accept typo corrections that refer to parameter packs. | |||
912 | class ParameterPackValidatorCCC : public CorrectionCandidateCallback { | |||
913 | public: | |||
914 | bool ValidateCandidate(const TypoCorrection &candidate) override { | |||
915 | NamedDecl *ND = candidate.getCorrectionDecl(); | |||
916 | return ND && ND->isParameterPack(); | |||
917 | } | |||
918 | }; | |||
919 | ||||
920 | } | |||
921 | ||||
922 | /// Called when an expression computing the size of a parameter pack | |||
923 | /// is parsed. | |||
924 | /// | |||
925 | /// \code | |||
926 | /// template<typename ...Types> struct count { | |||
927 | /// static const unsigned value = sizeof...(Types); | |||
928 | /// }; | |||
929 | /// \endcode | |||
930 | /// | |||
931 | // | |||
932 | /// \param OpLoc The location of the "sizeof" keyword. | |||
933 | /// \param Name The name of the parameter pack whose size will be determined. | |||
934 | /// \param NameLoc The source location of the name of the parameter pack. | |||
935 | /// \param RParenLoc The location of the closing parentheses. | |||
936 | ExprResult Sema::ActOnSizeofParameterPackExpr(Scope *S, | |||
937 | SourceLocation OpLoc, | |||
938 | IdentifierInfo &Name, | |||
939 | SourceLocation NameLoc, | |||
940 | SourceLocation RParenLoc) { | |||
941 | // C++0x [expr.sizeof]p5: | |||
942 | // The identifier in a sizeof... expression shall name a parameter pack. | |||
943 | LookupResult R(*this, &Name, NameLoc, LookupOrdinaryName); | |||
944 | LookupName(R, S); | |||
945 | ||||
946 | NamedDecl *ParameterPack = nullptr; | |||
947 | switch (R.getResultKind()) { | |||
948 | case LookupResult::Found: | |||
949 | ParameterPack = R.getFoundDecl(); | |||
950 | break; | |||
951 | ||||
952 | case LookupResult::NotFound: | |||
953 | case LookupResult::NotFoundInCurrentInstantiation: | |||
954 | if (TypoCorrection Corrected = | |||
955 | CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, nullptr, | |||
956 | llvm::make_unique<ParameterPackValidatorCCC>(), | |||
957 | CTK_ErrorRecovery)) { | |||
958 | diagnoseTypo(Corrected, | |||
959 | PDiag(diag::err_sizeof_pack_no_pack_name_suggest) << &Name, | |||
960 | PDiag(diag::note_parameter_pack_here)); | |||
961 | ParameterPack = Corrected.getCorrectionDecl(); | |||
962 | } | |||
963 | ||||
964 | case LookupResult::FoundOverloaded: | |||
965 | case LookupResult::FoundUnresolvedValue: | |||
966 | break; | |||
967 | ||||
968 | case LookupResult::Ambiguous: | |||
969 | DiagnoseAmbiguousLookup(R); | |||
970 | return ExprError(); | |||
971 | } | |||
972 | ||||
973 | if (!ParameterPack || !ParameterPack->isParameterPack()) { | |||
974 | Diag(NameLoc, diag::err_sizeof_pack_no_pack_name) | |||
975 | << &Name; | |||
976 | return ExprError(); | |||
977 | } | |||
978 | ||||
979 | MarkAnyDeclReferenced(OpLoc, ParameterPack, true); | |||
980 | ||||
981 | return SizeOfPackExpr::Create(Context, OpLoc, ParameterPack, NameLoc, | |||
982 | RParenLoc); | |||
983 | } | |||
984 | ||||
985 | TemplateArgumentLoc | |||
986 | Sema::getTemplateArgumentPackExpansionPattern( | |||
987 | TemplateArgumentLoc OrigLoc, | |||
988 | SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const { | |||
989 | const TemplateArgument &Argument = OrigLoc.getArgument(); | |||
990 | assert(Argument.isPackExpansion())(static_cast <bool> (Argument.isPackExpansion()) ? void (0) : __assert_fail ("Argument.isPackExpansion()", "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 990, __extension__ __PRETTY_FUNCTION__)); | |||
991 | switch (Argument.getKind()) { | |||
992 | case TemplateArgument::Type: { | |||
993 | // FIXME: We shouldn't ever have to worry about missing | |||
994 | // type-source info! | |||
995 | TypeSourceInfo *ExpansionTSInfo = OrigLoc.getTypeSourceInfo(); | |||
996 | if (!ExpansionTSInfo) | |||
997 | ExpansionTSInfo = Context.getTrivialTypeSourceInfo(Argument.getAsType(), | |||
998 | Ellipsis); | |||
999 | PackExpansionTypeLoc Expansion = | |||
1000 | ExpansionTSInfo->getTypeLoc().castAs<PackExpansionTypeLoc>(); | |||
1001 | Ellipsis = Expansion.getEllipsisLoc(); | |||
1002 | ||||
1003 | TypeLoc Pattern = Expansion.getPatternLoc(); | |||
1004 | NumExpansions = Expansion.getTypePtr()->getNumExpansions(); | |||
1005 | ||||
1006 | // We need to copy the TypeLoc because TemplateArgumentLocs store a | |||
1007 | // TypeSourceInfo. | |||
1008 | // FIXME: Find some way to avoid the copy? | |||
1009 | TypeLocBuilder TLB; | |||
1010 | TLB.pushFullCopy(Pattern); | |||
1011 | TypeSourceInfo *PatternTSInfo = | |||
1012 | TLB.getTypeSourceInfo(Context, Pattern.getType()); | |||
1013 | return TemplateArgumentLoc(TemplateArgument(Pattern.getType()), | |||
1014 | PatternTSInfo); | |||
1015 | } | |||
1016 | ||||
1017 | case TemplateArgument::Expression: { | |||
1018 | PackExpansionExpr *Expansion | |||
1019 | = cast<PackExpansionExpr>(Argument.getAsExpr()); | |||
1020 | Expr *Pattern = Expansion->getPattern(); | |||
1021 | Ellipsis = Expansion->getEllipsisLoc(); | |||
1022 | NumExpansions = Expansion->getNumExpansions(); | |||
1023 | return TemplateArgumentLoc(Pattern, Pattern); | |||
1024 | } | |||
1025 | ||||
1026 | case TemplateArgument::TemplateExpansion: | |||
1027 | Ellipsis = OrigLoc.getTemplateEllipsisLoc(); | |||
1028 | NumExpansions = Argument.getNumTemplateExpansions(); | |||
1029 | return TemplateArgumentLoc(Argument.getPackExpansionPattern(), | |||
1030 | OrigLoc.getTemplateQualifierLoc(), | |||
1031 | OrigLoc.getTemplateNameLoc()); | |||
1032 | ||||
1033 | case TemplateArgument::Declaration: | |||
1034 | case TemplateArgument::NullPtr: | |||
1035 | case TemplateArgument::Template: | |||
1036 | case TemplateArgument::Integral: | |||
1037 | case TemplateArgument::Pack: | |||
1038 | case TemplateArgument::Null: | |||
1039 | return TemplateArgumentLoc(); | |||
1040 | } | |||
1041 | ||||
1042 | llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 1042); | |||
1043 | } | |||
1044 | ||||
1045 | Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) { | |||
1046 | assert(Arg.containsUnexpandedParameterPack())(static_cast <bool> (Arg.containsUnexpandedParameterPack ()) ? void (0) : __assert_fail ("Arg.containsUnexpandedParameterPack()" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 1046, __extension__ __PRETTY_FUNCTION__)); | |||
1047 | ||||
1048 | // If this is a substituted pack, grab that pack. If not, we don't know | |||
1049 | // the size yet. | |||
1050 | // FIXME: We could find a size in more cases by looking for a substituted | |||
1051 | // pack anywhere within this argument, but that's not necessary in the common | |||
1052 | // case for 'sizeof...(A)' handling. | |||
1053 | TemplateArgument Pack; | |||
1054 | switch (Arg.getKind()) { | |||
1055 | case TemplateArgument::Type: | |||
1056 | if (auto *Subst = Arg.getAsType()->getAs<SubstTemplateTypeParmPackType>()) | |||
1057 | Pack = Subst->getArgumentPack(); | |||
1058 | else | |||
1059 | return None; | |||
1060 | break; | |||
1061 | ||||
1062 | case TemplateArgument::Expression: | |||
1063 | if (auto *Subst = | |||
1064 | dyn_cast<SubstNonTypeTemplateParmPackExpr>(Arg.getAsExpr())) | |||
1065 | Pack = Subst->getArgumentPack(); | |||
1066 | else if (auto *Subst = dyn_cast<FunctionParmPackExpr>(Arg.getAsExpr())) { | |||
1067 | for (ParmVarDecl *PD : *Subst) | |||
1068 | if (PD->isParameterPack()) | |||
1069 | return None; | |||
1070 | return Subst->getNumExpansions(); | |||
1071 | } else | |||
1072 | return None; | |||
1073 | break; | |||
1074 | ||||
1075 | case TemplateArgument::Template: | |||
1076 | if (SubstTemplateTemplateParmPackStorage *Subst = | |||
1077 | Arg.getAsTemplate().getAsSubstTemplateTemplateParmPack()) | |||
1078 | Pack = Subst->getArgumentPack(); | |||
1079 | else | |||
1080 | return None; | |||
1081 | break; | |||
1082 | ||||
1083 | case TemplateArgument::Declaration: | |||
1084 | case TemplateArgument::NullPtr: | |||
1085 | case TemplateArgument::TemplateExpansion: | |||
1086 | case TemplateArgument::Integral: | |||
1087 | case TemplateArgument::Pack: | |||
1088 | case TemplateArgument::Null: | |||
1089 | return None; | |||
1090 | } | |||
1091 | ||||
1092 | // Check that no argument in the pack is itself a pack expansion. | |||
1093 | for (TemplateArgument Elem : Pack.pack_elements()) { | |||
1094 | // There's no point recursing in this case; we would have already | |||
1095 | // expanded this pack expansion into the enclosing pack if we could. | |||
1096 | if (Elem.isPackExpansion()) | |||
1097 | return None; | |||
1098 | } | |||
1099 | return Pack.pack_size(); | |||
1100 | } | |||
1101 | ||||
1102 | static void CheckFoldOperand(Sema &S, Expr *E) { | |||
1103 | if (!E) | |||
1104 | return; | |||
1105 | ||||
1106 | E = E->IgnoreImpCasts(); | |||
1107 | auto *OCE = dyn_cast<CXXOperatorCallExpr>(E); | |||
1108 | if ((OCE && OCE->isInfixBinaryOp()) || isa<BinaryOperator>(E) || | |||
1109 | isa<AbstractConditionalOperator>(E)) { | |||
1110 | S.Diag(E->getExprLoc(), diag::err_fold_expression_bad_operand) | |||
1111 | << E->getSourceRange() | |||
1112 | << FixItHint::CreateInsertion(E->getLocStart(), "(") | |||
1113 | << FixItHint::CreateInsertion(E->getLocEnd(), ")"); | |||
1114 | } | |||
1115 | } | |||
1116 | ||||
1117 | ExprResult Sema::ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, | |||
1118 | tok::TokenKind Operator, | |||
1119 | SourceLocation EllipsisLoc, Expr *RHS, | |||
1120 | SourceLocation RParenLoc) { | |||
1121 | // LHS and RHS must be cast-expressions. We allow an arbitrary expression | |||
1122 | // in the parser and reduce down to just cast-expressions here. | |||
1123 | CheckFoldOperand(*this, LHS); | |||
1124 | CheckFoldOperand(*this, RHS); | |||
1125 | ||||
1126 | auto DiscardOperands = [&] { | |||
1127 | CorrectDelayedTyposInExpr(LHS); | |||
1128 | CorrectDelayedTyposInExpr(RHS); | |||
1129 | }; | |||
1130 | ||||
1131 | // [expr.prim.fold]p3: | |||
1132 | // In a binary fold, op1 and op2 shall be the same fold-operator, and | |||
1133 | // either e1 shall contain an unexpanded parameter pack or e2 shall contain | |||
1134 | // an unexpanded parameter pack, but not both. | |||
1135 | if (LHS && RHS && | |||
1136 | LHS->containsUnexpandedParameterPack() == | |||
1137 | RHS->containsUnexpandedParameterPack()) { | |||
1138 | DiscardOperands(); | |||
1139 | return Diag(EllipsisLoc, | |||
1140 | LHS->containsUnexpandedParameterPack() | |||
1141 | ? diag::err_fold_expression_packs_both_sides | |||
1142 | : diag::err_pack_expansion_without_parameter_packs) | |||
1143 | << LHS->getSourceRange() << RHS->getSourceRange(); | |||
1144 | } | |||
1145 | ||||
1146 | // [expr.prim.fold]p2: | |||
1147 | // In a unary fold, the cast-expression shall contain an unexpanded | |||
1148 | // parameter pack. | |||
1149 | if (!LHS || !RHS) { | |||
1150 | Expr *Pack = LHS ? LHS : RHS; | |||
1151 | assert(Pack && "fold expression with neither LHS nor RHS")(static_cast <bool> (Pack && "fold expression with neither LHS nor RHS" ) ? void (0) : __assert_fail ("Pack && \"fold expression with neither LHS nor RHS\"" , "/build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp" , 1151, __extension__ __PRETTY_FUNCTION__)); | |||
1152 | DiscardOperands(); | |||
1153 | if (!Pack->containsUnexpandedParameterPack()) | |||
1154 | return Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) | |||
1155 | << Pack->getSourceRange(); | |||
1156 | } | |||
1157 | ||||
1158 | BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Operator); | |||
1159 | return BuildCXXFoldExpr(LParenLoc, LHS, Opc, EllipsisLoc, RHS, RParenLoc); | |||
1160 | } | |||
1161 | ||||
1162 | ExprResult Sema::BuildCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, | |||
1163 | BinaryOperatorKind Operator, | |||
1164 | SourceLocation EllipsisLoc, Expr *RHS, | |||
1165 | SourceLocation RParenLoc) { | |||
1166 | return new (Context) CXXFoldExpr(Context.DependentTy, LParenLoc, LHS, | |||
1167 | Operator, EllipsisLoc, RHS, RParenLoc); | |||
1168 | } | |||
1169 | ||||
1170 | ExprResult Sema::BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc, | |||
1171 | BinaryOperatorKind Operator) { | |||
1172 | // [temp.variadic]p9: | |||
1173 | // If N is zero for a unary fold-expression, the value of the expression is | |||
1174 | // && -> true | |||
1175 | // || -> false | |||
1176 | // , -> void() | |||
1177 | // if the operator is not listed [above], the instantiation is ill-formed. | |||
1178 | // | |||
1179 | // Note that we need to use something like int() here, not merely 0, to | |||
1180 | // prevent the result from being a null pointer constant. | |||
1181 | QualType ScalarType; | |||
1182 | switch (Operator) { | |||
1183 | case BO_LOr: | |||
1184 | return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_false); | |||
1185 | case BO_LAnd: | |||
1186 | return ActOnCXXBoolLiteral(EllipsisLoc, tok::kw_true); | |||
1187 | case BO_Comma: | |||
1188 | ScalarType = Context.VoidTy; | |||
1189 | break; | |||
1190 | ||||
1191 | default: | |||
1192 | return Diag(EllipsisLoc, diag::err_fold_expression_empty) | |||
1193 | << BinaryOperator::getOpcodeStr(Operator); | |||
1194 | } | |||
1195 | ||||
1196 | return new (Context) CXXScalarValueInitExpr( | |||
1197 | ScalarType, Context.getTrivialTypeSourceInfo(ScalarType, EllipsisLoc), | |||
1198 | EllipsisLoc); | |||
1199 | } |