Bug Summary

File:tools/clang/lib/Sema/SemaTemplateVariadic.cpp
Warning:line 680, column 11
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateVariadic.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn337204/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn337204/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-17-043059-5239-1 -x c++ /build/llvm-toolchain-snapshot-7~svn337204/tools/clang/lib/Sema/SemaTemplateVariadic.cpp
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
23using namespace clang;
24
25//----------------------------------------------------------------------------
26// Visitor that collects unexpanded parameter packs
27//----------------------------------------------------------------------------
28
29/// Retrieve the depth and index of a parameter pack.
30static std::pair<unsigned, unsigned>
31getDepthAndIndex(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
42namespace {
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.
294bool 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.
303bool
304Sema::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
381bool 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
397bool 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
411bool 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
428bool 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
464bool 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
478bool 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
491void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
492 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
493 CollectUnexpandedParameterPacksVisitor(Unexpanded)
494 .TraverseTemplateArgument(Arg);
495}
496
497void Sema::collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
498 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
499 CollectUnexpandedParameterPacksVisitor(Unexpanded)
500 .TraverseTemplateArgumentLoc(Arg);
501}
502
503void Sema::collectUnexpandedParameterPacks(QualType T,
504 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
505 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(T);
506}
507
508void Sema::collectUnexpandedParameterPacks(TypeLoc TL,
509 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
510 CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseTypeLoc(TL);
511}
512
513void Sema::collectUnexpandedParameterPacks(
514 NestedNameSpecifierLoc NNS,
515 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
516 CollectUnexpandedParameterPacksVisitor(Unexpanded)
517 .TraverseNestedNameSpecifierLoc(NNS);
518}
519
520void Sema::collectUnexpandedParameterPacks(
521 const DeclarationNameInfo &NameInfo,
522 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded) {
523 CollectUnexpandedParameterPacksVisitor(Unexpanded)
524 .TraverseDeclarationNameInfo(NameInfo);
525}
526
527
528ParsedTemplateArgument
529Sema::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
568TypeResult 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
582TypeSourceInfo *
583Sema::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
600QualType 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
616ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) {
617 return CheckPackExpansion(Pattern, EllipsisLoc, None);
618}
619
620ExprResult 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
640bool 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(),
2
Loop condition is true. Entering loop body
13
Loop condition is true. Entering loop body
651 end = Unexpanded.end();
652 i != end; ++i) {
1
Assuming 'i' is not equal to 'end'
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
3
Assuming 'TTP' is non-null
4
Taking true branch
14
Assuming 'TTP' is null
15
Taking false branch
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))
16
Taking true branch
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) {
5
Taking false branch
17
Taking true branch
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(
18
Called C++ object pointer is null
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() ||
6
Taking false branch
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) {
7
Assuming the condition is false
8
Assuming pointer value is null
9
Taking false branch
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) {
10
Assuming the condition is false
11
Taking false branch
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) {
12
Taking false branch
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
748Optional<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
801bool 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
909namespace {
910
911// Callback to only accept typo corrections that refer to parameter packs.
912class 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.
936ExprResult 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
985TemplateArgumentLoc
986Sema::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
1045Optional<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
1102static 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
1117ExprResult 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
1162ExprResult 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
1170ExprResult 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}