annotate clang/lib/Sema/SemaTemplateVariadic.cpp @ 207:2e18cbf3894f

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