Bug Summary

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