|
111
|
1 /* Processing rules for constraints.
|
|
|
2 Copyright (C) 2013-2017 Free Software Foundation, Inc.
|
|
|
3 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify
|
|
|
8 it under the terms of the GNU General Public License as published by
|
|
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
|
10 any later version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful,
|
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 GNU General Public License for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "tm.h"
|
|
|
25 #include "timevar.h"
|
|
|
26 #include "hash-set.h"
|
|
|
27 #include "machmode.h"
|
|
|
28 #include "vec.h"
|
|
|
29 #include "double-int.h"
|
|
|
30 #include "input.h"
|
|
|
31 #include "alias.h"
|
|
|
32 #include "symtab.h"
|
|
|
33 #include "wide-int.h"
|
|
|
34 #include "inchash.h"
|
|
|
35 #include "tree.h"
|
|
|
36 #include "stringpool.h"
|
|
|
37 #include "attribs.h"
|
|
|
38 #include "intl.h"
|
|
|
39 #include "flags.h"
|
|
|
40 #include "cp-tree.h"
|
|
|
41 #include "c-family/c-common.h"
|
|
|
42 #include "c-family/c-objc.h"
|
|
|
43 #include "cp-objcp-common.h"
|
|
|
44 #include "tree-inline.h"
|
|
|
45 #include "decl.h"
|
|
|
46 #include "toplev.h"
|
|
|
47 #include "type-utils.h"
|
|
|
48
|
|
|
49 /*---------------------------------------------------------------------------
|
|
|
50 Operations on constraints
|
|
|
51 ---------------------------------------------------------------------------*/
|
|
|
52
|
|
|
53 /* Returns true if C is a constraint tree code. Note that ERROR_MARK
|
|
|
54 is a valid constraint. */
|
|
|
55
|
|
|
56 static inline bool
|
|
|
57 constraint_p (tree_code c)
|
|
|
58 {
|
|
|
59 return ((PRED_CONSTR <= c && c <= DISJ_CONSTR)
|
|
|
60 || c == EXPR_PACK_EXPANSION
|
|
|
61 || c == ERROR_MARK);
|
|
|
62 }
|
|
|
63
|
|
|
64 /* Returns true if T is a constraint. Note that error_mark_node
|
|
|
65 is a valid constraint. */
|
|
|
66
|
|
|
67 bool
|
|
|
68 constraint_p (tree t)
|
|
|
69 {
|
|
|
70 return constraint_p (TREE_CODE (t));
|
|
|
71 }
|
|
|
72
|
|
|
73 /* Returns the conjunction of two constraints A and B. Note that
|
|
|
74 conjoining a non-null constraint with NULL_TREE is an identity
|
|
|
75 operation. That is, for non-null A,
|
|
|
76
|
|
|
77 conjoin_constraints(a, NULL_TREE) == a
|
|
|
78
|
|
|
79 and
|
|
|
80
|
|
|
81 conjoin_constraints (NULL_TREE, a) == a
|
|
|
82
|
|
|
83 If both A and B are NULL_TREE, the result is also NULL_TREE. */
|
|
|
84
|
|
|
85 tree
|
|
|
86 conjoin_constraints (tree a, tree b)
|
|
|
87 {
|
|
|
88 gcc_assert (a ? constraint_p (a) : true);
|
|
|
89 gcc_assert (b ? constraint_p (b) : true);
|
|
|
90 if (a)
|
|
|
91 return b ? build_nt (CONJ_CONSTR, a, b) : a;
|
|
|
92 else if (b)
|
|
|
93 return b;
|
|
|
94 else
|
|
|
95 return NULL_TREE;
|
|
|
96 }
|
|
|
97
|
|
|
98 /* Transform the vector of expressions in the T into a conjunction
|
|
|
99 of requirements. T must be a TREE_VEC. */
|
|
|
100
|
|
|
101 tree
|
|
|
102 conjoin_constraints (tree t)
|
|
|
103 {
|
|
|
104 gcc_assert (TREE_CODE (t) == TREE_VEC);
|
|
|
105 tree r = NULL_TREE;
|
|
|
106 for (int i = 0; i < TREE_VEC_LENGTH (t); ++i)
|
|
|
107 r = conjoin_constraints (r, TREE_VEC_ELT (t, i));
|
|
|
108 return r;
|
|
|
109 }
|
|
|
110
|
|
|
111 /* Returns true if T is a call expression to a function
|
|
|
112 concept. */
|
|
|
113
|
|
|
114 bool
|
|
|
115 function_concept_check_p (tree t)
|
|
|
116 {
|
|
|
117 gcc_assert (TREE_CODE (t) == CALL_EXPR);
|
|
|
118 tree fn = CALL_EXPR_FN (t);
|
|
|
119 if (fn != NULL_TREE
|
|
|
120 && TREE_CODE (fn) == TEMPLATE_ID_EXPR)
|
|
|
121 {
|
|
|
122 tree f1 = OVL_FIRST (TREE_OPERAND (fn, 0));
|
|
|
123 if (TREE_CODE (f1) == TEMPLATE_DECL
|
|
|
124 && DECL_DECLARED_CONCEPT_P (DECL_TEMPLATE_RESULT (f1)))
|
|
|
125 return true;
|
|
|
126 }
|
|
|
127 return false;
|
|
|
128 }
|
|
|
129
|
|
|
130 /* Returns true if any of the arguments in the template
|
|
|
131 argument list is a wildcard or wildcard pack. */
|
|
|
132
|
|
|
133 bool
|
|
|
134 contains_wildcard_p (tree args)
|
|
|
135 {
|
|
|
136 for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
|
|
|
137 {
|
|
|
138 tree arg = TREE_VEC_ELT (args, i);
|
|
|
139 if (TREE_CODE (arg) == WILDCARD_DECL)
|
|
|
140 return true;
|
|
|
141 }
|
|
|
142 return false;
|
|
|
143 }
|
|
|
144
|
|
|
145 /* Build a new call expression, but don't actually generate a
|
|
|
146 new function call. We just want the tree, not the semantics. */
|
|
|
147
|
|
|
148 inline tree
|
|
|
149 build_call_check (tree id)
|
|
|
150 {
|
|
|
151 ++processing_template_decl;
|
|
|
152 vec<tree, va_gc> *fargs = make_tree_vector();
|
|
|
153 tree call = finish_call_expr (id, &fargs, false, false, tf_none);
|
|
|
154 release_tree_vector (fargs);
|
|
|
155 --processing_template_decl;
|
|
|
156 return call;
|
|
|
157 }
|
|
|
158
|
|
|
159 /* Build an expression that will check a variable concept. If any
|
|
|
160 argument contains a wildcard, don't try to finish the variable
|
|
|
161 template because we can't substitute into a non-existent
|
|
|
162 declaration. */
|
|
|
163
|
|
|
164 tree
|
|
|
165 build_variable_check (tree id)
|
|
|
166 {
|
|
|
167 gcc_assert (TREE_CODE (id) == TEMPLATE_ID_EXPR);
|
|
|
168 if (contains_wildcard_p (TREE_OPERAND (id, 1)))
|
|
|
169 return id;
|
|
|
170
|
|
|
171 ++processing_template_decl;
|
|
|
172 tree var = finish_template_variable (id);
|
|
|
173 --processing_template_decl;
|
|
|
174 return var;
|
|
|
175 }
|
|
|
176
|
|
|
177 /*---------------------------------------------------------------------------
|
|
|
178 Resolution of qualified concept names
|
|
|
179 ---------------------------------------------------------------------------*/
|
|
|
180
|
|
|
181 /* This facility is used to resolve constraint checks from
|
|
|
182 requirement expressions. A constraint check is a call to
|
|
|
183 a function template declared with the keyword 'concept'.
|
|
|
184
|
|
|
185 The result of resolution is a pair (a TREE_LIST) whose value
|
|
|
186 is the matched declaration, and whose purpose contains the
|
|
|
187 coerced template arguments that can be substituted into the
|
|
|
188 call. */
|
|
|
189
|
|
|
190 // Given an overload set OVL, try to find a unique definition that can be
|
|
|
191 // instantiated by the template arguments ARGS.
|
|
|
192 //
|
|
|
193 // This function is not called for arbitrary call expressions. In particular,
|
|
|
194 // the call expression must be written with explicit template arguments
|
|
|
195 // and no function arguments. For example:
|
|
|
196 //
|
|
|
197 // f<T, U>()
|
|
|
198 //
|
|
|
199 // If a single match is found, this returns a TREE_LIST whose VALUE
|
|
|
200 // is the constraint function (not the template), and its PURPOSE is
|
|
|
201 // the complete set of arguments substituted into the parameter list.
|
|
|
202 static tree
|
|
|
203 resolve_constraint_check (tree ovl, tree args)
|
|
|
204 {
|
|
|
205 int nerrs = 0;
|
|
|
206 tree cands = NULL_TREE;
|
|
|
207 for (lkp_iterator iter (ovl); iter; ++iter)
|
|
|
208 {
|
|
|
209 // Get the next template overload.
|
|
|
210 tree tmpl = *iter;
|
|
|
211 if (TREE_CODE (tmpl) != TEMPLATE_DECL)
|
|
|
212 continue;
|
|
|
213
|
|
|
214 // Don't try to deduce checks for non-concepts. We often
|
|
|
215 // end up trying to resolve constraints in functional casts
|
|
|
216 // as part of a postfix-expression. We can save time and
|
|
|
217 // headaches by not instantiating those declarations.
|
|
|
218 //
|
|
|
219 // NOTE: This masks a potential error, caused by instantiating
|
|
|
220 // non-deduced contexts using placeholder arguments.
|
|
|
221 tree fn = DECL_TEMPLATE_RESULT (tmpl);
|
|
|
222 if (DECL_ARGUMENTS (fn))
|
|
|
223 continue;
|
|
|
224 if (!DECL_DECLARED_CONCEPT_P (fn))
|
|
|
225 continue;
|
|
|
226
|
|
|
227 // Remember the candidate if we can deduce a substitution.
|
|
|
228 ++processing_template_decl;
|
|
|
229 tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
|
|
|
230 if (tree subst = coerce_template_parms (parms, args, tmpl))
|
|
|
231 {
|
|
|
232 if (subst == error_mark_node)
|
|
|
233 ++nerrs;
|
|
|
234 else
|
|
|
235 cands = tree_cons (subst, fn, cands);
|
|
|
236 }
|
|
|
237 --processing_template_decl;
|
|
|
238 }
|
|
|
239
|
|
|
240 if (!cands)
|
|
|
241 /* We either had no candidates or failed deductions. */
|
|
|
242 return nerrs ? error_mark_node : NULL_TREE;
|
|
|
243 else if (TREE_CHAIN (cands))
|
|
|
244 /* There are multiple candidates. */
|
|
|
245 return error_mark_node;
|
|
|
246
|
|
|
247 return cands;
|
|
|
248 }
|
|
|
249
|
|
|
250 // Determine if the the call expression CALL is a constraint check, and
|
|
|
251 // return the concept declaration and arguments being checked. If CALL
|
|
|
252 // does not denote a constraint check, return NULL.
|
|
|
253 tree
|
|
|
254 resolve_constraint_check (tree call)
|
|
|
255 {
|
|
|
256 gcc_assert (TREE_CODE (call) == CALL_EXPR);
|
|
|
257
|
|
|
258 // A constraint check must be only a template-id expression. If
|
|
|
259 // it's a call to a base-link, its function(s) should be a
|
|
|
260 // template-id expression. If this is not a template-id, then it
|
|
|
261 // cannot be a concept-check.
|
|
|
262 tree target = CALL_EXPR_FN (call);
|
|
|
263 if (BASELINK_P (target))
|
|
|
264 target = BASELINK_FUNCTIONS (target);
|
|
|
265 if (TREE_CODE (target) != TEMPLATE_ID_EXPR)
|
|
|
266 return NULL_TREE;
|
|
|
267
|
|
|
268 // Get the overload set and template arguments and try to
|
|
|
269 // resolve the target.
|
|
|
270 tree ovl = TREE_OPERAND (target, 0);
|
|
|
271
|
|
|
272 /* This is a function call of a variable concept... ill-formed. */
|
|
|
273 if (TREE_CODE (ovl) == TEMPLATE_DECL)
|
|
|
274 {
|
|
|
275 error_at (location_of (call),
|
|
|
276 "function call of variable concept %qE", call);
|
|
|
277 return error_mark_node;
|
|
|
278 }
|
|
|
279
|
|
|
280 tree args = TREE_OPERAND (target, 1);
|
|
|
281 return resolve_constraint_check (ovl, args);
|
|
|
282 }
|
|
|
283
|
|
|
284 /* Returns a pair containing the checked variable concept
|
|
|
285 and its associated prototype parameter. The result
|
|
|
286 is a TREE_LIST whose TREE_VALUE is the variable concept
|
|
|
287 and whose TREE_PURPOSE is the prototype parameter. */
|
|
|
288
|
|
|
289 tree
|
|
|
290 resolve_variable_concept_check (tree id)
|
|
|
291 {
|
|
|
292 tree tmpl = TREE_OPERAND (id, 0);
|
|
|
293 tree args = TREE_OPERAND (id, 1);
|
|
|
294
|
|
|
295 if (!variable_concept_p (tmpl))
|
|
|
296 return NULL_TREE;
|
|
|
297
|
|
|
298 /* Make sure that we have the right parameters before
|
|
|
299 assuming that it works. Note that failing to deduce
|
|
|
300 will result in diagnostics. */
|
|
|
301 tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
|
|
|
302 ++processing_template_decl;
|
|
|
303 tree result = coerce_template_parms (parms, args, tmpl);
|
|
|
304 --processing_template_decl;
|
|
|
305 if (result != error_mark_node)
|
|
|
306 {
|
|
|
307 tree decl = DECL_TEMPLATE_RESULT (tmpl);
|
|
|
308 return build_tree_list (result, decl);
|
|
|
309 }
|
|
|
310 else
|
|
|
311 return error_mark_node;
|
|
|
312 }
|
|
|
313
|
|
|
314
|
|
|
315 /* Given a call expression or template-id expression to
|
|
|
316 a concept EXPR possibly including a wildcard, deduce
|
|
|
317 the concept being checked and the prototype parameter.
|
|
|
318 Returns true if the constraint and prototype can be
|
|
|
319 deduced and false otherwise. Note that the CHECK and
|
|
|
320 PROTO arguments are set to NULL_TREE if this returns
|
|
|
321 false. */
|
|
|
322
|
|
|
323 bool
|
|
|
324 deduce_constrained_parameter (tree expr, tree& check, tree& proto)
|
|
|
325 {
|
|
|
326 tree info = NULL_TREE;
|
|
|
327 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
|
|
|
328 info = resolve_variable_concept_check (expr);
|
|
|
329 else if (TREE_CODE (expr) == CALL_EXPR)
|
|
|
330 info = resolve_constraint_check (expr);
|
|
|
331 else
|
|
|
332 gcc_unreachable ();
|
|
|
333
|
|
|
334 if (info && info != error_mark_node)
|
|
|
335 {
|
|
|
336 check = TREE_VALUE (info);
|
|
|
337 tree arg = TREE_VEC_ELT (TREE_PURPOSE (info), 0);
|
|
|
338 if (ARGUMENT_PACK_P (arg))
|
|
|
339 arg = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0);
|
|
|
340 proto = TREE_TYPE (arg);
|
|
|
341 return true;
|
|
|
342 }
|
|
|
343 check = proto = NULL_TREE;
|
|
|
344 return false;
|
|
|
345 }
|
|
|
346
|
|
|
347 // Given a call expression or template-id expression to a concept, EXPR,
|
|
|
348 // deduce the concept being checked and return the template arguments.
|
|
|
349 // Returns NULL_TREE if deduction fails.
|
|
|
350 static tree
|
|
|
351 deduce_concept_introduction (tree expr)
|
|
|
352 {
|
|
|
353 tree info = NULL_TREE;
|
|
|
354 if (TREE_CODE (expr) == TEMPLATE_ID_EXPR)
|
|
|
355 info = resolve_variable_concept_check (expr);
|
|
|
356 else if (TREE_CODE (expr) == CALL_EXPR)
|
|
|
357 info = resolve_constraint_check (expr);
|
|
|
358 else
|
|
|
359 gcc_unreachable ();
|
|
|
360
|
|
|
361 if (info && info != error_mark_node)
|
|
|
362 return TREE_PURPOSE (info);
|
|
|
363 return NULL_TREE;
|
|
|
364 }
|
|
|
365
|
|
|
366 namespace {
|
|
|
367
|
|
|
368 /*---------------------------------------------------------------------------
|
|
|
369 Constraint implication learning
|
|
|
370 ---------------------------------------------------------------------------*/
|
|
|
371
|
|
|
372 /* The implication context determines how we memoize concept checks.
|
|
|
373 Given two checks C1 and C2, the direction of implication depends
|
|
|
374 on whether we are learning implications of a conjunction or disjunction.
|
|
|
375 For example:
|
|
|
376
|
|
|
377 template<typename T> concept bool C = ...;
|
|
|
378 template<typenaem T> concept bool D = C<T> && true;
|
|
|
379
|
|
|
380 From this, we can learn that D<T> implies C<T>. We cannot learn,
|
|
|
381 without further testing, that C<T> does not imply D<T>. If, for
|
|
|
382 example, C<T> were defined as true, then these constraints would
|
|
|
383 be logically equivalent.
|
|
|
384
|
|
|
385 In rare cases, we may start with a logical equivalence. For example:
|
|
|
386
|
|
|
387 template<typename T> concept bool C = ...;
|
|
|
388 template<typename T> concept bool D = C<T>;
|
|
|
389
|
|
|
390 Here, we learn that C<T> implies D<T> and vice versa. */
|
|
|
391
|
|
|
392 enum implication_context
|
|
|
393 {
|
|
|
394 conjunction_cxt, /* C1 implies C2. */
|
|
|
395 disjunction_cxt, /* C2 implies C1. */
|
|
|
396 equivalence_cxt /* C1 implies C2, C2 implies C1. */
|
|
|
397 };
|
|
|
398
|
|
|
399 void learn_implications(tree, tree, implication_context);
|
|
|
400
|
|
|
401 void
|
|
|
402 learn_implication (tree parent, tree child, implication_context cxt)
|
|
|
403 {
|
|
|
404 switch (cxt)
|
|
|
405 {
|
|
|
406 case conjunction_cxt:
|
|
|
407 save_subsumption_result (parent, child, true);
|
|
|
408 break;
|
|
|
409 case disjunction_cxt:
|
|
|
410 save_subsumption_result (child, parent, true);
|
|
|
411 break;
|
|
|
412 case equivalence_cxt:
|
|
|
413 save_subsumption_result (parent, child, true);
|
|
|
414 save_subsumption_result (child, parent, true);
|
|
|
415 break;
|
|
|
416 }
|
|
|
417 }
|
|
|
418
|
|
|
419 void
|
|
|
420 learn_logical_operation (tree parent, tree constr, implication_context cxt)
|
|
|
421 {
|
|
|
422 learn_implications (parent, TREE_OPERAND (constr, 0), cxt);
|
|
|
423 learn_implications (parent, TREE_OPERAND (constr, 1), cxt);
|
|
|
424 }
|
|
|
425
|
|
|
426 void
|
|
|
427 learn_implications (tree parent, tree constr, implication_context cxt)
|
|
|
428 {
|
|
|
429 switch (TREE_CODE (constr))
|
|
|
430 {
|
|
|
431 case CHECK_CONSTR:
|
|
|
432 return learn_implication (parent, constr, cxt);
|
|
|
433
|
|
|
434 case CONJ_CONSTR:
|
|
|
435 if (cxt == disjunction_cxt)
|
|
|
436 return;
|
|
|
437 return learn_logical_operation (parent, constr, cxt);
|
|
|
438
|
|
|
439 case DISJ_CONSTR:
|
|
|
440 if (cxt == conjunction_cxt)
|
|
|
441 return;
|
|
|
442 return learn_logical_operation (parent, constr, cxt);
|
|
|
443
|
|
|
444 default:
|
|
|
445 break;
|
|
|
446 }
|
|
|
447 }
|
|
|
448
|
|
|
449 /* Quickly scan the top-level constraints of CONSTR to learn and
|
|
|
450 cache logical relations between concepts. The search does not
|
|
|
451 include conjunctions of disjunctions or vice versa. */
|
|
|
452
|
|
|
453 void
|
|
|
454 learn_implications (tree tmpl, tree args, tree constr)
|
|
|
455 {
|
|
|
456 /* Don't memoize relations between non-dependent arguemnts. It's not
|
|
|
457 helpful. */
|
|
|
458 if (!uses_template_parms (args))
|
|
|
459 return;
|
|
|
460
|
|
|
461 /* Build a check constraint for the purpose of caching. */
|
|
|
462 tree parent = build_nt (CHECK_CONSTR, tmpl, args);
|
|
|
463
|
|
|
464 /* Start learning based on the kind of the top-level contraint. */
|
|
|
465 if (TREE_CODE (constr) == CONJ_CONSTR)
|
|
|
466 return learn_logical_operation (parent, constr, conjunction_cxt);
|
|
|
467 else if (TREE_CODE (constr) == DISJ_CONSTR)
|
|
|
468 return learn_logical_operation (parent, constr, disjunction_cxt);
|
|
|
469 else if (TREE_CODE (constr) == CHECK_CONSTR)
|
|
|
470 /* This is the rare concept alias case. */
|
|
|
471 return learn_implication (parent, constr, equivalence_cxt);
|
|
|
472 }
|
|
|
473
|
|
|
474 /*---------------------------------------------------------------------------
|
|
|
475 Expansion of concept definitions
|
|
|
476 ---------------------------------------------------------------------------*/
|
|
|
477
|
|
|
478 /* Returns the expression of a function concept. */
|
|
|
479
|
|
|
480 tree
|
|
|
481 get_returned_expression (tree fn)
|
|
|
482 {
|
|
|
483 /* Extract the body of the function minus the return expression. */
|
|
|
484 tree body = DECL_SAVED_TREE (fn);
|
|
|
485 if (!body)
|
|
|
486 return error_mark_node;
|
|
|
487 if (TREE_CODE (body) == BIND_EXPR)
|
|
|
488 body = BIND_EXPR_BODY (body);
|
|
|
489 if (TREE_CODE (body) != RETURN_EXPR)
|
|
|
490 return error_mark_node;
|
|
|
491
|
|
|
492 return TREE_OPERAND (body, 0);
|
|
|
493 }
|
|
|
494
|
|
|
495 /* Returns the initializer of a variable concept. */
|
|
|
496
|
|
|
497 tree
|
|
|
498 get_variable_initializer (tree var)
|
|
|
499 {
|
|
|
500 tree init = DECL_INITIAL (var);
|
|
|
501 if (!init)
|
|
|
502 return error_mark_node;
|
|
|
503 return init;
|
|
|
504 }
|
|
|
505
|
|
|
506 /* Returns the definition of a variable or function concept. */
|
|
|
507
|
|
|
508 tree
|
|
|
509 get_concept_definition (tree decl)
|
|
|
510 {
|
|
|
511 if (VAR_P (decl))
|
|
|
512 return get_variable_initializer (decl);
|
|
|
513 else if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
514 return get_returned_expression (decl);
|
|
|
515 gcc_unreachable ();
|
|
|
516 }
|
|
|
517
|
|
|
518 int expansion_level = 0;
|
|
|
519
|
|
|
520 struct expanding_concept_sentinel
|
|
|
521 {
|
|
|
522 expanding_concept_sentinel ()
|
|
|
523 {
|
|
|
524 ++expansion_level;
|
|
|
525 }
|
|
|
526
|
|
|
527 ~expanding_concept_sentinel()
|
|
|
528 {
|
|
|
529 --expansion_level;
|
|
|
530 }
|
|
|
531 };
|
|
|
532
|
|
|
533
|
|
|
534 } /* namespace */
|
|
|
535
|
|
|
536 /* Returns true when a concept is being expanded. */
|
|
|
537
|
|
|
538 bool
|
|
|
539 expanding_concept()
|
|
|
540 {
|
|
|
541 return expansion_level > 0;
|
|
|
542 }
|
|
|
543
|
|
|
544 /* Expand a concept declaration (not a template) and its arguments to
|
|
|
545 a constraint defined by the concept's initializer or definition. */
|
|
|
546
|
|
|
547 tree
|
|
|
548 expand_concept (tree decl, tree args)
|
|
|
549 {
|
|
|
550 expanding_concept_sentinel sentinel;
|
|
|
551
|
|
|
552 if (TREE_CODE (decl) == TEMPLATE_DECL)
|
|
|
553 decl = DECL_TEMPLATE_RESULT (decl);
|
|
|
554 tree tmpl = DECL_TI_TEMPLATE (decl);
|
|
|
555
|
|
|
556 /* Check for a previous specialization. */
|
|
|
557 if (tree spec = get_concept_expansion (tmpl, args))
|
|
|
558 return spec;
|
|
|
559
|
|
|
560 /* Substitute the arguments to form a new definition expression. */
|
|
|
561 tree def = get_concept_definition (decl);
|
|
|
562
|
|
|
563 ++processing_template_decl;
|
|
|
564 tree result = tsubst_expr (def, args, tf_none, NULL_TREE, true);
|
|
|
565 --processing_template_decl;
|
|
|
566 if (result == error_mark_node)
|
|
|
567 return error_mark_node;
|
|
|
568
|
|
|
569 /* And lastly, normalize it, check for implications, and save
|
|
|
570 the specialization for later. */
|
|
|
571 tree norm = normalize_expression (result);
|
|
|
572 learn_implications (tmpl, args, norm);
|
|
|
573 return save_concept_expansion (tmpl, args, norm);
|
|
|
574 }
|
|
|
575
|
|
|
576
|
|
|
577 /*---------------------------------------------------------------------------
|
|
|
578 Stepwise normalization of expressions
|
|
|
579
|
|
|
580 This set of functions will transform an expression into a constraint
|
|
|
581 in a sequence of steps. Normalization does not not look into concept
|
|
|
582 definitions.
|
|
|
583 ---------------------------------------------------------------------------*/
|
|
|
584
|
|
|
585 /* Transform a logical-or or logical-and expression into either
|
|
|
586 a conjunction or disjunction. */
|
|
|
587
|
|
|
588 tree
|
|
|
589 normalize_logical_operation (tree t, tree_code c)
|
|
|
590 {
|
|
|
591 tree t0 = normalize_expression (TREE_OPERAND (t, 0));
|
|
|
592 tree t1 = normalize_expression (TREE_OPERAND (t, 1));
|
|
|
593 return build_nt (c, t0, t1);
|
|
|
594 }
|
|
|
595
|
|
|
596 /* A simple requirement T introduces an expression constraint
|
|
|
597 for its expression. */
|
|
|
598
|
|
|
599 inline tree
|
|
|
600 normalize_simple_requirement (tree t)
|
|
|
601 {
|
|
|
602 return build_nt (EXPR_CONSTR, TREE_OPERAND (t, 0));
|
|
|
603 }
|
|
|
604
|
|
|
605 /* A type requirement T introduce a type constraint for its type. */
|
|
|
606
|
|
|
607 inline tree
|
|
|
608 normalize_type_requirement (tree t)
|
|
|
609 {
|
|
|
610 return build_nt (TYPE_CONSTR, TREE_OPERAND (t, 0));
|
|
|
611 }
|
|
|
612
|
|
|
613 /* A compound requirement T introduces a conjunction of constraints
|
|
|
614 depending on its form. The conjunction always includes an
|
|
|
615 expression constraint for the expression of the requirement.
|
|
|
616 If a trailing return type was specified, the conjunction includes
|
|
|
617 either an implicit conversion constraint or an argument deduction
|
|
|
618 constraint. If the noexcept specifier is present, the conjunction
|
|
|
619 includes an exception constraint. */
|
|
|
620
|
|
|
621 tree
|
|
|
622 normalize_compound_requirement (tree t)
|
|
|
623 {
|
|
|
624 tree expr = TREE_OPERAND (t, 0);
|
|
|
625 tree constr = build_nt (EXPR_CONSTR, TREE_OPERAND (t, 0));
|
|
|
626
|
|
|
627 /* If a type is given, append an implicit conversion or
|
|
|
628 argument deduction constraint. */
|
|
|
629 if (tree type = TREE_OPERAND (t, 1))
|
|
|
630 {
|
|
|
631 tree type_constr;
|
|
|
632 /* TODO: We should be extracting a list of auto nodes
|
|
|
633 from type_uses_auto, not a single node */
|
|
|
634 if (tree placeholder = type_uses_auto (type))
|
|
|
635 type_constr = build_nt (DEDUCT_CONSTR, expr, type, placeholder);
|
|
|
636 else
|
|
|
637 type_constr = build_nt (ICONV_CONSTR, expr, type);
|
|
|
638 constr = conjoin_constraints (constr, type_constr);
|
|
|
639 }
|
|
|
640
|
|
|
641 /* If noexcept is present, append an exception constraint. */
|
|
|
642 if (COMPOUND_REQ_NOEXCEPT_P (t))
|
|
|
643 {
|
|
|
644 tree except = build_nt (EXCEPT_CONSTR, expr);
|
|
|
645 constr = conjoin_constraints (constr, except);
|
|
|
646 }
|
|
|
647
|
|
|
648 return constr;
|
|
|
649 }
|
|
|
650
|
|
|
651 /* A nested requirement T introduces a conjunction of constraints
|
|
|
652 corresponding to its constraint-expression.
|
|
|
653
|
|
|
654 If the result of transforming T is error_mark_node, the resulting
|
|
|
655 constraint is a predicate constraint whose operand is also
|
|
|
656 error_mark_node. This preserves the constraint structure, but
|
|
|
657 will guarantee that the constraint is never satisfied. */
|
|
|
658
|
|
|
659 inline tree
|
|
|
660 normalize_nested_requirement (tree t)
|
|
|
661 {
|
|
|
662 return normalize_expression (TREE_OPERAND (t, 0));
|
|
|
663 }
|
|
|
664
|
|
|
665 /* Transform a requirement T into one or more constraints. */
|
|
|
666
|
|
|
667 tree
|
|
|
668 normalize_requirement (tree t)
|
|
|
669 {
|
|
|
670 switch (TREE_CODE (t))
|
|
|
671 {
|
|
|
672 case SIMPLE_REQ:
|
|
|
673 return normalize_simple_requirement (t);
|
|
|
674
|
|
|
675 case TYPE_REQ:
|
|
|
676 return normalize_type_requirement (t);
|
|
|
677
|
|
|
678 case COMPOUND_REQ:
|
|
|
679 return normalize_compound_requirement (t);
|
|
|
680
|
|
|
681 case NESTED_REQ:
|
|
|
682 return normalize_nested_requirement (t);
|
|
|
683
|
|
|
684 default:
|
|
|
685 gcc_unreachable ();
|
|
|
686 }
|
|
|
687 return error_mark_node;
|
|
|
688 }
|
|
|
689
|
|
|
690 /* Transform a sequence of requirements into a conjunction of
|
|
|
691 constraints. */
|
|
|
692
|
|
|
693 tree
|
|
|
694 normalize_requirements (tree t)
|
|
|
695 {
|
|
|
696 tree result = NULL_TREE;
|
|
|
697 for (; t; t = TREE_CHAIN (t))
|
|
|
698 {
|
|
|
699 tree constr = normalize_requirement (TREE_VALUE (t));
|
|
|
700 result = conjoin_constraints (result, constr);
|
|
|
701 }
|
|
|
702 return result;
|
|
|
703 }
|
|
|
704
|
|
|
705 /* The normal form of a requires-expression is a parameterized
|
|
|
706 constraint having the same parameters and a conjunction of
|
|
|
707 constraints representing the normal form of requirements. */
|
|
|
708
|
|
|
709 tree
|
|
|
710 normalize_requires_expression (tree t)
|
|
|
711 {
|
|
|
712 tree operand = normalize_requirements (TREE_OPERAND (t, 1));
|
|
|
713 if (tree parms = TREE_OPERAND (t, 0))
|
|
|
714 return build_nt (PARM_CONSTR, parms, operand);
|
|
|
715 else
|
|
|
716 return operand;
|
|
|
717 }
|
|
|
718
|
|
|
719 /* For a template-id referring to a variable concept, returns
|
|
|
720 a check constraint. Otherwise, returns a predicate constraint. */
|
|
|
721
|
|
|
722 tree
|
|
|
723 normalize_template_id_expression (tree t)
|
|
|
724 {
|
|
|
725 if (tree info = resolve_variable_concept_check (t))
|
|
|
726 {
|
|
|
727 if (info == error_mark_node)
|
|
|
728 {
|
|
|
729 /* We get this when the template arguments don't match
|
|
|
730 the variable concept. */
|
|
|
731 error ("invalid reference to concept %qE", t);
|
|
|
732 return error_mark_node;
|
|
|
733 }
|
|
|
734
|
|
|
735 tree decl = TREE_VALUE (info);
|
|
|
736 tree args = TREE_PURPOSE (info);
|
|
|
737 return build_nt (CHECK_CONSTR, decl, args);
|
|
|
738 }
|
|
|
739
|
|
|
740 /* Check that we didn't refer to a function concept like a variable. */
|
|
|
741 tree fn = OVL_FIRST (TREE_OPERAND (t, 0));
|
|
|
742 if (TREE_CODE (fn) == TEMPLATE_DECL
|
|
|
743 && DECL_DECLARED_CONCEPT_P (DECL_TEMPLATE_RESULT (fn)))
|
|
|
744 {
|
|
|
745 error_at (location_of (t),
|
|
|
746 "invalid reference to function concept %qD", fn);
|
|
|
747 return error_mark_node;
|
|
|
748 }
|
|
|
749
|
|
|
750 return build_nt (PRED_CONSTR, t);
|
|
|
751 }
|
|
|
752
|
|
|
753 /* For a call expression to a function concept, returns a check
|
|
|
754 constraint. Otherwise, returns a predicate constraint. */
|
|
|
755
|
|
|
756 tree
|
|
|
757 normalize_call_expression (tree t)
|
|
|
758 {
|
|
|
759 /* Try to resolve this function call as a concept. If not, then
|
|
|
760 it can be returned as a predicate constraint. */
|
|
|
761 tree check = resolve_constraint_check (t);
|
|
|
762 if (!check)
|
|
|
763 return build_nt (PRED_CONSTR, t);
|
|
|
764 if (check == error_mark_node)
|
|
|
765 {
|
|
|
766 /* TODO: Improve diagnostics. We could report why the reference
|
|
|
767 is invalid. */
|
|
|
768 error ("invalid reference to concept %qE", t);
|
|
|
769 return error_mark_node;
|
|
|
770 }
|
|
|
771
|
|
|
772 tree fn = TREE_VALUE (check);
|
|
|
773 tree args = TREE_PURPOSE (check);
|
|
|
774 return build_nt (CHECK_CONSTR, fn, args);
|
|
|
775 }
|
|
|
776
|
|
|
777 /* If T is a call to an overloaded && or || operator, diagnose that
|
|
|
778 as a non-SFINAEable error. Returns true if an error is emitted.
|
|
|
779
|
|
|
780 TODO: It would be better to diagnose this at the point of definition,
|
|
|
781 if possible. Perhaps we should immediately do a first-pass normalization
|
|
|
782 of a concept definition to catch obvious non-dependent errors like
|
|
|
783 this. */
|
|
|
784
|
|
|
785 bool
|
|
|
786 check_for_logical_overloads (tree t)
|
|
|
787 {
|
|
|
788 if (TREE_CODE (t) != CALL_EXPR)
|
|
|
789 return false;
|
|
|
790
|
|
|
791 tree fn = CALL_EXPR_FN (t);
|
|
|
792
|
|
|
793 /* For member calls, try extracting the function from the
|
|
|
794 component ref. */
|
|
|
795 if (TREE_CODE (fn) == COMPONENT_REF)
|
|
|
796 {
|
|
|
797 fn = TREE_OPERAND (fn, 1);
|
|
|
798 if (TREE_CODE (fn) == BASELINK)
|
|
|
799 fn = BASELINK_FUNCTIONS (fn);
|
|
|
800 }
|
|
|
801
|
|
|
802 if (TREE_CODE (fn) != FUNCTION_DECL)
|
|
|
803 return false;
|
|
|
804
|
|
|
805 if (DECL_OVERLOADED_OPERATOR_P (fn))
|
|
|
806 {
|
|
|
807 location_t loc = EXPR_LOC_OR_LOC (t, input_location);
|
|
|
808 error_at (loc, "constraint %qE, uses overloaded operator", t);
|
|
|
809 return true;
|
|
|
810 }
|
|
|
811
|
|
|
812 return false;
|
|
|
813 }
|
|
|
814
|
|
|
815 /* The normal form of an atom depends on the expression. The normal
|
|
|
816 form of a function call to a function concept is a check constraint
|
|
|
817 for that concept. The normal form of a reference to a variable
|
|
|
818 concept is a check constraint for that concept. Otherwise, the
|
|
|
819 constraint is a predicate constraint. */
|
|
|
820
|
|
|
821 tree
|
|
|
822 normalize_atom (tree t)
|
|
|
823 {
|
|
|
824 /* We can get constraints pushed down through pack expansions, so
|
|
|
825 just return them. */
|
|
|
826 if (constraint_p (t))
|
|
|
827 return t;
|
|
|
828
|
|
|
829 tree type = TREE_TYPE (t);
|
|
|
830 if (!type || type_unknown_p (t) || TREE_CODE (type) == TEMPLATE_TYPE_PARM)
|
|
|
831 ;
|
|
|
832 else if (!dependent_type_p (type))
|
|
|
833 {
|
|
|
834 if (check_for_logical_overloads (t))
|
|
|
835 return error_mark_node;
|
|
|
836
|
|
|
837 type = cv_unqualified (type);
|
|
|
838 if (!same_type_p (type, boolean_type_node))
|
|
|
839 {
|
|
|
840 error ("predicate constraint %q+E does not have type %<bool%>", t);
|
|
|
841 return error_mark_node;
|
|
|
842 }
|
|
|
843 }
|
|
|
844
|
|
|
845 if (TREE_CODE (t) == TEMPLATE_ID_EXPR)
|
|
|
846 return normalize_template_id_expression (t);
|
|
|
847 if (TREE_CODE (t) == CALL_EXPR)
|
|
|
848 return normalize_call_expression (t);
|
|
|
849 return build_nt (PRED_CONSTR, t);
|
|
|
850 }
|
|
|
851
|
|
|
852 /* Push down the pack expansion EXP into the leaves of the constraint PAT. */
|
|
|
853
|
|
|
854 tree
|
|
|
855 push_down_pack_expansion (tree exp, tree pat)
|
|
|
856 {
|
|
|
857 switch (TREE_CODE (pat))
|
|
|
858 {
|
|
|
859 case CONJ_CONSTR:
|
|
|
860 case DISJ_CONSTR:
|
|
|
861 {
|
|
|
862 pat = copy_node (pat);
|
|
|
863 TREE_OPERAND (pat, 0)
|
|
|
864 = push_down_pack_expansion (exp, TREE_OPERAND (pat, 0));
|
|
|
865 TREE_OPERAND (pat, 1)
|
|
|
866 = push_down_pack_expansion (exp, TREE_OPERAND (pat, 1));
|
|
|
867 return pat;
|
|
|
868 }
|
|
|
869 default:
|
|
|
870 {
|
|
|
871 exp = copy_node (exp);
|
|
|
872 SET_PACK_EXPANSION_PATTERN (exp, pat);
|
|
|
873 return exp;
|
|
|
874 }
|
|
|
875 }
|
|
|
876 }
|
|
|
877
|
|
|
878 /* Transform a pack expansion into a constraint. First we transform the
|
|
|
879 pattern of the pack expansion, then we push the pack expansion down into the
|
|
|
880 leaves of the constraint so that partial ordering will work. */
|
|
|
881
|
|
|
882 tree
|
|
|
883 normalize_pack_expansion (tree t)
|
|
|
884 {
|
|
|
885 tree pat = normalize_expression (PACK_EXPANSION_PATTERN (t));
|
|
|
886 return push_down_pack_expansion (t, pat);
|
|
|
887 }
|
|
|
888
|
|
|
889 /* Transform an expression into a constraint. */
|
|
|
890
|
|
|
891 tree
|
|
|
892 normalize_any_expression (tree t)
|
|
|
893 {
|
|
|
894 switch (TREE_CODE (t))
|
|
|
895 {
|
|
|
896 case TRUTH_ANDIF_EXPR:
|
|
|
897 return normalize_logical_operation (t, CONJ_CONSTR);
|
|
|
898
|
|
|
899 case TRUTH_ORIF_EXPR:
|
|
|
900 return normalize_logical_operation (t, DISJ_CONSTR);
|
|
|
901
|
|
|
902 case REQUIRES_EXPR:
|
|
|
903 return normalize_requires_expression (t);
|
|
|
904
|
|
|
905 case BIND_EXPR:
|
|
|
906 return normalize_expression (BIND_EXPR_BODY (t));
|
|
|
907
|
|
|
908 case EXPR_PACK_EXPANSION:
|
|
|
909 return normalize_pack_expansion (t);
|
|
|
910
|
|
|
911 default:
|
|
|
912 /* All other constraints are atomic. */
|
|
|
913 return normalize_atom (t);
|
|
|
914 }
|
|
|
915 }
|
|
|
916
|
|
|
917 /* Transform a statement into an expression. */
|
|
|
918 tree
|
|
|
919 normalize_any_statement (tree t)
|
|
|
920 {
|
|
|
921 switch (TREE_CODE (t))
|
|
|
922 {
|
|
|
923 case RETURN_EXPR:
|
|
|
924 return normalize_expression (TREE_OPERAND (t, 0));
|
|
|
925 default:
|
|
|
926 gcc_unreachable ();
|
|
|
927 }
|
|
|
928 return error_mark_node;
|
|
|
929 }
|
|
|
930
|
|
|
931 /* Reduction rules for the declaration T. */
|
|
|
932
|
|
|
933 tree
|
|
|
934 normalize_any_declaration (tree t)
|
|
|
935 {
|
|
|
936 switch (TREE_CODE (t))
|
|
|
937 {
|
|
|
938 case VAR_DECL:
|
|
|
939 return normalize_atom (t);
|
|
|
940 default:
|
|
|
941 gcc_unreachable ();
|
|
|
942 }
|
|
|
943 return error_mark_node;
|
|
|
944 }
|
|
|
945
|
|
|
946 /* Returns the normal form of a constraint expression. */
|
|
|
947
|
|
|
948 tree
|
|
|
949 normalize_expression (tree t)
|
|
|
950 {
|
|
|
951 if (!t)
|
|
|
952 return NULL_TREE;
|
|
|
953
|
|
|
954 if (t == error_mark_node)
|
|
|
955 return error_mark_node;
|
|
|
956
|
|
|
957 switch (TREE_CODE_CLASS (TREE_CODE (t)))
|
|
|
958 {
|
|
|
959 case tcc_unary:
|
|
|
960 case tcc_binary:
|
|
|
961 case tcc_expression:
|
|
|
962 case tcc_vl_exp:
|
|
|
963 return normalize_any_expression (t);
|
|
|
964
|
|
|
965 case tcc_statement:
|
|
|
966 return normalize_any_statement (t);
|
|
|
967
|
|
|
968 case tcc_declaration:
|
|
|
969 return normalize_any_declaration (t);
|
|
|
970
|
|
|
971 case tcc_exceptional:
|
|
|
972 case tcc_constant:
|
|
|
973 case tcc_reference:
|
|
|
974 case tcc_comparison:
|
|
|
975 /* These are all atomic predicate constraints. */
|
|
|
976 return normalize_atom (t);
|
|
|
977
|
|
|
978 default:
|
|
|
979 /* Unhandled node kind. */
|
|
|
980 gcc_unreachable ();
|
|
|
981 }
|
|
|
982 return error_mark_node;
|
|
|
983 }
|
|
|
984
|
|
|
985
|
|
|
986 /*---------------------------------------------------------------------------
|
|
|
987 Constraint normalization
|
|
|
988 ---------------------------------------------------------------------------*/
|
|
|
989
|
|
|
990 tree normalize_constraint (tree);
|
|
|
991
|
|
|
992 /* The normal form of the disjunction T0 /\ T1 is the conjunction
|
|
|
993 of the normal form of T0 and the normal form of T1. */
|
|
|
994
|
|
|
995 inline tree
|
|
|
996 normalize_conjunction (tree t)
|
|
|
997 {
|
|
|
998 tree t0 = normalize_constraint (TREE_OPERAND (t, 0));
|
|
|
999 tree t1 = normalize_constraint (TREE_OPERAND (t, 1));
|
|
|
1000 return build_nt (CONJ_CONSTR, t0, t1);
|
|
|
1001 }
|
|
|
1002
|
|
|
1003 /* The normal form of the disjunction T0 \/ T1 is the disjunction
|
|
|
1004 of the normal form of T0 and the normal form of T1. */
|
|
|
1005
|
|
|
1006 inline tree
|
|
|
1007 normalize_disjunction (tree t)
|
|
|
1008 {
|
|
|
1009 tree t0 = normalize_constraint (TREE_OPERAND (t, 0));
|
|
|
1010 tree t1 = normalize_constraint (TREE_OPERAND (t, 1));
|
|
|
1011 return build_nt (DISJ_CONSTR, t0, t1);
|
|
|
1012 }
|
|
|
1013
|
|
|
1014 /* A predicate constraint is normalized in two stages. First all
|
|
|
1015 references specializations of concepts are replaced by their
|
|
|
1016 substituted definitions. Then, the resulting expression is
|
|
|
1017 transformed into a constraint by transforming && expressions
|
|
|
1018 into conjunctions and || into disjunctions. */
|
|
|
1019
|
|
|
1020 tree
|
|
|
1021 normalize_predicate_constraint (tree t)
|
|
|
1022 {
|
|
|
1023 ++processing_template_decl;
|
|
|
1024 tree expr = PRED_CONSTR_EXPR (t);
|
|
|
1025 tree constr = normalize_expression (expr);
|
|
|
1026 --processing_template_decl;
|
|
|
1027 return constr;
|
|
|
1028 }
|
|
|
1029
|
|
|
1030 /* The normal form of a parameterized constraint is the normal
|
|
|
1031 form of its operand. */
|
|
|
1032
|
|
|
1033 tree
|
|
|
1034 normalize_parameterized_constraint (tree t)
|
|
|
1035 {
|
|
|
1036 tree parms = PARM_CONSTR_PARMS (t);
|
|
|
1037 tree operand = normalize_constraint (PARM_CONSTR_OPERAND (t));
|
|
|
1038 return build_nt (PARM_CONSTR, parms, operand);
|
|
|
1039 }
|
|
|
1040
|
|
|
1041 /* Normalize the constraint T by reducing it so that it is
|
|
|
1042 comprised of only conjunctions and disjunctions of atomic
|
|
|
1043 constraints. */
|
|
|
1044
|
|
|
1045 tree
|
|
|
1046 normalize_constraint (tree t)
|
|
|
1047 {
|
|
|
1048 if (!t)
|
|
|
1049 return NULL_TREE;
|
|
|
1050
|
|
|
1051 if (t == error_mark_node)
|
|
|
1052 return t;
|
|
|
1053
|
|
|
1054 switch (TREE_CODE (t))
|
|
|
1055 {
|
|
|
1056 case CONJ_CONSTR:
|
|
|
1057 return normalize_conjunction (t);
|
|
|
1058
|
|
|
1059 case DISJ_CONSTR:
|
|
|
1060 return normalize_disjunction (t);
|
|
|
1061
|
|
|
1062 case PRED_CONSTR:
|
|
|
1063 return normalize_predicate_constraint (t);
|
|
|
1064
|
|
|
1065 case PARM_CONSTR:
|
|
|
1066 return normalize_parameterized_constraint (t);
|
|
|
1067
|
|
|
1068 case EXPR_CONSTR:
|
|
|
1069 case TYPE_CONSTR:
|
|
|
1070 case ICONV_CONSTR:
|
|
|
1071 case DEDUCT_CONSTR:
|
|
|
1072 case EXCEPT_CONSTR:
|
|
|
1073 /* These constraints are defined to be atomic. */
|
|
|
1074 return t;
|
|
|
1075
|
|
|
1076 default:
|
|
|
1077 /* CONSTR was not a constraint. */
|
|
|
1078 gcc_unreachable();
|
|
|
1079 }
|
|
|
1080 return error_mark_node;
|
|
|
1081 }
|
|
|
1082
|
|
|
1083
|
|
|
1084
|
|
|
1085 // -------------------------------------------------------------------------- //
|
|
|
1086 // Constraint Semantic Processing
|
|
|
1087 //
|
|
|
1088 // The following functions are called by the parser and substitution rules
|
|
|
1089 // to create and evaluate constraint-related nodes.
|
|
|
1090
|
|
|
1091 // The constraints associated with the current template parameters.
|
|
|
1092 tree
|
|
|
1093 current_template_constraints (void)
|
|
|
1094 {
|
|
|
1095 if (!current_template_parms)
|
|
|
1096 return NULL_TREE;
|
|
|
1097 tree tmpl_constr = TEMPLATE_PARM_CONSTRAINTS (current_template_parms);
|
|
|
1098 return build_constraints (tmpl_constr, NULL_TREE);
|
|
|
1099 }
|
|
|
1100
|
|
|
1101 // If the recently parsed TYPE declares or defines a template or template
|
|
|
1102 // specialization, get its corresponding constraints from the current
|
|
|
1103 // template parameters and bind them to TYPE's declaration.
|
|
|
1104 tree
|
|
|
1105 associate_classtype_constraints (tree type)
|
|
|
1106 {
|
|
|
1107 if (!type || type == error_mark_node || TREE_CODE (type) != RECORD_TYPE)
|
|
|
1108 return type;
|
|
|
1109
|
|
|
1110 // An explicit class template specialization has no template
|
|
|
1111 // parameters.
|
|
|
1112 if (!current_template_parms)
|
|
|
1113 return type;
|
|
|
1114
|
|
|
1115 if (CLASSTYPE_IS_TEMPLATE (type) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
|
|
|
1116 {
|
|
|
1117 tree decl = TYPE_STUB_DECL (type);
|
|
|
1118 tree ci = current_template_constraints ();
|
|
|
1119
|
|
|
1120 // An implicitly instantiated member template declaration already
|
|
|
1121 // has associated constraints. If it is defined outside of its
|
|
|
1122 // class, then we need match these constraints against those of
|
|
|
1123 // original declaration.
|
|
|
1124 if (tree orig_ci = get_constraints (decl))
|
|
|
1125 {
|
|
|
1126 if (!equivalent_constraints (ci, orig_ci))
|
|
|
1127 {
|
|
|
1128 // FIXME: Improve diagnostics.
|
|
|
1129 error ("%qT does not match any declaration", type);
|
|
|
1130 return error_mark_node;
|
|
|
1131 }
|
|
|
1132 return type;
|
|
|
1133 }
|
|
|
1134 set_constraints (decl, ci);
|
|
|
1135 }
|
|
|
1136 return type;
|
|
|
1137 }
|
|
|
1138
|
|
|
1139 namespace {
|
|
|
1140
|
|
|
1141 // Create an empty constraint info block.
|
|
|
1142 inline tree_constraint_info*
|
|
|
1143 build_constraint_info ()
|
|
|
1144 {
|
|
|
1145 return (tree_constraint_info *)make_node (CONSTRAINT_INFO);
|
|
|
1146 }
|
|
|
1147
|
|
|
1148 } // namespace
|
|
|
1149
|
|
|
1150 /* Build a constraint-info object that contains the associated constraints
|
|
|
1151 of a declaration. This also includes the declaration's template
|
|
|
1152 requirements (TREQS) and any trailing requirements for a function
|
|
|
1153 declarator (DREQS). Note that both TREQS and DREQS must be constraints.
|
|
|
1154
|
|
|
1155 If the declaration has neither template nor declaration requirements
|
|
|
1156 this returns NULL_TREE, indicating an unconstrained declaration. */
|
|
|
1157
|
|
|
1158 tree
|
|
|
1159 build_constraints (tree tmpl_reqs, tree decl_reqs)
|
|
|
1160 {
|
|
|
1161 gcc_assert (tmpl_reqs ? constraint_p (tmpl_reqs) : true);
|
|
|
1162 gcc_assert (decl_reqs ? constraint_p (decl_reqs) : true);
|
|
|
1163
|
|
|
1164 if (!tmpl_reqs && !decl_reqs)
|
|
|
1165 return NULL_TREE;
|
|
|
1166
|
|
|
1167 tree_constraint_info* ci = build_constraint_info ();
|
|
|
1168 ci->template_reqs = tmpl_reqs;
|
|
|
1169 ci->declarator_reqs = decl_reqs;
|
|
|
1170 ci->associated_constr = conjoin_constraints (tmpl_reqs, decl_reqs);
|
|
|
1171
|
|
|
1172 return (tree)ci;
|
|
|
1173 }
|
|
|
1174
|
|
|
1175 namespace {
|
|
|
1176
|
|
|
1177 /* Construct a sequence of template arguments by prepending
|
|
|
1178 ARG to REST. Either ARG or REST may be null. */
|
|
|
1179 tree
|
|
|
1180 build_concept_check_arguments (tree arg, tree rest)
|
|
|
1181 {
|
|
|
1182 gcc_assert (rest ? TREE_CODE (rest) == TREE_VEC : true);
|
|
|
1183 tree args;
|
|
|
1184 if (arg)
|
|
|
1185 {
|
|
|
1186 int n = rest ? TREE_VEC_LENGTH (rest) : 0;
|
|
|
1187 args = make_tree_vec (n + 1);
|
|
|
1188 TREE_VEC_ELT (args, 0) = arg;
|
|
|
1189 if (rest)
|
|
|
1190 for (int i = 0; i < n; ++i)
|
|
|
1191 TREE_VEC_ELT (args, i + 1) = TREE_VEC_ELT (rest, i);
|
|
|
1192 int def = rest ? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest) : 0;
|
|
|
1193 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, def + 1);
|
|
|
1194 }
|
|
|
1195 else
|
|
|
1196 {
|
|
|
1197 gcc_assert (rest != NULL_TREE);
|
|
|
1198 args = rest;
|
|
|
1199 }
|
|
|
1200 return args;
|
|
|
1201 }
|
|
|
1202
|
|
|
1203 } // namespace
|
|
|
1204
|
|
|
1205 /* Construct an expression that checks the concept given by
|
|
|
1206 TARGET. The TARGET must be:
|
|
|
1207
|
|
|
1208 - an OVERLOAD referring to one or more function concepts
|
|
|
1209 - a BASELINK referring to an overload set of the above, or
|
|
|
1210 - a TEMPLTATE_DECL referring to a variable concept.
|
|
|
1211
|
|
|
1212 ARG and REST are the explicit template arguments for the
|
|
|
1213 eventual concept check. */
|
|
|
1214 tree
|
|
|
1215 build_concept_check (tree target, tree arg, tree rest)
|
|
|
1216 {
|
|
|
1217 tree args = build_concept_check_arguments (arg, rest);
|
|
|
1218 if (variable_template_p (target))
|
|
|
1219 return build_variable_check (lookup_template_variable (target, args));
|
|
|
1220 else
|
|
|
1221 return build_call_check (lookup_template_function (target, args));
|
|
|
1222 }
|
|
|
1223
|
|
|
1224
|
|
|
1225 /* Returns a TYPE_DECL that contains sufficient information to
|
|
|
1226 build a template parameter of the same kind as PROTO and
|
|
|
1227 constrained by the concept declaration CNC. Note that PROTO
|
|
|
1228 is the first template parameter of CNC.
|
|
|
1229
|
|
|
1230 If specified, ARGS provides additional arguments to the
|
|
|
1231 constraint check. */
|
|
|
1232 tree
|
|
|
1233 build_constrained_parameter (tree cnc, tree proto, tree args)
|
|
|
1234 {
|
|
|
1235 tree name = DECL_NAME (cnc);
|
|
|
1236 tree type = TREE_TYPE (proto);
|
|
|
1237 tree decl = build_decl (input_location, TYPE_DECL, name, type);
|
|
|
1238 CONSTRAINED_PARM_PROTOTYPE (decl) = proto;
|
|
|
1239 CONSTRAINED_PARM_CONCEPT (decl) = cnc;
|
|
|
1240 CONSTRAINED_PARM_EXTRA_ARGS (decl) = args;
|
|
|
1241 return decl;
|
|
|
1242 }
|
|
|
1243
|
|
|
1244 /* Create a constraint expression for the given DECL that
|
|
|
1245 evaluates the requirements specified by CONSTR, a TYPE_DECL
|
|
|
1246 that contains all the information necessary to build the
|
|
|
1247 requirements (see finish_concept_name for the layout of
|
|
|
1248 that TYPE_DECL).
|
|
|
1249
|
|
|
1250 Note that the constraints are neither reduced nor decomposed.
|
|
|
1251 That is done only after the requires clause has been parsed
|
|
|
1252 (or not).
|
|
|
1253
|
|
|
1254 This will always return a CHECK_CONSTR. */
|
|
|
1255 tree
|
|
|
1256 finish_shorthand_constraint (tree decl, tree constr)
|
|
|
1257 {
|
|
|
1258 /* No requirements means no constraints. */
|
|
|
1259 if (!constr)
|
|
|
1260 return NULL_TREE;
|
|
|
1261
|
|
|
1262 tree proto = CONSTRAINED_PARM_PROTOTYPE (constr);
|
|
|
1263 tree con = CONSTRAINED_PARM_CONCEPT (constr);
|
|
|
1264 tree args = CONSTRAINED_PARM_EXTRA_ARGS (constr);
|
|
|
1265
|
|
|
1266 /* If the parameter declaration is variadic, but the concept
|
|
|
1267 is not then we need to apply the concept to every element
|
|
|
1268 in the pack. */
|
|
|
1269 bool is_proto_pack = template_parameter_pack_p (proto);
|
|
|
1270 bool is_decl_pack = template_parameter_pack_p (decl);
|
|
|
1271 bool apply_to_all_p = is_decl_pack && !is_proto_pack;
|
|
|
1272
|
|
|
1273 /* Get the argument and overload used for the requirement
|
|
|
1274 and adjust it if we're going to expand later. */
|
|
|
1275 tree arg = template_parm_to_arg (build_tree_list (NULL_TREE, decl));
|
|
|
1276 if (apply_to_all_p)
|
|
|
1277 arg = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0));
|
|
|
1278
|
|
|
1279 /* Build the concept check. If it the constraint needs to be
|
|
|
1280 applied to all elements of the parameter pack, then make
|
|
|
1281 the constraint an expansion. */
|
|
|
1282 tree tmpl = DECL_TI_TEMPLATE (con);
|
|
|
1283 tree check = VAR_P (con) ? tmpl : ovl_make (tmpl);
|
|
|
1284 check = build_concept_check (check, arg, args);
|
|
|
1285
|
|
|
1286 /* Make the check a pack expansion if needed.
|
|
|
1287
|
|
|
1288 FIXME: We should be making a fold expression. */
|
|
|
1289 if (apply_to_all_p)
|
|
|
1290 {
|
|
|
1291 check = make_pack_expansion (check);
|
|
|
1292 TREE_TYPE (check) = boolean_type_node;
|
|
|
1293 }
|
|
|
1294
|
|
|
1295 return normalize_expression (check);
|
|
|
1296 }
|
|
|
1297
|
|
|
1298 /* Returns a conjunction of shorthand requirements for the template
|
|
|
1299 parameter list PARMS. Note that the requirements are stored in
|
|
|
1300 the TYPE of each tree node. */
|
|
|
1301 tree
|
|
|
1302 get_shorthand_constraints (tree parms)
|
|
|
1303 {
|
|
|
1304 tree result = NULL_TREE;
|
|
|
1305 parms = INNERMOST_TEMPLATE_PARMS (parms);
|
|
|
1306 for (int i = 0; i < TREE_VEC_LENGTH (parms); ++i)
|
|
|
1307 {
|
|
|
1308 tree parm = TREE_VEC_ELT (parms, i);
|
|
|
1309 tree constr = TEMPLATE_PARM_CONSTRAINTS (parm);
|
|
|
1310 result = conjoin_constraints (result, constr);
|
|
|
1311 }
|
|
|
1312 return result;
|
|
|
1313 }
|
|
|
1314
|
|
|
1315 // Returns and chains a new parameter for PARAMETER_LIST which will conform
|
|
|
1316 // to the prototype given by SRC_PARM. The new parameter will have its
|
|
|
1317 // identifier and location set according to IDENT and PARM_LOC respectively.
|
|
|
1318 static tree
|
|
|
1319 process_introduction_parm (tree parameter_list, tree src_parm)
|
|
|
1320 {
|
|
|
1321 // If we have a pack, we should have a single pack argument which is the
|
|
|
1322 // placeholder we want to look at.
|
|
|
1323 bool is_parameter_pack = ARGUMENT_PACK_P (src_parm);
|
|
|
1324 if (is_parameter_pack)
|
|
|
1325 src_parm = TREE_VEC_ELT (ARGUMENT_PACK_ARGS (src_parm), 0);
|
|
|
1326
|
|
|
1327 // At this point we should have a wildcard, but we want to
|
|
|
1328 // grab the associated decl from it. Also grab the stored
|
|
|
1329 // identifier and location that should be chained to it in
|
|
|
1330 // a PARM_DECL.
|
|
|
1331 gcc_assert (TREE_CODE (src_parm) == WILDCARD_DECL);
|
|
|
1332
|
|
|
1333 tree ident = DECL_NAME (src_parm);
|
|
|
1334 location_t parm_loc = DECL_SOURCE_LOCATION (src_parm);
|
|
|
1335
|
|
|
1336 // If we expect a pack and the deduced template is not a pack, or if the
|
|
|
1337 // template is using a pack and we didn't declare a pack, throw an error.
|
|
|
1338 if (is_parameter_pack != WILDCARD_PACK_P (src_parm))
|
|
|
1339 {
|
|
|
1340 error_at (parm_loc, "cannot match pack for introduced parameter");
|
|
|
1341 tree err_parm = build_tree_list (error_mark_node, error_mark_node);
|
|
|
1342 return chainon (parameter_list, err_parm);
|
|
|
1343 }
|
|
|
1344
|
|
|
1345 src_parm = TREE_TYPE (src_parm);
|
|
|
1346
|
|
|
1347 tree parm;
|
|
|
1348 bool is_non_type;
|
|
|
1349 if (TREE_CODE (src_parm) == TYPE_DECL)
|
|
|
1350 {
|
|
|
1351 is_non_type = false;
|
|
|
1352 parm = finish_template_type_parm (class_type_node, ident);
|
|
|
1353 }
|
|
|
1354 else if (TREE_CODE (src_parm) == TEMPLATE_DECL)
|
|
|
1355 {
|
|
|
1356 is_non_type = false;
|
|
|
1357 begin_template_parm_list ();
|
|
|
1358 current_template_parms = DECL_TEMPLATE_PARMS (src_parm);
|
|
|
1359 end_template_parm_list ();
|
|
|
1360 parm = finish_template_template_parm (class_type_node, ident);
|
|
|
1361 }
|
|
|
1362 else
|
|
|
1363 {
|
|
|
1364 is_non_type = true;
|
|
|
1365
|
|
|
1366 // Since we don't have a declarator, so we can copy the source
|
|
|
1367 // parameter and change the name and eventually the location.
|
|
|
1368 parm = copy_decl (src_parm);
|
|
|
1369 DECL_NAME (parm) = ident;
|
|
|
1370 }
|
|
|
1371
|
|
|
1372 // Wrap in a TREE_LIST for process_template_parm. Introductions do not
|
|
|
1373 // retain the defaults from the source template.
|
|
|
1374 parm = build_tree_list (NULL_TREE, parm);
|
|
|
1375
|
|
|
1376 return process_template_parm (parameter_list, parm_loc, parm,
|
|
|
1377 is_non_type, is_parameter_pack);
|
|
|
1378 }
|
|
|
1379
|
|
|
1380 /* Associates a constraint check to the current template based
|
|
|
1381 on the introduction parameters. INTRO_LIST must be a TREE_VEC
|
|
|
1382 of WILDCARD_DECLs containing a chained PARM_DECL which
|
|
|
1383 contains the identifier as well as the source location.
|
|
|
1384 TMPL_DECL is the decl for the concept being used. If we
|
|
|
1385 take a concept, C, this will form a check in the form of
|
|
|
1386 C<INTRO_LIST> filling in any extra arguments needed by the
|
|
|
1387 defaults deduced.
|
|
|
1388
|
|
|
1389 Returns NULL_TREE if no concept could be matched and
|
|
|
1390 error_mark_node if an error occurred when matching. */
|
|
|
1391 tree
|
|
|
1392 finish_template_introduction (tree tmpl_decl, tree intro_list)
|
|
|
1393 {
|
|
|
1394 /* Deduce the concept check. */
|
|
|
1395 tree expr = build_concept_check (tmpl_decl, NULL_TREE, intro_list);
|
|
|
1396 if (expr == error_mark_node)
|
|
|
1397 return NULL_TREE;
|
|
|
1398
|
|
|
1399 tree parms = deduce_concept_introduction (expr);
|
|
|
1400 if (!parms)
|
|
|
1401 return NULL_TREE;
|
|
|
1402
|
|
|
1403 /* Build template parameter scope for introduction. */
|
|
|
1404 tree parm_list = NULL_TREE;
|
|
|
1405 begin_template_parm_list ();
|
|
|
1406 int nargs = MIN (TREE_VEC_LENGTH (parms), TREE_VEC_LENGTH (intro_list));
|
|
|
1407 for (int n = 0; n < nargs; ++n)
|
|
|
1408 parm_list = process_introduction_parm (parm_list, TREE_VEC_ELT (parms, n));
|
|
|
1409 parm_list = end_template_parm_list (parm_list);
|
|
|
1410 for (int i = 0; i < TREE_VEC_LENGTH (parm_list); ++i)
|
|
|
1411 if (TREE_VALUE (TREE_VEC_ELT (parm_list, i)) == error_mark_node)
|
|
|
1412 {
|
|
|
1413 end_template_decl ();
|
|
|
1414 return error_mark_node;
|
|
|
1415 }
|
|
|
1416
|
|
|
1417 /* Build a concept check for our constraint. */
|
|
|
1418 tree check_args = make_tree_vec (TREE_VEC_LENGTH (parms));
|
|
|
1419 int n = 0;
|
|
|
1420 for (; n < TREE_VEC_LENGTH (parm_list); ++n)
|
|
|
1421 {
|
|
|
1422 tree parm = TREE_VEC_ELT (parm_list, n);
|
|
|
1423 TREE_VEC_ELT (check_args, n) = template_parm_to_arg (parm);
|
|
|
1424 }
|
|
|
1425 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args, n);
|
|
|
1426
|
|
|
1427 /* If the template expects more parameters we should be able
|
|
|
1428 to use the defaults from our deduced concept. */
|
|
|
1429 for (; n < TREE_VEC_LENGTH (parms); ++n)
|
|
|
1430 TREE_VEC_ELT (check_args, n) = TREE_VEC_ELT (parms, n);
|
|
|
1431
|
|
|
1432 /* Associate the constraint. */
|
|
|
1433 tree check = build_concept_check (tmpl_decl, NULL_TREE, check_args);
|
|
|
1434 tree constr = normalize_expression (check);
|
|
|
1435 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = constr;
|
|
|
1436
|
|
|
1437 return parm_list;
|
|
|
1438 }
|
|
|
1439
|
|
|
1440
|
|
|
1441 /* Given the predicate constraint T from a constrained-type-specifier, extract
|
|
|
1442 its TMPL and ARGS. FIXME why do we need two different forms of
|
|
|
1443 constrained-type-specifier? */
|
|
|
1444
|
|
|
1445 void
|
|
|
1446 placeholder_extract_concept_and_args (tree t, tree &tmpl, tree &args)
|
|
|
1447 {
|
|
|
1448 if (TREE_CODE (t) == TYPE_DECL)
|
|
|
1449 {
|
|
|
1450 /* A constrained parameter. Build a constraint check
|
|
|
1451 based on the prototype parameter and then extract the
|
|
|
1452 arguments from that. */
|
|
|
1453 tree proto = CONSTRAINED_PARM_PROTOTYPE (t);
|
|
|
1454 tree check = finish_shorthand_constraint (proto, t);
|
|
|
1455 placeholder_extract_concept_and_args (check, tmpl, args);
|
|
|
1456 return;
|
|
|
1457 }
|
|
|
1458
|
|
|
1459 if (TREE_CODE (t) == CHECK_CONSTR)
|
|
|
1460 {
|
|
|
1461 tree decl = CHECK_CONSTR_CONCEPT (t);
|
|
|
1462 tmpl = DECL_TI_TEMPLATE (decl);
|
|
|
1463 args = CHECK_CONSTR_ARGS (t);
|
|
|
1464 return;
|
|
|
1465 }
|
|
|
1466
|
|
|
1467 gcc_unreachable ();
|
|
|
1468 }
|
|
|
1469
|
|
|
1470 /* Returns true iff the placeholders C1 and C2 are equivalent. C1
|
|
|
1471 and C2 can be either CHECK_CONSTR or TEMPLATE_TYPE_PARM. */
|
|
|
1472
|
|
|
1473 bool
|
|
|
1474 equivalent_placeholder_constraints (tree c1, tree c2)
|
|
|
1475 {
|
|
|
1476 if (c1 && TREE_CODE (c1) == TEMPLATE_TYPE_PARM)
|
|
|
1477 /* A constrained auto. */
|
|
|
1478 c1 = PLACEHOLDER_TYPE_CONSTRAINTS (c1);
|
|
|
1479 if (c2 && TREE_CODE (c2) == TEMPLATE_TYPE_PARM)
|
|
|
1480 c2 = PLACEHOLDER_TYPE_CONSTRAINTS (c2);
|
|
|
1481
|
|
|
1482 if (c1 == c2)
|
|
|
1483 return true;
|
|
|
1484 if (!c1 || !c2)
|
|
|
1485 return false;
|
|
|
1486 if (c1 == error_mark_node || c2 == error_mark_node)
|
|
|
1487 /* We get here during satisfaction; when a deduction constraint
|
|
|
1488 fails, substitution can produce an error_mark_node for the
|
|
|
1489 placeholder constraints. */
|
|
|
1490 return false;
|
|
|
1491
|
|
|
1492 tree t1, t2, a1, a2;
|
|
|
1493 placeholder_extract_concept_and_args (c1, t1, a1);
|
|
|
1494 placeholder_extract_concept_and_args (c2, t2, a2);
|
|
|
1495
|
|
|
1496 if (t1 != t2)
|
|
|
1497 return false;
|
|
|
1498
|
|
|
1499 int len1 = TREE_VEC_LENGTH (a1);
|
|
|
1500 int len2 = TREE_VEC_LENGTH (a2);
|
|
|
1501 if (len1 != len2)
|
|
|
1502 return false;
|
|
|
1503
|
|
|
1504 /* Skip the first argument so we don't infinitely recurse.
|
|
|
1505 Also, they may differ in template parameter index. */
|
|
|
1506 for (int i = 1; i < len1; ++i)
|
|
|
1507 {
|
|
|
1508 tree t1 = TREE_VEC_ELT (a1, i);
|
|
|
1509 tree t2 = TREE_VEC_ELT (a2, i);
|
|
|
1510 if (!template_args_equal (t1, t2))
|
|
|
1511 return false;
|
|
|
1512 }
|
|
|
1513 return true;
|
|
|
1514 }
|
|
|
1515
|
|
|
1516 /* Return a hash value for the placeholder PRED_CONSTR C. */
|
|
|
1517
|
|
|
1518 hashval_t
|
|
|
1519 hash_placeholder_constraint (tree c)
|
|
|
1520 {
|
|
|
1521 tree t, a;
|
|
|
1522 placeholder_extract_concept_and_args (c, t, a);
|
|
|
1523
|
|
|
1524 /* Like hash_tmpl_and_args, but skip the first argument. */
|
|
|
1525 hashval_t val = iterative_hash_object (DECL_UID (t), 0);
|
|
|
1526
|
|
|
1527 for (int i = TREE_VEC_LENGTH (a)-1; i > 0; --i)
|
|
|
1528 val = iterative_hash_template_arg (TREE_VEC_ELT (a, i), val);
|
|
|
1529
|
|
|
1530 return val;
|
|
|
1531 }
|
|
|
1532
|
|
|
1533 /*---------------------------------------------------------------------------
|
|
|
1534 Constraint substitution
|
|
|
1535 ---------------------------------------------------------------------------*/
|
|
|
1536
|
|
|
1537 /* The following functions implement substitution rules for constraints.
|
|
|
1538 Substitution without checking constraints happens only in the
|
|
|
1539 instantiation of class templates. For example:
|
|
|
1540
|
|
|
1541 template<C1 T> struct S {
|
|
|
1542 void f(T) requires C2<T>;
|
|
|
1543 void g(T) requires T::value;
|
|
|
1544 };
|
|
|
1545
|
|
|
1546 S<int> s; // error instantiating S<int>::g(T)
|
|
|
1547
|
|
|
1548 When we instantiate S, we substitute into its member declarations,
|
|
|
1549 including their constraints. However, those constraints are not
|
|
|
1550 checked. Substituting int into C2<T> yields C2<int>, and substituting
|
|
|
1551 into T::value yields a substitution failure, making the program
|
|
|
1552 ill-formed.
|
|
|
1553
|
|
|
1554 Note that we only ever substitute into the associated constraints
|
|
|
1555 of a declaration. That is, substitution is defined only for predicate
|
|
|
1556 constraints and conjunctions. */
|
|
|
1557
|
|
|
1558 /* Substitute into the predicate constraints. Returns error_mark_node
|
|
|
1559 if the substitution into the expression fails. */
|
|
|
1560 tree
|
|
|
1561 tsubst_predicate_constraint (tree t, tree args,
|
|
|
1562 tsubst_flags_t complain, tree in_decl)
|
|
|
1563 {
|
|
|
1564 tree expr = PRED_CONSTR_EXPR (t);
|
|
|
1565 ++processing_template_decl;
|
|
|
1566 tree result = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1567 --processing_template_decl;
|
|
|
1568 return build_nt (PRED_CONSTR, result);
|
|
|
1569 }
|
|
|
1570
|
|
|
1571 /* Substitute into a check constraint. */
|
|
|
1572
|
|
|
1573 tree
|
|
|
1574 tsubst_check_constraint (tree t, tree args,
|
|
|
1575 tsubst_flags_t complain, tree in_decl)
|
|
|
1576 {
|
|
|
1577 tree decl = CHECK_CONSTR_CONCEPT (t);
|
|
|
1578 tree tmpl = DECL_TI_TEMPLATE (decl);
|
|
|
1579 tree targs = CHECK_CONSTR_ARGS (t);
|
|
|
1580
|
|
|
1581 /* Substitute through by building an template-id expression
|
|
|
1582 and then substituting into that. */
|
|
|
1583 tree expr = build_nt (TEMPLATE_ID_EXPR, tmpl, targs);
|
|
|
1584 ++processing_template_decl;
|
|
|
1585 tree result = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1586 --processing_template_decl;
|
|
|
1587
|
|
|
1588 if (result == error_mark_node)
|
|
|
1589 return error_mark_node;
|
|
|
1590
|
|
|
1591 /* Extract the results and rebuild the check constraint. */
|
|
|
1592 decl = DECL_TEMPLATE_RESULT (TREE_OPERAND (result, 0));
|
|
|
1593 args = TREE_OPERAND (result, 1);
|
|
|
1594
|
|
|
1595 return build_nt (CHECK_CONSTR, decl, args);
|
|
|
1596 }
|
|
|
1597
|
|
|
1598 /* Substitute into the conjunction of constraints. Returns
|
|
|
1599 error_mark_node if substitution into either operand fails. */
|
|
|
1600
|
|
|
1601 tree
|
|
|
1602 tsubst_logical_operator (tree t, tree args,
|
|
|
1603 tsubst_flags_t complain, tree in_decl)
|
|
|
1604 {
|
|
|
1605 tree t0 = TREE_OPERAND (t, 0);
|
|
|
1606 tree r0 = tsubst_constraint (t0, args, complain, in_decl);
|
|
|
1607 if (r0 == error_mark_node)
|
|
|
1608 return error_mark_node;
|
|
|
1609 tree t1 = TREE_OPERAND (t, 1);
|
|
|
1610 tree r1 = tsubst_constraint (t1, args, complain, in_decl);
|
|
|
1611 if (r1 == error_mark_node)
|
|
|
1612 return error_mark_node;
|
|
|
1613 return build_nt (TREE_CODE (t), r0, r1);
|
|
|
1614 }
|
|
|
1615
|
|
|
1616 namespace {
|
|
|
1617
|
|
|
1618 /* Substitute ARGS into the expression constraint T. */
|
|
|
1619
|
|
|
1620 tree
|
|
|
1621 tsubst_expr_constr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
1622 {
|
|
|
1623 cp_unevaluated guard;
|
|
|
1624 tree expr = EXPR_CONSTR_EXPR (t);
|
|
|
1625 tree ret = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1626 if (ret == error_mark_node)
|
|
|
1627 return error_mark_node;
|
|
|
1628 return build_nt (EXPR_CONSTR, ret);
|
|
|
1629 }
|
|
|
1630
|
|
|
1631 /* Substitute ARGS into the type constraint T. */
|
|
|
1632
|
|
|
1633 tree
|
|
|
1634 tsubst_type_constr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
1635 {
|
|
|
1636 tree type = TYPE_CONSTR_TYPE (t);
|
|
|
1637 tree ret = tsubst (type, args, complain, in_decl);
|
|
|
1638 if (ret == error_mark_node)
|
|
|
1639 return error_mark_node;
|
|
|
1640 return build_nt (TYPE_CONSTR, ret);
|
|
|
1641 }
|
|
|
1642
|
|
|
1643 /* Substitute ARGS into the implicit conversion constraint T. */
|
|
|
1644
|
|
|
1645 tree
|
|
|
1646 tsubst_implicit_conversion_constr (tree t, tree args, tsubst_flags_t complain,
|
|
|
1647 tree in_decl)
|
|
|
1648 {
|
|
|
1649 cp_unevaluated guard;
|
|
|
1650 tree expr = ICONV_CONSTR_EXPR (t);
|
|
|
1651 tree type = ICONV_CONSTR_TYPE (t);
|
|
|
1652 tree new_expr = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1653 if (new_expr == error_mark_node)
|
|
|
1654 return error_mark_node;
|
|
|
1655 tree new_type = tsubst (type, args, complain, in_decl);
|
|
|
1656 if (new_type == error_mark_node)
|
|
|
1657 return error_mark_node;
|
|
|
1658 return build_nt (ICONV_CONSTR, new_expr, new_type);
|
|
|
1659 }
|
|
|
1660
|
|
|
1661 /* Substitute ARGS into the argument deduction constraint T. */
|
|
|
1662
|
|
|
1663 tree
|
|
|
1664 tsubst_argument_deduction_constr (tree t, tree args, tsubst_flags_t complain,
|
|
|
1665 tree in_decl)
|
|
|
1666 {
|
|
|
1667 cp_unevaluated guard;
|
|
|
1668 tree expr = DEDUCT_CONSTR_EXPR (t);
|
|
|
1669 tree pattern = DEDUCT_CONSTR_PATTERN (t);
|
|
|
1670 tree autos = DEDUCT_CONSTR_PLACEHOLDER(t);
|
|
|
1671 tree new_expr = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1672 if (new_expr == error_mark_node)
|
|
|
1673 return error_mark_node;
|
|
|
1674 /* It seems like substituting through the pattern will not affect the
|
|
|
1675 placeholders. We should (?) be able to reuse the existing list
|
|
|
1676 without any problems. If not, then we probably want to create a
|
|
|
1677 new list of placeholders and then instantiate the pattern using
|
|
|
1678 those. */
|
|
|
1679 tree new_pattern = tsubst (pattern, args, complain, in_decl);
|
|
|
1680 if (new_pattern == error_mark_node)
|
|
|
1681 return error_mark_node;
|
|
|
1682 return build_nt (DEDUCT_CONSTR, new_expr, new_pattern, autos);
|
|
|
1683 }
|
|
|
1684
|
|
|
1685 /* Substitute ARGS into the exception constraint T. */
|
|
|
1686
|
|
|
1687 tree
|
|
|
1688 tsubst_exception_constr (tree t, tree args, tsubst_flags_t complain,
|
|
|
1689 tree in_decl)
|
|
|
1690 {
|
|
|
1691 cp_unevaluated guard;
|
|
|
1692 tree expr = EXCEPT_CONSTR_EXPR (t);
|
|
|
1693 tree ret = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
1694 if (ret == error_mark_node)
|
|
|
1695 return error_mark_node;
|
|
|
1696 return build_nt (EXCEPT_CONSTR, ret);
|
|
|
1697 }
|
|
|
1698
|
|
|
1699 /* A subroutine of tsubst_constraint_variables. Register local
|
|
|
1700 specializations for each of parameter in PARMS and its
|
|
|
1701 corresponding substituted constraint variable in VARS.
|
|
|
1702 Returns VARS. */
|
|
|
1703
|
|
|
1704 tree
|
|
|
1705 declare_constraint_vars (tree parms, tree vars)
|
|
|
1706 {
|
|
|
1707 tree s = vars;
|
|
|
1708 for (tree t = parms; t; t = DECL_CHAIN (t))
|
|
|
1709 {
|
|
|
1710 if (DECL_PACK_P (t))
|
|
|
1711 {
|
|
|
1712 tree pack = extract_fnparm_pack (t, &s);
|
|
|
1713 register_local_specialization (pack, t);
|
|
|
1714 }
|
|
|
1715 else
|
|
|
1716 {
|
|
|
1717 register_local_specialization (s, t);
|
|
|
1718 s = DECL_CHAIN (s);
|
|
|
1719 }
|
|
|
1720 }
|
|
|
1721 return vars;
|
|
|
1722 }
|
|
|
1723
|
|
|
1724 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
|
|
|
1725 into the parameter list T, producing a sequence of constraint
|
|
|
1726 variables, declared in the current scope.
|
|
|
1727
|
|
|
1728 Note that the caller must establish a local specialization stack
|
|
|
1729 prior to calling this function since this substitution will
|
|
|
1730 declare the substituted parameters. */
|
|
|
1731
|
|
|
1732 tree
|
|
|
1733 tsubst_constraint_variables (tree t, tree args,
|
|
|
1734 tsubst_flags_t complain, tree in_decl)
|
|
|
1735 {
|
|
|
1736 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
|
|
|
1737 of PARM_DECLs. */
|
|
|
1738 int saved_unevaluated_operand = cp_unevaluated_operand;
|
|
|
1739 cp_unevaluated_operand = 0;
|
|
|
1740 tree vars = tsubst (t, args, complain, in_decl);
|
|
|
1741 cp_unevaluated_operand = saved_unevaluated_operand;
|
|
|
1742 if (vars == error_mark_node)
|
|
|
1743 return error_mark_node;
|
|
|
1744 return declare_constraint_vars (t, vars);
|
|
|
1745 }
|
|
|
1746
|
|
|
1747 /* Substitute ARGS into the parameterized constraint T. */
|
|
|
1748
|
|
|
1749 tree
|
|
|
1750 tsubst_parameterized_constraint (tree t, tree args,
|
|
|
1751 tsubst_flags_t complain, tree in_decl)
|
|
|
1752 {
|
|
|
1753 local_specialization_stack stack;
|
|
|
1754 tree vars = tsubst_constraint_variables (PARM_CONSTR_PARMS (t),
|
|
|
1755 args, complain, in_decl);
|
|
|
1756 if (vars == error_mark_node)
|
|
|
1757 return error_mark_node;
|
|
|
1758 tree expr = tsubst_constraint (PARM_CONSTR_OPERAND (t), args,
|
|
|
1759 complain, in_decl);
|
|
|
1760 if (expr == error_mark_node)
|
|
|
1761 return error_mark_node;
|
|
|
1762 return build_nt (PARM_CONSTR, vars, expr);
|
|
|
1763 }
|
|
|
1764
|
|
|
1765 /* Substitute ARGS into the simple requirement T. Note that
|
|
|
1766 substitution may result in an ill-formed expression without
|
|
|
1767 causing the program to be ill-formed. In such cases, the
|
|
|
1768 requirement wraps an error_mark_node. */
|
|
|
1769
|
|
|
1770 inline tree
|
|
|
1771 tsubst_simple_requirement (tree t, tree args,
|
|
|
1772 tsubst_flags_t complain, tree in_decl)
|
|
|
1773 {
|
|
|
1774 ++processing_template_decl;
|
|
|
1775 tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
|
|
|
1776 --processing_template_decl;
|
|
|
1777 return finish_simple_requirement (expr);
|
|
|
1778 }
|
|
|
1779
|
|
|
1780 /* Substitute ARGS into the type requirement T. Note that
|
|
|
1781 substitution may result in an ill-formed type without
|
|
|
1782 causing the program to be ill-formed. In such cases, the
|
|
|
1783 requirement wraps an error_mark_node. */
|
|
|
1784
|
|
|
1785 inline tree
|
|
|
1786 tsubst_type_requirement (tree t, tree args,
|
|
|
1787 tsubst_flags_t complain, tree in_decl)
|
|
|
1788 {
|
|
|
1789 ++processing_template_decl;
|
|
|
1790 tree type = tsubst (TREE_OPERAND (t, 0), args, complain, in_decl);
|
|
|
1791 --processing_template_decl;
|
|
|
1792 return finish_type_requirement (type);
|
|
|
1793 }
|
|
|
1794
|
|
|
1795 /* Substitute args into the compound requirement T. If substituting
|
|
|
1796 into either the expression or the type fails, the corresponding
|
|
|
1797 operands in the resulting node will be error_mark_node. This
|
|
|
1798 preserves a requirement for the purpose of partial ordering, but
|
|
|
1799 it will never be satisfied. */
|
|
|
1800
|
|
|
1801 tree
|
|
|
1802 tsubst_compound_requirement (tree t, tree args,
|
|
|
1803 tsubst_flags_t complain, tree in_decl)
|
|
|
1804 {
|
|
|
1805 ++processing_template_decl;
|
|
|
1806 tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
|
|
|
1807 tree type = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
|
|
|
1808 --processing_template_decl;
|
|
|
1809 bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t);
|
|
|
1810 return finish_compound_requirement (expr, type, noexcept_p);
|
|
|
1811 }
|
|
|
1812
|
|
|
1813 /* Substitute ARGS into the nested requirement T. */
|
|
|
1814
|
|
|
1815 tree
|
|
|
1816 tsubst_nested_requirement (tree t, tree args,
|
|
|
1817 tsubst_flags_t complain, tree in_decl)
|
|
|
1818 {
|
|
|
1819 ++processing_template_decl;
|
|
|
1820 tree expr = tsubst_expr (TREE_OPERAND (t, 0), args, complain, in_decl, false);
|
|
|
1821 --processing_template_decl;
|
|
|
1822 return finish_nested_requirement (expr);
|
|
|
1823 }
|
|
|
1824
|
|
|
1825 /* Substitute ARGS into the requirement T. */
|
|
|
1826
|
|
|
1827 inline tree
|
|
|
1828 tsubst_requirement (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
1829 {
|
|
|
1830 switch (TREE_CODE (t))
|
|
|
1831 {
|
|
|
1832 case SIMPLE_REQ:
|
|
|
1833 return tsubst_simple_requirement (t, args, complain, in_decl);
|
|
|
1834 case TYPE_REQ:
|
|
|
1835 return tsubst_type_requirement (t, args, complain, in_decl);
|
|
|
1836 case COMPOUND_REQ:
|
|
|
1837 return tsubst_compound_requirement (t, args, complain, in_decl);
|
|
|
1838 case NESTED_REQ:
|
|
|
1839 return tsubst_nested_requirement (t, args, complain, in_decl);
|
|
|
1840 default:
|
|
|
1841 gcc_unreachable ();
|
|
|
1842 }
|
|
|
1843 return error_mark_node;
|
|
|
1844 }
|
|
|
1845
|
|
|
1846 /* Substitute ARGS into the list of requirements T. Note that
|
|
|
1847 substitution failures here result in ill-formed programs. */
|
|
|
1848
|
|
|
1849 tree
|
|
|
1850 tsubst_requirement_body (tree t, tree args,
|
|
|
1851 tsubst_flags_t complain, tree in_decl)
|
|
|
1852 {
|
|
|
1853 tree r = NULL_TREE;
|
|
|
1854 while (t)
|
|
|
1855 {
|
|
|
1856 tree e = tsubst_requirement (TREE_VALUE (t), args, complain, in_decl);
|
|
|
1857 if (e == error_mark_node)
|
|
|
1858 return error_mark_node;
|
|
|
1859 r = tree_cons (NULL_TREE, e, r);
|
|
|
1860 t = TREE_CHAIN (t);
|
|
|
1861 }
|
|
|
1862 /* Ensure that the order of constraints is the same as the original. */
|
|
|
1863 return nreverse (r);
|
|
|
1864 }
|
|
|
1865
|
|
|
1866 } /* namespace */
|
|
|
1867
|
|
|
1868 /* Substitute ARGS into the requires expression T. Note that this
|
|
|
1869 results in the re-declaration of local parameters when
|
|
|
1870 substituting through the parameter list. If either substitution
|
|
|
1871 fails, the program is ill-formed. */
|
|
|
1872
|
|
|
1873 tree
|
|
|
1874 tsubst_requires_expr (tree t, tree args,
|
|
|
1875 tsubst_flags_t complain, tree in_decl)
|
|
|
1876 {
|
|
|
1877 local_specialization_stack stack;
|
|
|
1878
|
|
|
1879 tree parms = TREE_OPERAND (t, 0);
|
|
|
1880 if (parms)
|
|
|
1881 {
|
|
|
1882 parms = tsubst_constraint_variables (parms, args, complain, in_decl);
|
|
|
1883 if (parms == error_mark_node)
|
|
|
1884 return error_mark_node;
|
|
|
1885 }
|
|
|
1886
|
|
|
1887 tree reqs = TREE_OPERAND (t, 1);
|
|
|
1888 reqs = tsubst_requirement_body (reqs, args, complain, in_decl);
|
|
|
1889 if (reqs == error_mark_node)
|
|
|
1890 return error_mark_node;
|
|
|
1891
|
|
|
1892 return finish_requires_expr (parms, reqs);
|
|
|
1893 }
|
|
|
1894
|
|
|
1895 /* Substitute ARGS into the constraint information CI, producing a new
|
|
|
1896 constraint record. */
|
|
|
1897
|
|
|
1898 tree
|
|
|
1899 tsubst_constraint_info (tree t, tree args,
|
|
|
1900 tsubst_flags_t complain, tree in_decl)
|
|
|
1901 {
|
|
|
1902 if (!t || t == error_mark_node || !check_constraint_info (t))
|
|
|
1903 return NULL_TREE;
|
|
|
1904
|
|
|
1905 tree tmpl_constr = NULL_TREE;
|
|
|
1906 if (tree r = CI_TEMPLATE_REQS (t))
|
|
|
1907 tmpl_constr = tsubst_constraint (r, args, complain, in_decl);
|
|
|
1908
|
|
|
1909 tree decl_constr = NULL_TREE;
|
|
|
1910 if (tree r = CI_DECLARATOR_REQS (t))
|
|
|
1911 decl_constr = tsubst_constraint (r, args, complain, in_decl);
|
|
|
1912
|
|
|
1913 return build_constraints (tmpl_constr, decl_constr);
|
|
|
1914 }
|
|
|
1915
|
|
|
1916 /* Substitute ARGS into the constraint T. */
|
|
|
1917
|
|
|
1918 tree
|
|
|
1919 tsubst_constraint (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
1920 {
|
|
|
1921 if (t == NULL_TREE)
|
|
|
1922 return t;
|
|
|
1923 switch (TREE_CODE (t))
|
|
|
1924 {
|
|
|
1925 case PRED_CONSTR:
|
|
|
1926 return tsubst_predicate_constraint (t, args, complain, in_decl);
|
|
|
1927 case CHECK_CONSTR:
|
|
|
1928 return tsubst_check_constraint (t, args, complain, in_decl);
|
|
|
1929 case CONJ_CONSTR:
|
|
|
1930 case DISJ_CONSTR:
|
|
|
1931 return tsubst_logical_operator (t, args, complain, in_decl);
|
|
|
1932 case PARM_CONSTR:
|
|
|
1933 return tsubst_parameterized_constraint (t, args, complain, in_decl);
|
|
|
1934 case EXPR_CONSTR:
|
|
|
1935 return tsubst_expr_constr (t, args, complain, in_decl);
|
|
|
1936 case TYPE_CONSTR:
|
|
|
1937 return tsubst_type_constr (t, args, complain, in_decl);
|
|
|
1938 case ICONV_CONSTR:
|
|
|
1939 return tsubst_implicit_conversion_constr (t, args, complain, in_decl);
|
|
|
1940 case DEDUCT_CONSTR:
|
|
|
1941 return tsubst_argument_deduction_constr (t, args, complain, in_decl);
|
|
|
1942 case EXCEPT_CONSTR:
|
|
|
1943 return tsubst_exception_constr (t, args, complain, in_decl);
|
|
|
1944 default:
|
|
|
1945 gcc_unreachable ();
|
|
|
1946 }
|
|
|
1947 return error_mark_node;
|
|
|
1948 }
|
|
|
1949
|
|
|
1950 /*---------------------------------------------------------------------------
|
|
|
1951 Constraint satisfaction
|
|
|
1952 ---------------------------------------------------------------------------*/
|
|
|
1953
|
|
|
1954 /* The following functions determine if a constraint, when
|
|
|
1955 substituting template arguments, is satisfied. For convenience,
|
|
|
1956 satisfaction reduces a constraint to either true or false (and
|
|
|
1957 nothing else). */
|
|
|
1958
|
|
|
1959 namespace {
|
|
|
1960
|
|
|
1961 tree satisfy_constraint_1 (tree, tree, tsubst_flags_t, tree);
|
|
|
1962
|
|
|
1963 /* Check the constraint pack expansion. */
|
|
|
1964
|
|
|
1965 tree
|
|
|
1966 satisfy_pack_expansion (tree t, tree args,
|
|
|
1967 tsubst_flags_t complain, tree in_decl)
|
|
|
1968 {
|
|
|
1969 /* Get the vector of satisfaction results.
|
|
|
1970 gen_elem_of_pack_expansion_instantiation will check that each element of
|
|
|
1971 the expansion is satisfied. */
|
|
|
1972 tree exprs = tsubst_pack_expansion (t, args, complain, in_decl);
|
|
|
1973
|
|
|
1974 if (exprs == error_mark_node)
|
|
|
1975 return boolean_false_node;
|
|
|
1976
|
|
|
1977 /* TODO: It might be better to normalize each expanded term
|
|
|
1978 and evaluate them separately. That would provide better
|
|
|
1979 opportunities for diagnostics. */
|
|
|
1980 for (int i = 0; i < TREE_VEC_LENGTH (exprs); ++i)
|
|
|
1981 if (TREE_VEC_ELT (exprs, i) != boolean_true_node)
|
|
|
1982 return boolean_false_node;
|
|
|
1983 return boolean_true_node;
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 /* A predicate constraint is satisfied if its expression evaluates
|
|
|
1987 to true. If substitution into that node fails, the constraint
|
|
|
1988 is not satisfied ([temp.constr.pred]).
|
|
|
1989
|
|
|
1990 Note that a predicate constraint is a constraint expression
|
|
|
1991 of type bool. If neither of those are true, the program is
|
|
|
1992 ill-formed; they are not SFINAE'able errors. */
|
|
|
1993
|
|
|
1994 tree
|
|
|
1995 satisfy_predicate_constraint (tree t, tree args,
|
|
|
1996 tsubst_flags_t complain, tree in_decl)
|
|
|
1997 {
|
|
|
1998 tree expr = TREE_OPERAND (t, 0);
|
|
|
1999
|
|
|
2000 /* We should never have a naked pack expansion in a predicate constraint. */
|
|
|
2001 gcc_assert (TREE_CODE (expr) != EXPR_PACK_EXPANSION);
|
|
|
2002
|
|
|
2003 /* If substitution into the expression fails, the constraint
|
|
|
2004 is not satisfied. */
|
|
|
2005 expr = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
2006 if (expr == error_mark_node)
|
|
|
2007 return boolean_false_node;
|
|
|
2008
|
|
|
2009 /* A predicate constraint shall have type bool. In some
|
|
|
2010 cases, substitution gives us const-qualified bool, which
|
|
|
2011 is also acceptable. */
|
|
|
2012 tree type = cv_unqualified (TREE_TYPE (expr));
|
|
|
2013 if (!same_type_p (type, boolean_type_node))
|
|
|
2014 {
|
|
|
2015 error_at (EXPR_LOC_OR_LOC (expr, input_location),
|
|
|
2016 "constraint %qE does not have type %qT",
|
|
|
2017 expr, boolean_type_node);
|
|
|
2018 return boolean_false_node;
|
|
|
2019 }
|
|
|
2020
|
|
|
2021 return cxx_constant_value (expr);
|
|
|
2022 }
|
|
|
2023
|
|
|
2024 /* A concept check constraint like C<CARGS> is satisfied if substituting ARGS
|
|
|
2025 into CARGS succeeds and C is satisfied for the resulting arguments. */
|
|
|
2026
|
|
|
2027 tree
|
|
|
2028 satisfy_check_constraint (tree t, tree args,
|
|
|
2029 tsubst_flags_t complain, tree in_decl)
|
|
|
2030 {
|
|
|
2031 tree decl = CHECK_CONSTR_CONCEPT (t);
|
|
|
2032 tree tmpl = DECL_TI_TEMPLATE (decl);
|
|
|
2033 tree cargs = CHECK_CONSTR_ARGS (t);
|
|
|
2034
|
|
|
2035 /* Instantiate the concept check arguments. */
|
|
|
2036 tree targs = tsubst (cargs, args, tf_none, NULL_TREE);
|
|
|
2037 if (targs == error_mark_node)
|
|
|
2038 return boolean_false_node;
|
|
|
2039
|
|
|
2040 /* Search for a previous value. */
|
|
|
2041 if (tree prev = lookup_concept_satisfaction (tmpl, targs))
|
|
|
2042 return prev;
|
|
|
2043
|
|
|
2044 /* Expand the concept; failure here implies non-satisfaction. */
|
|
|
2045 tree def = expand_concept (decl, targs);
|
|
|
2046 if (def == error_mark_node)
|
|
|
2047 return memoize_concept_satisfaction (tmpl, args, boolean_false_node);
|
|
|
2048
|
|
|
2049 /* Recursively satisfy the constraint. */
|
|
|
2050 tree result = satisfy_constraint_1 (def, targs, complain, in_decl);
|
|
|
2051 return memoize_concept_satisfaction (tmpl, targs, result);
|
|
|
2052 }
|
|
|
2053
|
|
|
2054 /* Check an expression constraint. The constraint is satisfied if
|
|
|
2055 substitution succeeds ([temp.constr.expr]).
|
|
|
2056
|
|
|
2057 Note that the expression is unevaluated. */
|
|
|
2058
|
|
|
2059 tree
|
|
|
2060 satisfy_expression_constraint (tree t, tree args,
|
|
|
2061 tsubst_flags_t complain, tree in_decl)
|
|
|
2062 {
|
|
|
2063 cp_unevaluated guard;
|
|
|
2064 deferring_access_check_sentinel deferring;
|
|
|
2065
|
|
|
2066 tree expr = EXPR_CONSTR_EXPR (t);
|
|
|
2067 tree check = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
2068 if (check == error_mark_node)
|
|
|
2069 return boolean_false_node;
|
|
|
2070 if (!perform_deferred_access_checks (tf_none))
|
|
|
2071 return boolean_false_node;
|
|
|
2072 return boolean_true_node;
|
|
|
2073 }
|
|
|
2074
|
|
|
2075 /* Check a type constraint. The constraint is satisfied if
|
|
|
2076 substitution succeeds. */
|
|
|
2077
|
|
|
2078 inline tree
|
|
|
2079 satisfy_type_constraint (tree t, tree args,
|
|
|
2080 tsubst_flags_t complain, tree in_decl)
|
|
|
2081 {
|
|
|
2082 deferring_access_check_sentinel deferring;
|
|
|
2083 tree type = TYPE_CONSTR_TYPE (t);
|
|
|
2084 gcc_assert (TYPE_P (type) || type == error_mark_node);
|
|
|
2085 tree check = tsubst (type, args, complain, in_decl);
|
|
|
2086 if (error_operand_p (check))
|
|
|
2087 return boolean_false_node;
|
|
|
2088 if (!perform_deferred_access_checks (complain))
|
|
|
2089 return boolean_false_node;
|
|
|
2090 return boolean_true_node;
|
|
|
2091 }
|
|
|
2092
|
|
|
2093 /* Check an implicit conversion constraint. */
|
|
|
2094
|
|
|
2095 tree
|
|
|
2096 satisfy_implicit_conversion_constraint (tree t, tree args,
|
|
|
2097 tsubst_flags_t complain, tree in_decl)
|
|
|
2098 {
|
|
|
2099 /* Don't tsubst as if we're processing a template. If we try
|
|
|
2100 to we can end up generating template-like expressions
|
|
|
2101 (e.g., modop-exprs) that aren't properly typed. */
|
|
|
2102 tree expr =
|
|
|
2103 tsubst_expr (ICONV_CONSTR_EXPR (t), args, complain, in_decl, false);
|
|
|
2104 if (expr == error_mark_node)
|
|
|
2105 return boolean_false_node;
|
|
|
2106
|
|
|
2107 /* Get the transformed target type. */
|
|
|
2108 tree type = tsubst (ICONV_CONSTR_TYPE (t), args, complain, in_decl);
|
|
|
2109 if (type == error_mark_node)
|
|
|
2110 return boolean_false_node;
|
|
|
2111
|
|
|
2112 /* Attempt the conversion as a direct initialization
|
|
|
2113 of the form TYPE <unspecified> = EXPR. */
|
|
|
2114 tree conv =
|
|
|
2115 perform_direct_initialization_if_possible (type, expr, false, complain);
|
|
|
2116 if (conv == NULL_TREE || conv == error_mark_node)
|
|
|
2117 return boolean_false_node;
|
|
|
2118 else
|
|
|
2119 return boolean_true_node;
|
|
|
2120 }
|
|
|
2121
|
|
|
2122 /* Check an argument deduction constraint. */
|
|
|
2123
|
|
|
2124 tree
|
|
|
2125 satisfy_argument_deduction_constraint (tree t, tree args,
|
|
|
2126 tsubst_flags_t complain, tree in_decl)
|
|
|
2127 {
|
|
|
2128 /* Substitute through the expression. */
|
|
|
2129 tree expr = DEDUCT_CONSTR_EXPR (t);
|
|
|
2130 tree init = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
2131 if (expr == error_mark_node)
|
|
|
2132 return boolean_false_node;
|
|
|
2133
|
|
|
2134 /* Perform auto or decltype(auto) deduction to get the result. */
|
|
|
2135 tree pattern = DEDUCT_CONSTR_PATTERN (t);
|
|
|
2136 tree placeholder = DEDUCT_CONSTR_PLACEHOLDER (t);
|
|
|
2137 tree constr = PLACEHOLDER_TYPE_CONSTRAINTS (placeholder);
|
|
|
2138 tree type_canonical = TYPE_CANONICAL (placeholder);
|
|
|
2139 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder)
|
|
|
2140 = tsubst_constraint (constr, args, complain|tf_partial, in_decl);
|
|
|
2141 TYPE_CANONICAL (placeholder) = NULL_TREE;
|
|
|
2142 tree type = do_auto_deduction (pattern, init, placeholder,
|
|
|
2143 complain, adc_requirement);
|
|
|
2144 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder) = constr;
|
|
|
2145 TYPE_CANONICAL (placeholder) = type_canonical;
|
|
|
2146 if (type == error_mark_node)
|
|
|
2147 return boolean_false_node;
|
|
|
2148
|
|
|
2149 return boolean_true_node;
|
|
|
2150 }
|
|
|
2151
|
|
|
2152 /* Check an exception constraint. An exception constraint for an
|
|
|
2153 expression e is satisfied when noexcept(e) is true. */
|
|
|
2154
|
|
|
2155 tree
|
|
|
2156 satisfy_exception_constraint (tree t, tree args,
|
|
|
2157 tsubst_flags_t complain, tree in_decl)
|
|
|
2158 {
|
|
|
2159 tree expr = EXCEPT_CONSTR_EXPR (t);
|
|
|
2160 tree check = tsubst_expr (expr, args, complain, in_decl, false);
|
|
|
2161 if (check == error_mark_node)
|
|
|
2162 return boolean_false_node;
|
|
|
2163
|
|
|
2164 if (expr_noexcept_p (check, complain))
|
|
|
2165 return boolean_true_node;
|
|
|
2166 else
|
|
|
2167 return boolean_false_node;
|
|
|
2168 }
|
|
|
2169
|
|
|
2170 /* Check a parameterized constraint. */
|
|
|
2171
|
|
|
2172 tree
|
|
|
2173 satisfy_parameterized_constraint (tree t, tree args,
|
|
|
2174 tsubst_flags_t complain, tree in_decl)
|
|
|
2175 {
|
|
|
2176 local_specialization_stack stack;
|
|
|
2177 tree parms = PARM_CONSTR_PARMS (t);
|
|
|
2178 tree vars = tsubst_constraint_variables (parms, args, complain, in_decl);
|
|
|
2179 if (vars == error_mark_node)
|
|
|
2180 return boolean_false_node;
|
|
|
2181 tree constr = PARM_CONSTR_OPERAND (t);
|
|
|
2182 return satisfy_constraint_1 (constr, args, complain, in_decl);
|
|
|
2183 }
|
|
|
2184
|
|
|
2185 /* Check that the conjunction of constraints is satisfied. Note
|
|
|
2186 that if left operand is not satisfied, the right operand
|
|
|
2187 is not checked.
|
|
|
2188
|
|
|
2189 FIXME: Check that this wouldn't result in a user-defined
|
|
|
2190 operator. Note that this error is partially diagnosed in
|
|
|
2191 satisfy_predicate_constraint. It would be nice to diagnose
|
|
|
2192 the overload, but I don't think it's strictly necessary. */
|
|
|
2193
|
|
|
2194 tree
|
|
|
2195 satisfy_conjunction (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
2196 {
|
|
|
2197 tree t0 = satisfy_constraint_1 (TREE_OPERAND (t, 0), args, complain, in_decl);
|
|
|
2198 if (t0 == boolean_false_node)
|
|
|
2199 return boolean_false_node;
|
|
|
2200 return satisfy_constraint_1 (TREE_OPERAND (t, 1), args, complain, in_decl);
|
|
|
2201 }
|
|
|
2202
|
|
|
2203 /* Check that the disjunction of constraints is satisfied. Note
|
|
|
2204 that if the left operand is satisfied, the right operand is not
|
|
|
2205 checked. */
|
|
|
2206
|
|
|
2207 tree
|
|
|
2208 satisfy_disjunction (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
2209 {
|
|
|
2210 tree t0 = satisfy_constraint_1 (TREE_OPERAND (t, 0), args, complain, in_decl);
|
|
|
2211 if (t0 == boolean_true_node)
|
|
|
2212 return boolean_true_node;
|
|
|
2213 return satisfy_constraint_1 (TREE_OPERAND (t, 1), args, complain, in_decl);
|
|
|
2214 }
|
|
|
2215
|
|
|
2216 /* Dispatch to an appropriate satisfaction routine depending on the
|
|
|
2217 tree code of T. */
|
|
|
2218
|
|
|
2219 tree
|
|
|
2220 satisfy_constraint_1 (tree t, tree args, tsubst_flags_t complain, tree in_decl)
|
|
|
2221 {
|
|
|
2222 gcc_assert (!processing_template_decl);
|
|
|
2223
|
|
|
2224 if (!t)
|
|
|
2225 return boolean_false_node;
|
|
|
2226
|
|
|
2227 if (t == error_mark_node)
|
|
|
2228 return boolean_false_node;
|
|
|
2229
|
|
|
2230 switch (TREE_CODE (t))
|
|
|
2231 {
|
|
|
2232 case PRED_CONSTR:
|
|
|
2233 return satisfy_predicate_constraint (t, args, complain, in_decl);
|
|
|
2234
|
|
|
2235 case CHECK_CONSTR:
|
|
|
2236 return satisfy_check_constraint (t, args, complain, in_decl);
|
|
|
2237
|
|
|
2238 case EXPR_CONSTR:
|
|
|
2239 return satisfy_expression_constraint (t, args, complain, in_decl);
|
|
|
2240
|
|
|
2241 case TYPE_CONSTR:
|
|
|
2242 return satisfy_type_constraint (t, args, complain, in_decl);
|
|
|
2243
|
|
|
2244 case ICONV_CONSTR:
|
|
|
2245 return satisfy_implicit_conversion_constraint (t, args, complain, in_decl);
|
|
|
2246
|
|
|
2247 case DEDUCT_CONSTR:
|
|
|
2248 return satisfy_argument_deduction_constraint (t, args, complain, in_decl);
|
|
|
2249
|
|
|
2250 case EXCEPT_CONSTR:
|
|
|
2251 return satisfy_exception_constraint (t, args, complain, in_decl);
|
|
|
2252
|
|
|
2253 case PARM_CONSTR:
|
|
|
2254 return satisfy_parameterized_constraint (t, args, complain, in_decl);
|
|
|
2255
|
|
|
2256 case CONJ_CONSTR:
|
|
|
2257 return satisfy_conjunction (t, args, complain, in_decl);
|
|
|
2258
|
|
|
2259 case DISJ_CONSTR:
|
|
|
2260 return satisfy_disjunction (t, args, complain, in_decl);
|
|
|
2261
|
|
|
2262 case EXPR_PACK_EXPANSION:
|
|
|
2263 return satisfy_pack_expansion (t, args, complain, in_decl);
|
|
|
2264
|
|
|
2265 default:
|
|
|
2266 gcc_unreachable ();
|
|
|
2267 }
|
|
|
2268 return boolean_false_node;
|
|
|
2269 }
|
|
|
2270
|
|
|
2271 /* Check that the constraint is satisfied, according to the rules
|
|
|
2272 for that constraint. Note that each satisfy_* function returns
|
|
|
2273 true or false, depending on whether it is satisfied or not. */
|
|
|
2274
|
|
|
2275 tree
|
|
|
2276 satisfy_constraint (tree t, tree args)
|
|
|
2277 {
|
|
|
2278 auto_timevar time (TV_CONSTRAINT_SAT);
|
|
|
2279
|
|
|
2280 /* Turn off template processing. Constraint satisfaction only applies
|
|
|
2281 to non-dependent terms, so we want to ensure full checking here. */
|
|
|
2282 processing_template_decl_sentinel proc (true);
|
|
|
2283
|
|
|
2284 /* Avoid early exit in tsubst and tsubst_copy from null args; since earlier
|
|
|
2285 substitution was done with processing_template_decl forced on, there will
|
|
|
2286 be expressions that still need semantic processing, possibly buried in
|
|
|
2287 decltype or a template argument. */
|
|
|
2288 if (args == NULL_TREE)
|
|
|
2289 args = make_tree_vec (1);
|
|
|
2290
|
|
|
2291 return satisfy_constraint_1 (t, args, tf_none, NULL_TREE);
|
|
|
2292 }
|
|
|
2293
|
|
|
2294 /* Check the associated constraints in CI against the given
|
|
|
2295 ARGS, returning true when the constraints are satisfied
|
|
|
2296 and false otherwise. */
|
|
|
2297
|
|
|
2298 tree
|
|
|
2299 satisfy_associated_constraints (tree ci, tree args)
|
|
|
2300 {
|
|
|
2301 /* If there are no constraints then this is trivially satisfied. */
|
|
|
2302 if (!ci)
|
|
|
2303 return boolean_true_node;
|
|
|
2304
|
|
|
2305 /* If any arguments depend on template parameters, we can't
|
|
|
2306 check constraints. */
|
|
|
2307 if (args && uses_template_parms (args))
|
|
|
2308 return boolean_true_node;
|
|
|
2309
|
|
|
2310 /* Check if we've seen a previous result. */
|
|
|
2311 if (tree prev = lookup_constraint_satisfaction (ci, args))
|
|
|
2312 return prev;
|
|
|
2313
|
|
|
2314 /* Actually test for satisfaction. */
|
|
|
2315 tree result = satisfy_constraint (CI_ASSOCIATED_CONSTRAINTS (ci), args);
|
|
|
2316 return memoize_constraint_satisfaction (ci, args, result);
|
|
|
2317 }
|
|
|
2318
|
|
|
2319 } /* namespace */
|
|
|
2320
|
|
|
2321 /* Evaluate the given constraint, returning boolean_true_node
|
|
|
2322 if the constraint is satisfied and boolean_false_node
|
|
|
2323 otherwise. */
|
|
|
2324
|
|
|
2325 tree
|
|
|
2326 evaluate_constraints (tree constr, tree args)
|
|
|
2327 {
|
|
|
2328 gcc_assert (constraint_p (constr));
|
|
|
2329 return satisfy_constraint (constr, args);
|
|
|
2330 }
|
|
|
2331
|
|
|
2332 /* Evaluate the function concept FN by substituting its own args
|
|
|
2333 into its definition and evaluating that as the result. Returns
|
|
|
2334 boolean_true_node if the constraints are satisfied and
|
|
|
2335 boolean_false_node otherwise. */
|
|
|
2336
|
|
|
2337 tree
|
|
|
2338 evaluate_function_concept (tree fn, tree args)
|
|
|
2339 {
|
|
|
2340 tree constr = build_nt (CHECK_CONSTR, fn, args);
|
|
|
2341 return satisfy_constraint (constr, args);
|
|
|
2342 }
|
|
|
2343
|
|
|
2344 /* Evaluate the variable concept VAR by substituting its own args into
|
|
|
2345 its initializer and checking the resulting constraint. Returns
|
|
|
2346 boolean_true_node if the constraints are satisfied and
|
|
|
2347 boolean_false_node otherwise. */
|
|
|
2348
|
|
|
2349 tree
|
|
|
2350 evaluate_variable_concept (tree var, tree args)
|
|
|
2351 {
|
|
|
2352 tree constr = build_nt (CHECK_CONSTR, var, args);
|
|
|
2353 return satisfy_constraint (constr, args);
|
|
|
2354 }
|
|
|
2355
|
|
|
2356 /* Evaluate the given expression as if it were a predicate
|
|
|
2357 constraint. Returns boolean_true_node if the constraint
|
|
|
2358 is satisfied and boolean_false_node otherwise. */
|
|
|
2359
|
|
|
2360 tree
|
|
|
2361 evaluate_constraint_expression (tree expr, tree args)
|
|
|
2362 {
|
|
|
2363 tree constr = normalize_expression (expr);
|
|
|
2364 return satisfy_constraint (constr, args);
|
|
|
2365 }
|
|
|
2366
|
|
|
2367 /* Returns true if the DECL's constraints are satisfied.
|
|
|
2368 This is used in cases where a declaration is formed but
|
|
|
2369 before it is used (e.g., overload resolution). */
|
|
|
2370
|
|
|
2371 bool
|
|
|
2372 constraints_satisfied_p (tree decl)
|
|
|
2373 {
|
|
|
2374 /* Get the constraints to check for satisfaction. This depends
|
|
|
2375 on whether we're looking at a template specialization or not. */
|
|
|
2376 tree ci;
|
|
|
2377 tree args = NULL_TREE;
|
|
|
2378 if (tree ti = DECL_TEMPLATE_INFO (decl))
|
|
|
2379 {
|
|
|
2380 tree tmpl = TI_TEMPLATE (ti);
|
|
|
2381 ci = get_constraints (tmpl);
|
|
|
2382 int depth = TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl));
|
|
|
2383 args = get_innermost_template_args (TI_ARGS (ti), depth);
|
|
|
2384 }
|
|
|
2385 else
|
|
|
2386 {
|
|
|
2387 ci = get_constraints (decl);
|
|
|
2388 }
|
|
|
2389
|
|
|
2390 tree eval = satisfy_associated_constraints (ci, args);
|
|
|
2391 return eval == boolean_true_node;
|
|
|
2392 }
|
|
|
2393
|
|
|
2394 /* Returns true if the constraints are satisfied by ARGS.
|
|
|
2395 Here, T can be either a constraint or a constrained
|
|
|
2396 declaration. */
|
|
|
2397
|
|
|
2398 bool
|
|
|
2399 constraints_satisfied_p (tree t, tree args)
|
|
|
2400 {
|
|
|
2401 tree eval;
|
|
|
2402 if (constraint_p (t))
|
|
|
2403 eval = evaluate_constraints (t, args);
|
|
|
2404 else
|
|
|
2405 eval = satisfy_associated_constraints (get_constraints (t), args);
|
|
|
2406 return eval == boolean_true_node;
|
|
|
2407 }
|
|
|
2408
|
|
|
2409 namespace
|
|
|
2410 {
|
|
|
2411
|
|
|
2412 /* Normalize EXPR and determine if the resulting constraint is
|
|
|
2413 satisfied by ARGS. Returns true if and only if the constraint
|
|
|
2414 is satisfied. This is used extensively by diagnostics to
|
|
|
2415 determine causes for failure. */
|
|
|
2416
|
|
|
2417 inline bool
|
|
|
2418 constraint_expression_satisfied_p (tree expr, tree args)
|
|
|
2419 {
|
|
|
2420 return evaluate_constraint_expression (expr, args) == boolean_true_node;
|
|
|
2421 }
|
|
|
2422
|
|
|
2423 } /* namespace */
|
|
|
2424
|
|
|
2425 /*---------------------------------------------------------------------------
|
|
|
2426 Semantic analysis of requires-expressions
|
|
|
2427 ---------------------------------------------------------------------------*/
|
|
|
2428
|
|
|
2429 /* Finish a requires expression for the given PARMS (possibly
|
|
|
2430 null) and the non-empty sequence of requirements. */
|
|
|
2431 tree
|
|
|
2432 finish_requires_expr (tree parms, tree reqs)
|
|
|
2433 {
|
|
|
2434 /* Modify the declared parameters by removing their context
|
|
|
2435 so they don't refer to the enclosing scope and explicitly
|
|
|
2436 indicating that they are constraint variables. */
|
|
|
2437 for (tree parm = parms; parm; parm = DECL_CHAIN (parm))
|
|
|
2438 {
|
|
|
2439 DECL_CONTEXT (parm) = NULL_TREE;
|
|
|
2440 CONSTRAINT_VAR_P (parm) = true;
|
|
|
2441 }
|
|
|
2442
|
|
|
2443 /* Build the node. */
|
|
|
2444 tree r = build_min (REQUIRES_EXPR, boolean_type_node, parms, reqs);
|
|
|
2445 TREE_SIDE_EFFECTS (r) = false;
|
|
|
2446 TREE_CONSTANT (r) = true;
|
|
|
2447 return r;
|
|
|
2448 }
|
|
|
2449
|
|
|
2450 /* Construct a requirement for the validity of EXPR. */
|
|
|
2451 tree
|
|
|
2452 finish_simple_requirement (tree expr)
|
|
|
2453 {
|
|
|
2454 return build_nt (SIMPLE_REQ, expr);
|
|
|
2455 }
|
|
|
2456
|
|
|
2457 /* Construct a requirement for the validity of TYPE. */
|
|
|
2458 tree
|
|
|
2459 finish_type_requirement (tree type)
|
|
|
2460 {
|
|
|
2461 return build_nt (TYPE_REQ, type);
|
|
|
2462 }
|
|
|
2463
|
|
|
2464 /* Construct a requirement for the validity of EXPR, along with
|
|
|
2465 its properties. if TYPE is non-null, then it specifies either
|
|
|
2466 an implicit conversion or argument deduction constraint,
|
|
|
2467 depending on whether any placeholders occur in the type name.
|
|
|
2468 NOEXCEPT_P is true iff the noexcept keyword was specified. */
|
|
|
2469 tree
|
|
|
2470 finish_compound_requirement (tree expr, tree type, bool noexcept_p)
|
|
|
2471 {
|
|
|
2472 tree req = build_nt (COMPOUND_REQ, expr, type);
|
|
|
2473 COMPOUND_REQ_NOEXCEPT_P (req) = noexcept_p;
|
|
|
2474 return req;
|
|
|
2475 }
|
|
|
2476
|
|
|
2477 /* Finish a nested requirement. */
|
|
|
2478 tree
|
|
|
2479 finish_nested_requirement (tree expr)
|
|
|
2480 {
|
|
|
2481 return build_nt (NESTED_REQ, expr);
|
|
|
2482 }
|
|
|
2483
|
|
|
2484 // Check that FN satisfies the structural requirements of a
|
|
|
2485 // function concept definition.
|
|
|
2486 tree
|
|
|
2487 check_function_concept (tree fn)
|
|
|
2488 {
|
|
|
2489 // Check that the function is comprised of only a single
|
|
|
2490 // return statement.
|
|
|
2491 tree body = DECL_SAVED_TREE (fn);
|
|
|
2492 if (TREE_CODE (body) == BIND_EXPR)
|
|
|
2493 body = BIND_EXPR_BODY (body);
|
|
|
2494
|
|
|
2495 // Sometimes a function call results in the creation of clean up
|
|
|
2496 // points. Allow these to be preserved in the body of the
|
|
|
2497 // constraint, as we might actually need them for some constexpr
|
|
|
2498 // evaluations.
|
|
|
2499 if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
|
|
|
2500 body = TREE_OPERAND (body, 0);
|
|
|
2501
|
|
|
2502 /* Check that the definition is written correctly. */
|
|
|
2503 if (TREE_CODE (body) != RETURN_EXPR)
|
|
|
2504 {
|
|
|
2505 location_t loc = DECL_SOURCE_LOCATION (fn);
|
|
|
2506 if (TREE_CODE (body) == STATEMENT_LIST && !STATEMENT_LIST_HEAD (body))
|
|
|
2507 {
|
|
|
2508 if (seen_error ())
|
|
|
2509 /* The definition was probably erroneous, not empty. */;
|
|
|
2510 else
|
|
|
2511 error_at (loc, "definition of concept %qD is empty", fn);
|
|
|
2512 }
|
|
|
2513 else
|
|
|
2514 error_at (loc, "definition of concept %qD has multiple statements", fn);
|
|
|
2515 }
|
|
|
2516
|
|
|
2517 return NULL_TREE;
|
|
|
2518 }
|
|
|
2519
|
|
|
2520
|
|
|
2521 // Check that a constrained friend declaration function declaration,
|
|
|
2522 // FN, is admissible. This is the case only when the declaration depends
|
|
|
2523 // on template parameters and does not declare a specialization.
|
|
|
2524 void
|
|
|
2525 check_constrained_friend (tree fn, tree reqs)
|
|
|
2526 {
|
|
|
2527 if (fn == error_mark_node)
|
|
|
2528 return;
|
|
|
2529 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
|
|
|
2530
|
|
|
2531 // If there are not constraints, this cannot be an error.
|
|
|
2532 if (!reqs)
|
|
|
2533 return;
|
|
|
2534
|
|
|
2535 // Constrained friend functions that don't depend on template
|
|
|
2536 // arguments are effectively meaningless.
|
|
|
2537 if (!uses_template_parms (TREE_TYPE (fn)))
|
|
|
2538 {
|
|
|
2539 error_at (location_of (fn),
|
|
|
2540 "constrained friend does not depend on template parameters");
|
|
|
2541 return;
|
|
|
2542 }
|
|
|
2543 }
|
|
|
2544
|
|
|
2545 /*---------------------------------------------------------------------------
|
|
|
2546 Equivalence of constraints
|
|
|
2547 ---------------------------------------------------------------------------*/
|
|
|
2548
|
|
|
2549 /* Returns true when A and B are equivalent constraints. */
|
|
|
2550 bool
|
|
|
2551 equivalent_constraints (tree a, tree b)
|
|
|
2552 {
|
|
|
2553 gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO);
|
|
|
2554 gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO);
|
|
|
2555 return cp_tree_equal (a, b);
|
|
|
2556 }
|
|
|
2557
|
|
|
2558 /* Returns true if the template declarations A and B have equivalent
|
|
|
2559 constraints. This is the case when A's constraints subsume B's and
|
|
|
2560 when B's also constrain A's. */
|
|
|
2561 bool
|
|
|
2562 equivalently_constrained (tree d1, tree d2)
|
|
|
2563 {
|
|
|
2564 gcc_assert (TREE_CODE (d1) == TREE_CODE (d2));
|
|
|
2565 return equivalent_constraints (get_constraints (d1), get_constraints (d2));
|
|
|
2566 }
|
|
|
2567
|
|
|
2568 /*---------------------------------------------------------------------------
|
|
|
2569 Partial ordering of constraints
|
|
|
2570 ---------------------------------------------------------------------------*/
|
|
|
2571
|
|
|
2572 /* Returns true when the the constraints in A subsume those in B. */
|
|
|
2573
|
|
|
2574 bool
|
|
|
2575 subsumes_constraints (tree a, tree b)
|
|
|
2576 {
|
|
|
2577 gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO);
|
|
|
2578 gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO);
|
|
|
2579 return subsumes (a, b);
|
|
|
2580 }
|
|
|
2581
|
|
|
2582 /* Returns true when the the constraints in A subsume those in B, but
|
|
|
2583 the constraints in B do not subsume the constraints in A. */
|
|
|
2584
|
|
|
2585 bool
|
|
|
2586 strictly_subsumes (tree a, tree b)
|
|
|
2587 {
|
|
|
2588 return subsumes (a, b) && !subsumes (b, a);
|
|
|
2589 }
|
|
|
2590
|
|
|
2591 /* Determines which of the declarations, A or B, is more constrained.
|
|
|
2592 That is, which declaration's constraints subsume but are not subsumed
|
|
|
2593 by the other's?
|
|
|
2594
|
|
|
2595 Returns 1 if A is more constrained than B, -1 if B is more constrained
|
|
|
2596 than A, and 0 otherwise. */
|
|
|
2597
|
|
|
2598 int
|
|
|
2599 more_constrained (tree d1, tree d2)
|
|
|
2600 {
|
|
|
2601 tree c1 = get_constraints (d1);
|
|
|
2602 tree c2 = get_constraints (d2);
|
|
|
2603 int winner = 0;
|
|
|
2604 if (subsumes_constraints (c1, c2))
|
|
|
2605 ++winner;
|
|
|
2606 if (subsumes_constraints (c2, c1))
|
|
|
2607 --winner;
|
|
|
2608 return winner;
|
|
|
2609 }
|
|
|
2610
|
|
|
2611 /* Returns true if D1 is at least as constrained as D2. That is, the
|
|
|
2612 associated constraints of D1 subsume those of D2, or both declarations
|
|
|
2613 are unconstrained. */
|
|
|
2614
|
|
|
2615 bool
|
|
|
2616 at_least_as_constrained (tree d1, tree d2)
|
|
|
2617 {
|
|
|
2618 tree c1 = get_constraints (d1);
|
|
|
2619 tree c2 = get_constraints (d2);
|
|
|
2620 return subsumes_constraints (c1, c2);
|
|
|
2621 }
|
|
|
2622
|
|
|
2623
|
|
|
2624 /*---------------------------------------------------------------------------
|
|
|
2625 Constraint diagnostics
|
|
|
2626
|
|
|
2627 FIXME: Normalize expressions into constraints before evaluating them.
|
|
|
2628 This should be the general pattern for all such diagnostics.
|
|
|
2629 ---------------------------------------------------------------------------*/
|
|
|
2630
|
|
|
2631 /* The number of detailed constraint failures. */
|
|
|
2632
|
|
|
2633 int constraint_errors = 0;
|
|
|
2634
|
|
|
2635 /* Do not generate errors after diagnosing this number of constraint
|
|
|
2636 failures.
|
|
|
2637
|
|
|
2638 FIXME: This is a really arbitrary number. Provide better control of
|
|
|
2639 constraint diagnostics with a command line option. */
|
|
|
2640
|
|
|
2641 int constraint_thresh = 20;
|
|
|
2642
|
|
|
2643
|
|
|
2644 /* Returns true if we should elide the diagnostic for a constraint failure.
|
|
|
2645 This is the case when the number of errors has exceeded the pre-configured
|
|
|
2646 threshold. */
|
|
|
2647
|
|
|
2648 inline bool
|
|
|
2649 elide_constraint_failure_p ()
|
|
|
2650 {
|
|
|
2651 bool ret = constraint_thresh <= constraint_errors;
|
|
|
2652 ++constraint_errors;
|
|
|
2653 return ret;
|
|
|
2654 }
|
|
|
2655
|
|
|
2656 /* Returns the number of undiagnosed errors. */
|
|
|
2657
|
|
|
2658 inline int
|
|
|
2659 undiagnosed_constraint_failures ()
|
|
|
2660 {
|
|
|
2661 return constraint_errors - constraint_thresh;
|
|
|
2662 }
|
|
|
2663
|
|
|
2664 /* The diagnosis of constraints performs a combination of normalization
|
|
|
2665 and satisfaction testing. We recursively walk through the conjunction or
|
|
|
2666 disjunction of associated constraints, testing each sub-constraint in
|
|
|
2667 turn. */
|
|
|
2668
|
|
|
2669 namespace {
|
|
|
2670
|
|
|
2671 void diagnose_constraint (location_t, tree, tree, tree);
|
|
|
2672
|
|
|
2673 /* Emit a specific diagnostics for a failed trait. */
|
|
|
2674
|
|
|
2675 void
|
|
|
2676 diagnose_trait_expression (location_t loc, tree, tree cur, tree args)
|
|
|
2677 {
|
|
|
2678 if (constraint_expression_satisfied_p (cur, args))
|
|
|
2679 return;
|
|
|
2680 if (elide_constraint_failure_p())
|
|
|
2681 return;
|
|
|
2682
|
|
|
2683 tree expr = PRED_CONSTR_EXPR (cur);
|
|
|
2684 ++processing_template_decl;
|
|
|
2685 expr = tsubst_expr (expr, args, tf_none, NULL_TREE, false);
|
|
|
2686 --processing_template_decl;
|
|
|
2687
|
|
|
2688 tree t1 = TRAIT_EXPR_TYPE1 (expr);
|
|
|
2689 tree t2 = TRAIT_EXPR_TYPE2 (expr);
|
|
|
2690 switch (TRAIT_EXPR_KIND (expr))
|
|
|
2691 {
|
|
|
2692 case CPTK_HAS_NOTHROW_ASSIGN:
|
|
|
2693 inform (loc, " %qT is not nothrow copy assignable", t1);
|
|
|
2694 break;
|
|
|
2695 case CPTK_HAS_NOTHROW_CONSTRUCTOR:
|
|
|
2696 inform (loc, " %qT is not nothrow default constructible", t1);
|
|
|
2697 break;
|
|
|
2698 case CPTK_HAS_NOTHROW_COPY:
|
|
|
2699 inform (loc, " %qT is not nothrow copy constructible", t1);
|
|
|
2700 break;
|
|
|
2701 case CPTK_HAS_TRIVIAL_ASSIGN:
|
|
|
2702 inform (loc, " %qT is not trivially copy assignable", t1);
|
|
|
2703 break;
|
|
|
2704 case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
|
|
|
2705 inform (loc, " %qT is not trivially default constructible", t1);
|
|
|
2706 break;
|
|
|
2707 case CPTK_HAS_TRIVIAL_COPY:
|
|
|
2708 inform (loc, " %qT is not trivially copy constructible", t1);
|
|
|
2709 break;
|
|
|
2710 case CPTK_HAS_TRIVIAL_DESTRUCTOR:
|
|
|
2711 inform (loc, " %qT is not trivially destructible", t1);
|
|
|
2712 break;
|
|
|
2713 case CPTK_HAS_VIRTUAL_DESTRUCTOR:
|
|
|
2714 inform (loc, " %qT does not have a virtual destructor", t1);
|
|
|
2715 break;
|
|
|
2716 case CPTK_IS_ABSTRACT:
|
|
|
2717 inform (loc, " %qT is not an abstract class", t1);
|
|
|
2718 break;
|
|
|
2719 case CPTK_IS_BASE_OF:
|
|
|
2720 inform (loc, " %qT is not a base of %qT", t1, t2);
|
|
|
2721 break;
|
|
|
2722 case CPTK_IS_CLASS:
|
|
|
2723 inform (loc, " %qT is not a class", t1);
|
|
|
2724 break;
|
|
|
2725 case CPTK_IS_EMPTY:
|
|
|
2726 inform (loc, " %qT is not an empty class", t1);
|
|
|
2727 break;
|
|
|
2728 case CPTK_IS_ENUM:
|
|
|
2729 inform (loc, " %qT is not an enum", t1);
|
|
|
2730 break;
|
|
|
2731 case CPTK_IS_FINAL:
|
|
|
2732 inform (loc, " %qT is not a final class", t1);
|
|
|
2733 break;
|
|
|
2734 case CPTK_IS_LITERAL_TYPE:
|
|
|
2735 inform (loc, " %qT is not a literal type", t1);
|
|
|
2736 break;
|
|
|
2737 case CPTK_IS_POD:
|
|
|
2738 inform (loc, " %qT is not a POD type", t1);
|
|
|
2739 break;
|
|
|
2740 case CPTK_IS_POLYMORPHIC:
|
|
|
2741 inform (loc, " %qT is not a polymorphic type", t1);
|
|
|
2742 break;
|
|
|
2743 case CPTK_IS_SAME_AS:
|
|
|
2744 inform (loc, " %qT is not the same as %qT", t1, t2);
|
|
|
2745 break;
|
|
|
2746 case CPTK_IS_STD_LAYOUT:
|
|
|
2747 inform (loc, " %qT is not an standard layout type", t1);
|
|
|
2748 break;
|
|
|
2749 case CPTK_IS_TRIVIAL:
|
|
|
2750 inform (loc, " %qT is not a trivial type", t1);
|
|
|
2751 break;
|
|
|
2752 case CPTK_IS_UNION:
|
|
|
2753 inform (loc, " %qT is not a union", t1);
|
|
|
2754 break;
|
|
|
2755 default:
|
|
|
2756 gcc_unreachable ();
|
|
|
2757 }
|
|
|
2758 }
|
|
|
2759
|
|
|
2760 /* Diagnose the expression of a predicate constraint. */
|
|
|
2761
|
|
|
2762 void
|
|
|
2763 diagnose_other_expression (location_t loc, tree, tree cur, tree args)
|
|
|
2764 {
|
|
|
2765 if (constraint_expression_satisfied_p (cur, args))
|
|
|
2766 return;
|
|
|
2767 if (elide_constraint_failure_p())
|
|
|
2768 return;
|
|
|
2769 inform (loc, "%qE evaluated to false", cur);
|
|
|
2770 }
|
|
|
2771
|
|
|
2772 /* Do our best to infer meaning from predicates. */
|
|
|
2773
|
|
|
2774 inline void
|
|
|
2775 diagnose_predicate_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2776 {
|
|
|
2777 if (TREE_CODE (PRED_CONSTR_EXPR (cur)) == TRAIT_EXPR)
|
|
|
2778 diagnose_trait_expression (loc, orig, cur, args);
|
|
|
2779 else
|
|
|
2780 diagnose_other_expression (loc, orig, cur, args);
|
|
|
2781 }
|
|
|
2782
|
|
|
2783 /* Diagnose a failed pack expansion, possibly containing constraints. */
|
|
|
2784
|
|
|
2785 void
|
|
|
2786 diagnose_pack_expansion (location_t loc, tree, tree cur, tree args)
|
|
|
2787 {
|
|
|
2788 if (constraint_expression_satisfied_p (cur, args))
|
|
|
2789 return;
|
|
|
2790 if (elide_constraint_failure_p())
|
|
|
2791 return;
|
|
|
2792
|
|
|
2793 /* Make sure that we don't have naked packs that we don't expect. */
|
|
|
2794 if (!same_type_p (TREE_TYPE (cur), boolean_type_node))
|
|
|
2795 {
|
|
|
2796 inform (loc, "invalid pack expansion in constraint %qE", cur);
|
|
|
2797 return;
|
|
|
2798 }
|
|
|
2799
|
|
|
2800 inform (loc, "in the expansion of %qE", cur);
|
|
|
2801
|
|
|
2802 /* Get the vector of expanded arguments. Note that n must not
|
|
|
2803 be 0 since this constraint is not satisfied. */
|
|
|
2804 ++processing_template_decl;
|
|
|
2805 tree exprs = tsubst_pack_expansion (cur, args, tf_none, NULL_TREE);
|
|
|
2806 --processing_template_decl;
|
|
|
2807 if (exprs == error_mark_node)
|
|
|
2808 {
|
|
|
2809 /* TODO: This error message could be better. */
|
|
|
2810 inform (loc, " substitution failure occurred during expansion");
|
|
|
2811 return;
|
|
|
2812 }
|
|
|
2813
|
|
|
2814 /* Check each expanded constraint separately. */
|
|
|
2815 int n = TREE_VEC_LENGTH (exprs);
|
|
|
2816 for (int i = 0; i < n; ++i)
|
|
|
2817 {
|
|
|
2818 tree expr = TREE_VEC_ELT (exprs, i);
|
|
|
2819 if (!constraint_expression_satisfied_p (expr, args))
|
|
|
2820 inform (loc, " %qE was not satisfied", expr);
|
|
|
2821 }
|
|
|
2822 }
|
|
|
2823
|
|
|
2824 /* Diagnose a potentially unsatisfied concept check constraint DECL<CARGS>.
|
|
|
2825 Parameters are as for diagnose_constraint. */
|
|
|
2826
|
|
|
2827 void
|
|
|
2828 diagnose_check_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2829 {
|
|
|
2830 if (constraints_satisfied_p (cur, args))
|
|
|
2831 return;
|
|
|
2832
|
|
|
2833 tree decl = CHECK_CONSTR_CONCEPT (cur);
|
|
|
2834 tree cargs = CHECK_CONSTR_ARGS (cur);
|
|
|
2835 tree tmpl = DECL_TI_TEMPLATE (decl);
|
|
|
2836 tree check = build_nt (CHECK_CONSTR, decl, cargs);
|
|
|
2837
|
|
|
2838 /* Instantiate the concept check arguments. */
|
|
|
2839 tree targs = tsubst (cargs, args, tf_none, NULL_TREE);
|
|
|
2840 if (targs == error_mark_node)
|
|
|
2841 {
|
|
|
2842 if (elide_constraint_failure_p ())
|
|
|
2843 return;
|
|
|
2844 inform (loc, "invalid use of the concept %qE", check);
|
|
|
2845 tsubst (cargs, args, tf_warning_or_error, NULL_TREE);
|
|
|
2846 return;
|
|
|
2847 }
|
|
|
2848
|
|
|
2849 tree sub = build_tree_list (tmpl, targs);
|
|
|
2850 /* Update to the expanded definitions. */
|
|
|
2851 cur = expand_concept (decl, targs);
|
|
|
2852 if (cur == error_mark_node)
|
|
|
2853 {
|
|
|
2854 if (elide_constraint_failure_p ())
|
|
|
2855 return;
|
|
|
2856 inform (loc, "in the expansion of concept %<%E %S%>", check, sub);
|
|
|
2857 cur = get_concept_definition (decl);
|
|
|
2858 tsubst_expr (cur, targs, tf_warning_or_error, NULL_TREE, false);
|
|
|
2859 return;
|
|
|
2860 }
|
|
|
2861
|
|
|
2862 orig = get_concept_definition (CHECK_CONSTR_CONCEPT (orig));
|
|
|
2863 orig = normalize_expression (orig);
|
|
|
2864
|
|
|
2865 location_t dloc = DECL_SOURCE_LOCATION (decl);
|
|
|
2866 inform (dloc, "within %qS", sub);
|
|
|
2867 diagnose_constraint (dloc, orig, cur, targs);
|
|
|
2868 }
|
|
|
2869
|
|
|
2870 /* Diagnose a potentially unsatisfied conjunction or disjunction. Parameters
|
|
|
2871 are as for diagnose_constraint. */
|
|
|
2872
|
|
|
2873 void
|
|
|
2874 diagnose_logical_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2875 {
|
|
|
2876 tree t0 = TREE_OPERAND (cur, 0);
|
|
|
2877 tree t1 = TREE_OPERAND (cur, 1);
|
|
|
2878 if (!constraints_satisfied_p (t0, args))
|
|
|
2879 diagnose_constraint (loc, TREE_OPERAND (orig, 0), t0, args);
|
|
|
2880 else if (TREE_CODE (orig) == TRUTH_ORIF_EXPR)
|
|
|
2881 return;
|
|
|
2882 if (!constraints_satisfied_p (t1, args))
|
|
|
2883 diagnose_constraint (loc, TREE_OPERAND (orig, 1), t1, args);
|
|
|
2884 }
|
|
|
2885
|
|
|
2886 /* Diagnose a potential expression constraint failure. */
|
|
|
2887
|
|
|
2888 void
|
|
|
2889 diagnose_expression_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2890 {
|
|
|
2891 if (constraints_satisfied_p (cur, args))
|
|
|
2892 return;
|
|
|
2893 if (elide_constraint_failure_p())
|
|
|
2894 return;
|
|
|
2895
|
|
|
2896 tree expr = EXPR_CONSTR_EXPR (orig);
|
|
|
2897 inform (loc, "the required expression %qE would be ill-formed", expr);
|
|
|
2898
|
|
|
2899 // TODO: We should have a flag that controls this substitution.
|
|
|
2900 // I'm finding it very useful for resolving concept check errors.
|
|
|
2901
|
|
|
2902 // inform (input_location, "==== BEGIN DUMP ====");
|
|
|
2903 // tsubst_expr (EXPR_CONSTR_EXPR (orig), args, tf_warning_or_error, NULL_TREE, false);
|
|
|
2904 // inform (input_location, "==== END DUMP ====");
|
|
|
2905 }
|
|
|
2906
|
|
|
2907 /* Diagnose a potentially failed type constraint. */
|
|
|
2908
|
|
|
2909 void
|
|
|
2910 diagnose_type_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2911 {
|
|
|
2912 if (constraints_satisfied_p (cur, args))
|
|
|
2913 return;
|
|
|
2914 if (elide_constraint_failure_p())
|
|
|
2915 return;
|
|
|
2916
|
|
|
2917 tree type = TYPE_CONSTR_TYPE (orig);
|
|
|
2918 inform (loc, "the required type %qT would be ill-formed", type);
|
|
|
2919 }
|
|
|
2920
|
|
|
2921 /* Diagnose a potentially unsatisfied conversion constraint. */
|
|
|
2922
|
|
|
2923 void
|
|
|
2924 diagnose_implicit_conversion_constraint (location_t loc, tree orig, tree cur,
|
|
|
2925 tree args)
|
|
|
2926 {
|
|
|
2927 if (constraints_satisfied_p (cur, args))
|
|
|
2928 return;
|
|
|
2929
|
|
|
2930 /* The expression and type will previously have been substituted into,
|
|
|
2931 and therefore may already be an error. Also, we will have already
|
|
|
2932 diagnosed substitution failures into an expression since this must be
|
|
|
2933 part of a compound requirement. */
|
|
|
2934 tree expr = ICONV_CONSTR_EXPR (cur);
|
|
|
2935 if (error_operand_p (expr))
|
|
|
2936 return;
|
|
|
2937
|
|
|
2938 /* Don't elide a previously diagnosed failure. */
|
|
|
2939 if (elide_constraint_failure_p())
|
|
|
2940 return;
|
|
|
2941
|
|
|
2942 tree type = ICONV_CONSTR_TYPE (cur);
|
|
|
2943 if (error_operand_p (type))
|
|
|
2944 {
|
|
|
2945 inform (loc, "substitution into type %qT failed",
|
|
|
2946 ICONV_CONSTR_TYPE (orig));
|
|
|
2947 return;
|
|
|
2948 }
|
|
|
2949
|
|
|
2950 inform(loc, "%qE is not implicitly convertible to %qT", expr, type);
|
|
|
2951 }
|
|
|
2952
|
|
|
2953 /* Diagnose an argument deduction constraint. */
|
|
|
2954
|
|
|
2955 void
|
|
|
2956 diagnose_argument_deduction_constraint (location_t loc, tree orig, tree cur,
|
|
|
2957 tree args)
|
|
|
2958 {
|
|
|
2959 if (constraints_satisfied_p (cur, args))
|
|
|
2960 return;
|
|
|
2961
|
|
|
2962 /* The expression and type will previously have been substituted into,
|
|
|
2963 and therefore may already be an error. Also, we will have already
|
|
|
2964 diagnosed substution failures into an expression since this must be
|
|
|
2965 part of a compound requirement. */
|
|
|
2966 tree expr = DEDUCT_CONSTR_EXPR (cur);
|
|
|
2967 if (error_operand_p (expr))
|
|
|
2968 return;
|
|
|
2969
|
|
|
2970 /* Don't elide a previously diagnosed failure. */
|
|
|
2971 if (elide_constraint_failure_p ())
|
|
|
2972 return;
|
|
|
2973
|
|
|
2974 tree pattern = DEDUCT_CONSTR_PATTERN (cur);
|
|
|
2975 if (error_operand_p (pattern))
|
|
|
2976 {
|
|
|
2977 inform (loc, "substitution into type %qT failed",
|
|
|
2978 DEDUCT_CONSTR_PATTERN (orig));
|
|
|
2979 return;
|
|
|
2980 }
|
|
|
2981
|
|
|
2982 inform (loc, "unable to deduce placeholder type %qT from %qE",
|
|
|
2983 pattern, expr);
|
|
|
2984 }
|
|
|
2985
|
|
|
2986 /* Diagnose an exception constraint. */
|
|
|
2987
|
|
|
2988 void
|
|
|
2989 diagnose_exception_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
2990 {
|
|
|
2991 if (constraints_satisfied_p (cur, args))
|
|
|
2992 return;
|
|
|
2993 if (elide_constraint_failure_p ())
|
|
|
2994 return;
|
|
|
2995
|
|
|
2996 /* Rebuild a noexcept expression. */
|
|
|
2997 tree expr = EXCEPT_CONSTR_EXPR (cur);
|
|
|
2998 if (error_operand_p (expr))
|
|
|
2999 return;
|
|
|
3000
|
|
|
3001 inform (loc, "%qE evaluated to false", EXCEPT_CONSTR_EXPR (orig));
|
|
|
3002 }
|
|
|
3003
|
|
|
3004 /* Diagnose a potentially unsatisfied parameterized constraint. */
|
|
|
3005
|
|
|
3006 void
|
|
|
3007 diagnose_parameterized_constraint (location_t loc, tree orig, tree cur,
|
|
|
3008 tree args)
|
|
|
3009 {
|
|
|
3010 if (constraints_satisfied_p (cur, args))
|
|
|
3011 return;
|
|
|
3012
|
|
|
3013 local_specialization_stack stack;
|
|
|
3014 tree parms = PARM_CONSTR_PARMS (cur);
|
|
|
3015 tree vars = tsubst_constraint_variables (parms, args, tf_warning_or_error,
|
|
|
3016 NULL_TREE);
|
|
|
3017 if (vars == error_mark_node)
|
|
|
3018 {
|
|
|
3019 if (elide_constraint_failure_p ())
|
|
|
3020 return;
|
|
|
3021
|
|
|
3022 /* TODO: Check which variable failed and use orig to diagnose
|
|
|
3023 that substitution error. */
|
|
|
3024 inform (loc, "failed to instantiate constraint variables");
|
|
|
3025 return;
|
|
|
3026 }
|
|
|
3027
|
|
|
3028 /* TODO: It would be better write these in a list. */
|
|
|
3029 while (vars)
|
|
|
3030 {
|
|
|
3031 inform (loc, " with %q#D", vars);
|
|
|
3032 vars = TREE_CHAIN (vars);
|
|
|
3033 }
|
|
|
3034 orig = PARM_CONSTR_OPERAND (orig);
|
|
|
3035 cur = PARM_CONSTR_OPERAND (cur);
|
|
|
3036 return diagnose_constraint (loc, orig, cur, args);
|
|
|
3037 }
|
|
|
3038
|
|
|
3039 /* Diagnose the constraint CUR for the given ARGS. This is only ever invoked
|
|
|
3040 on the associated constraints, so we can only have conjunctions of
|
|
|
3041 predicate constraints. The ORIGinal (dependent) constructs follow
|
|
|
3042 the current constraints to enable better diagnostics. Note that ORIG
|
|
|
3043 and CUR must be the same kinds of node, except when CUR is an error. */
|
|
|
3044
|
|
|
3045 void
|
|
|
3046 diagnose_constraint (location_t loc, tree orig, tree cur, tree args)
|
|
|
3047 {
|
|
|
3048 switch (TREE_CODE (cur))
|
|
|
3049 {
|
|
|
3050 case EXPR_CONSTR:
|
|
|
3051 diagnose_expression_constraint (loc, orig, cur, args);
|
|
|
3052 break;
|
|
|
3053
|
|
|
3054 case TYPE_CONSTR:
|
|
|
3055 diagnose_type_constraint (loc, orig, cur, args);
|
|
|
3056 break;
|
|
|
3057
|
|
|
3058 case ICONV_CONSTR:
|
|
|
3059 diagnose_implicit_conversion_constraint (loc, orig, cur, args);
|
|
|
3060 break;
|
|
|
3061
|
|
|
3062 case DEDUCT_CONSTR:
|
|
|
3063 diagnose_argument_deduction_constraint (loc, orig, cur, args);
|
|
|
3064 break;
|
|
|
3065
|
|
|
3066 case EXCEPT_CONSTR:
|
|
|
3067 diagnose_exception_constraint (loc, orig, cur, args);
|
|
|
3068 break;
|
|
|
3069
|
|
|
3070 case CONJ_CONSTR:
|
|
|
3071 case DISJ_CONSTR:
|
|
|
3072 diagnose_logical_constraint (loc, orig, cur, args);
|
|
|
3073 break;
|
|
|
3074
|
|
|
3075 case PRED_CONSTR:
|
|
|
3076 diagnose_predicate_constraint (loc, orig, cur, args);
|
|
|
3077 break;
|
|
|
3078
|
|
|
3079 case PARM_CONSTR:
|
|
|
3080 diagnose_parameterized_constraint (loc, orig, cur, args);
|
|
|
3081 break;
|
|
|
3082
|
|
|
3083 case CHECK_CONSTR:
|
|
|
3084 diagnose_check_constraint (loc, orig, cur, args);
|
|
|
3085 break;
|
|
|
3086
|
|
|
3087 case EXPR_PACK_EXPANSION:
|
|
|
3088 diagnose_pack_expansion (loc, orig, cur, args);
|
|
|
3089 break;
|
|
|
3090
|
|
|
3091 case ERROR_MARK:
|
|
|
3092 /* TODO: Can we improve the diagnostic with the original? */
|
|
|
3093 inform (input_location, "ill-formed constraint");
|
|
|
3094 break;
|
|
|
3095
|
|
|
3096 default:
|
|
|
3097 gcc_unreachable ();
|
|
|
3098 break;
|
|
|
3099 }
|
|
|
3100 }
|
|
|
3101
|
|
|
3102 /* Diagnose the reason(s) why ARGS do not satisfy the constraints
|
|
|
3103 of declaration DECL. */
|
|
|
3104
|
|
|
3105 void
|
|
|
3106 diagnose_declaration_constraints (location_t loc, tree decl, tree args)
|
|
|
3107 {
|
|
|
3108 inform (loc, " constraints not satisfied");
|
|
|
3109
|
|
|
3110 /* Constraints are attached to the template. */
|
|
|
3111 if (tree ti = DECL_TEMPLATE_INFO (decl))
|
|
|
3112 {
|
|
|
3113 decl = TI_TEMPLATE (ti);
|
|
|
3114 if (!args)
|
|
|
3115 args = TI_ARGS (ti);
|
|
|
3116 }
|
|
|
3117
|
|
|
3118 /* Recursively diagnose the associated constraints. */
|
|
|
3119 tree ci = get_constraints (decl);
|
|
|
3120 tree t = CI_ASSOCIATED_CONSTRAINTS (ci);
|
|
|
3121 diagnose_constraint (loc, t, t, args);
|
|
|
3122 }
|
|
|
3123
|
|
|
3124 } // namespace
|
|
|
3125
|
|
|
3126 /* Emit diagnostics detailing the failure ARGS to satisfy the
|
|
|
3127 constraints of T. Here, T can be either a constraint
|
|
|
3128 or a declaration. */
|
|
|
3129
|
|
|
3130 void
|
|
|
3131 diagnose_constraints (location_t loc, tree t, tree args)
|
|
|
3132 {
|
|
|
3133 constraint_errors = 0;
|
|
|
3134
|
|
|
3135 if (constraint_p (t))
|
|
|
3136 diagnose_constraint (loc, t, t, args);
|
|
|
3137 else if (DECL_P (t))
|
|
|
3138 diagnose_declaration_constraints (loc, t, args);
|
|
|
3139 else
|
|
|
3140 gcc_unreachable ();
|
|
|
3141
|
|
|
3142 /* Note the number of elided failures. */
|
|
|
3143 int n = undiagnosed_constraint_failures ();
|
|
|
3144 if (n > 0)
|
|
|
3145 inform (loc, "... and %d more constraint errors not shown", n);
|
|
|
3146 }
|
