Line data Source code
1 : /* Processing rules for constraints.
2 : Copyright (C) 2013-2026 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 : static tree satisfaction_value (tree t);
50 :
51 : /* When we're parsing or substuting a constraint expression, we have slightly
52 : different expression semantics. In particular, we don't want to reduce a
53 : concept-id to a satisfaction value. */
54 :
55 202158974 : processing_constraint_expression_sentinel::
56 : processing_constraint_expression_sentinel ()
57 : {
58 202158974 : ++scope_chain->x_processing_constraint;
59 202158974 : }
60 :
61 202158974 : processing_constraint_expression_sentinel::
62 : ~processing_constraint_expression_sentinel ()
63 : {
64 202158974 : --scope_chain->x_processing_constraint;
65 202158974 : }
66 :
67 : bool
68 8552923 : processing_constraint_expression_p ()
69 : {
70 8552923 : return scope_chain->x_processing_constraint != 0;
71 : }
72 :
73 : /*---------------------------------------------------------------------------
74 : Constraint expressions
75 : ---------------------------------------------------------------------------*/
76 :
77 : /* Information provided to substitution. */
78 :
79 : struct subst_info
80 : {
81 1488501668 : subst_info (tsubst_flags_t cmp, tree in)
82 1488501668 : : complain (cmp), in_decl (in)
83 : { }
84 :
85 : /* True if we should not diagnose errors. */
86 4127044186 : bool quiet () const
87 : {
88 4127044186 : return !(complain & tf_warning_or_error);
89 : }
90 :
91 : /* True if we should diagnose errors. */
92 3142412662 : bool noisy () const
93 : {
94 3176699657 : return !quiet ();
95 : }
96 :
97 : tsubst_flags_t complain;
98 : tree in_decl;
99 : };
100 :
101 : /* Provides additional context for satisfaction.
102 :
103 : During satisfaction:
104 : - The flag noisy() controls whether to diagnose ill-formed satisfaction,
105 : such as the satisfaction value of an atom being non-bool or non-constant.
106 : - The flag diagnose_unsatisfaction_p() controls whether to additionally
107 : explain why a constraint is not satisfied.
108 : - We enter satisfaction with noisy+unsat from diagnose_constraints.
109 : - We enter satisfaction with noisy-unsat from the replay inside
110 : constraint_satisfaction_value.
111 : - We enter satisfaction quietly (both flags cleared) from
112 : constraints_satisfied_p.
113 :
114 : During evaluation of a requires-expression:
115 : - The flag noisy() controls whether to diagnose ill-formed types and
116 : expressions inside its requirements.
117 : - The flag diagnose_unsatisfaction_p() controls whether to additionally
118 : explain why the requires-expression evaluates to false.
119 : - We enter tsubst_requires_expr with noisy+unsat from
120 : diagnose_atomic_constraint and potentially from
121 : satisfy_nondeclaration_constraints.
122 : - We enter tsubst_requires_expr with noisy-unsat from
123 : cp_parser_requires_expression when processing a requires-expression that
124 : appears outside a template.
125 : - We enter tsubst_requires_expr quietly (both flags cleared) when
126 : substituting through a requires-expression as part of template
127 : instantiation. */
128 :
129 : struct sat_info : subst_info
130 : {
131 1376030967 : sat_info (tsubst_flags_t cmp, tree in, bool diag_unsat = false)
132 1376030967 : : subst_info (cmp, in), diagnose_unsatisfaction (diag_unsat)
133 : {
134 1376030967 : if (diagnose_unsatisfaction_p ())
135 0 : gcc_checking_assert (noisy ());
136 15924295 : }
137 :
138 : /* True if we should diagnose the cause of satisfaction failure.
139 : Implies noisy(). */
140 : bool
141 1387216570 : diagnose_unsatisfaction_p () const
142 : {
143 15924295 : return diagnose_unsatisfaction;
144 : }
145 :
146 : bool diagnose_unsatisfaction;
147 : };
148 :
149 : static tree constraint_satisfaction_value (tree, tree, sat_info);
150 :
151 : /* True if T is known to be some type other than bool. Note that this
152 : is false for dependent types and errors. */
153 :
154 : static inline bool
155 28944130 : known_non_bool_p (tree t)
156 : {
157 28944130 : return (t && !WILDCARD_TYPE_P (t) && TREE_CODE (t) != BOOLEAN_TYPE);
158 : }
159 :
160 : static bool
161 28944130 : check_constraint_atom (cp_expr expr)
162 : {
163 28944130 : if (known_non_bool_p (TREE_TYPE (expr)))
164 : {
165 10 : error_at (expr.get_location (),
166 : "constraint expression does not have type %<bool%>");
167 10 : return false;
168 : }
169 :
170 : return true;
171 : }
172 :
173 : static bool
174 8549365 : check_constraint_operands (location_t, cp_expr lhs, cp_expr rhs)
175 : {
176 8549365 : return check_constraint_atom (lhs) && check_constraint_atom (rhs);
177 : }
178 :
179 : /* Validate the semantic properties of the constraint expression. */
180 :
181 : static cp_expr
182 8549371 : finish_constraint_binary_op (location_t loc,
183 : tree_code code,
184 : cp_expr lhs,
185 : cp_expr rhs)
186 : {
187 8549371 : gcc_assert (processing_constraint_expression_p ());
188 8549371 : if (lhs == error_mark_node || rhs == error_mark_node)
189 6 : return error_mark_node;
190 8549365 : if (!check_constraint_operands (loc, lhs, rhs))
191 0 : return error_mark_node;
192 8549365 : cp_expr expr
193 8549365 : = build_min_nt_loc (loc, code, lhs.get_value (), rhs.get_value ());
194 8549365 : expr.set_range (lhs.get_start (), rhs.get_finish ());
195 8549365 : return expr;
196 : }
197 :
198 : cp_expr
199 433251 : finish_constraint_or_expr (location_t loc, cp_expr lhs, cp_expr rhs)
200 : {
201 433251 : return finish_constraint_binary_op (loc, TRUTH_ORIF_EXPR, lhs, rhs);
202 : }
203 :
204 : cp_expr
205 8116120 : finish_constraint_and_expr (location_t loc, cp_expr lhs, cp_expr rhs)
206 : {
207 8116120 : return finish_constraint_binary_op (loc, TRUTH_ANDIF_EXPR, lhs, rhs);
208 : }
209 :
210 : cp_expr
211 11845430 : finish_constraint_primary_expr (cp_expr expr)
212 : {
213 11845430 : if (expr == error_mark_node)
214 30 : return error_mark_node;
215 11845400 : if (!check_constraint_atom (expr))
216 10 : return cp_expr (error_mark_node, expr.get_location ());
217 11845390 : return expr;
218 : }
219 :
220 : /* Combine two constraint-expressions with a logical-and. */
221 :
222 : tree
223 186425143 : combine_constraint_expressions (tree lhs, tree rhs)
224 : {
225 186425143 : processing_constraint_expression_sentinel pce;
226 186425143 : if (!lhs)
227 : return rhs;
228 25324808 : if (!rhs)
229 : return lhs;
230 : /* Use UNKNOWN_LOCATION so write_template_args can tell the difference
231 : between this and a && the user wrote. */
232 5207207 : return finish_constraint_and_expr (UNKNOWN_LOCATION, lhs, rhs);
233 186425143 : }
234 :
235 : /* Extract the TEMPLATE_DECL from a concept check. */
236 :
237 : tree
238 24558978 : get_concept_check_template (tree t)
239 : {
240 24558978 : gcc_assert (concept_check_p (t));
241 24558978 : return TREE_OPERAND (t, 0);
242 : }
243 :
244 : /*---------------------------------------------------------------------------
245 : Expansion of concept definitions
246 : ---------------------------------------------------------------------------*/
247 :
248 : /* Returns the definition of a concept. */
249 :
250 : static tree
251 20934093 : get_concept_definition (tree decl)
252 : {
253 20934093 : gcc_assert (TREE_CODE (decl) == CONCEPT_DECL);
254 20934093 : return DECL_INITIAL (decl);
255 : }
256 :
257 : /*---------------------------------------------------------------------------
258 : Normalization of expressions
259 :
260 : This set of functions will transform an expression into a constraint
261 : in a sequence of steps.
262 : ---------------------------------------------------------------------------*/
263 :
264 : void
265 0 : debug_parameter_mapping (tree map)
266 : {
267 0 : for (tree p = map; p; p = TREE_CHAIN (p))
268 : {
269 0 : tree parm = TREE_VALUE (p);
270 0 : tree arg = TREE_PURPOSE (p);
271 0 : if (TYPE_P (parm))
272 0 : verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm), arg);
273 : else
274 0 : verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm), arg);
275 : // debug_tree (parm);
276 : // debug_tree (arg);
277 : }
278 0 : }
279 :
280 : void
281 0 : debug_argument_list (tree args)
282 : {
283 0 : for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
284 : {
285 0 : tree arg = TREE_VEC_ELT (args, i);
286 0 : if (TYPE_P (arg))
287 0 : verbatim ("argument %qT", arg);
288 : else
289 0 : verbatim ("argument %qE", arg);
290 : }
291 0 : }
292 :
293 : /* Associate each parameter in PARMS with its corresponding template
294 : argument in ARGS. */
295 :
296 : static tree
297 23476326 : map_arguments (tree parms, tree args)
298 : {
299 64523639 : for (tree p = parms; p; p = TREE_CHAIN (p))
300 41047313 : if (args)
301 : {
302 35225430 : int level;
303 35225430 : int index;
304 35225430 : template_parm_level_and_index (TREE_VALUE (p), &level, &index);
305 35225430 : TREE_PURPOSE (p) = TMPL_ARG (args, level, index);
306 : }
307 : else
308 5821883 : TREE_PURPOSE (p) = template_parm_to_arg (p);
309 :
310 23476326 : return parms;
311 : }
312 :
313 : /* Build the parameter mapping for EXPR using ARGS, where CTX_PARMS
314 : are the template parameters in scope for EXPR. */
315 :
316 : static tree
317 23476326 : build_parameter_mapping (tree expr, tree args, tree ctx_parms)
318 : {
319 23476326 : tree parms = find_template_parameters (expr, ctx_parms);
320 23476326 : tree map = map_arguments (parms, args);
321 23476326 : return map;
322 : }
323 :
324 : /* True if the parameter mappings of two atomic constraints formed
325 : from the same expression are equivalent. */
326 :
327 : static bool
328 84833478 : parameter_mapping_equivalent_p (tree t1, tree t2)
329 : {
330 84833478 : tree map1 = ATOMIC_CONSTR_MAP (t1);
331 84833478 : tree map2 = ATOMIC_CONSTR_MAP (t2);
332 196930863 : while (map1 && map2)
333 : {
334 136982082 : gcc_checking_assert (TREE_VALUE (map1) == TREE_VALUE (map2));
335 136982082 : tree arg1 = TREE_PURPOSE (map1);
336 136982082 : tree arg2 = TREE_PURPOSE (map2);
337 136982082 : if (!template_args_equal (arg1, arg2))
338 : return false;
339 112097385 : map1 = TREE_CHAIN (map1);
340 112097385 : map2 = TREE_CHAIN (map2);
341 : }
342 59948781 : gcc_checking_assert (!map1 && !map2);
343 : return true;
344 : }
345 :
346 : /* Provides additional context for normalization. */
347 :
348 : struct norm_info : subst_info
349 : {
350 12072283 : explicit norm_info (bool diag)
351 12072283 : : norm_info (NULL_TREE, diag)
352 : {}
353 :
354 : /* Construct a top-level context for DECL. */
355 :
356 15676732 : norm_info (tree in_decl, bool diag)
357 15676732 : : subst_info (tf_warning_or_error|tf_partial, in_decl),
358 15676732 : generate_diagnostics (diag)
359 : {
360 3604449 : if (in_decl)
361 : {
362 2956191 : initial_parms = DECL_TEMPLATE_PARMS (in_decl);
363 2956191 : if (generate_diagnostics)
364 1277 : context = build_tree_list (NULL_TREE, in_decl);
365 : }
366 : else
367 648258 : initial_parms = current_template_parms;
368 3604449 : }
369 :
370 20603694 : void update_context (tree expr, tree args)
371 : {
372 20603694 : if (generate_diagnostics)
373 : {
374 3406 : tree map = build_parameter_mapping (expr, args, ctx_parms ());
375 3406 : context = tree_cons (map, expr, context);
376 : }
377 20603694 : in_decl = get_concept_check_template (expr);
378 20603694 : }
379 :
380 : /* Returns the template parameters that are in scope for the current
381 : normalization context. */
382 :
383 23476326 : tree ctx_parms ()
384 : {
385 23476326 : if (in_decl)
386 23034512 : return DECL_TEMPLATE_PARMS (in_decl);
387 : else
388 441814 : return initial_parms;
389 : }
390 :
391 : /* Provides information about the source of a constraint. This is a
392 : TREE_LIST whose VALUE is either a concept check or a constrained
393 : declaration. The PURPOSE, for concept checks is a parameter mapping
394 : for that check. */
395 :
396 : tree context = NULL_TREE;
397 :
398 : /* The declaration whose constraints we're normalizing. The targets
399 : of the parameter mapping of each atom will be in terms of the
400 : template parameters of ORIG_DECL. */
401 :
402 : tree initial_parms = NULL_TREE;
403 :
404 : /* Whether to build diagnostic information during normalization. */
405 :
406 : bool generate_diagnostics;
407 : };
408 :
409 : static tree normalize_expression (tree, tree, norm_info);
410 :
411 : /* Transform a logical-or or logical-and expression into either
412 : a conjunction or disjunction. */
413 :
414 : static tree
415 23610607 : normalize_logical_operation (tree t, tree args, tree_code c, norm_info info)
416 : {
417 23610607 : tree t0 = normalize_expression (TREE_OPERAND (t, 0), args, info);
418 23610607 : tree t1 = normalize_expression (TREE_OPERAND (t, 1), args, info);
419 :
420 : /* Build a new info object for the constraint. */
421 23610607 : tree ci = (info.generate_diagnostics
422 23610607 : ? build_tree_list (t, info.context) : NULL_TREE);
423 :
424 23610607 : return build2 (c, ci, t0, t1);
425 : }
426 :
427 : /* Data types and hash functions for caching the normal form of a concept-id.
428 : This essentially memoizes calls to normalize_concept_check. */
429 :
430 : struct GTY((for_user)) norm_entry
431 : {
432 : /* The CONCEPT_DECL of the concept-id. */
433 : tree tmpl;
434 : /* The arguments of the concept-id. */
435 : tree args;
436 : /* The normal form of the concept-id. */
437 : tree norm;
438 : };
439 :
440 : struct norm_hasher : ggc_ptr_hash<norm_entry>
441 : {
442 184308291 : static hashval_t hash (norm_entry *e)
443 : {
444 184308291 : ++comparing_specializations;
445 184308291 : hashval_t val = iterative_hash_template_arg (e->tmpl, 0);
446 184308291 : val = iterative_hash_template_arg (e->args, val);
447 184308291 : --comparing_specializations;
448 184308291 : return val;
449 : }
450 :
451 207646157 : static bool equal (norm_entry *e1, norm_entry *e2)
452 : {
453 207646157 : ++comparing_specializations;
454 207646157 : bool eq = e1->tmpl == e2->tmpl
455 207646157 : && template_args_equal (e1->args, e2->args);
456 207646157 : --comparing_specializations;
457 207646157 : return eq;
458 : }
459 : };
460 :
461 : static GTY((deletable)) hash_table<norm_hasher> *norm_cache;
462 :
463 : /* Normalize the concept check CHECK where ARGS are the
464 : arguments to be substituted into CHECK's arguments. */
465 :
466 : static tree
467 25967419 : normalize_concept_check (tree check, tree args, norm_info info)
468 : {
469 25967419 : gcc_assert (concept_check_p (check));
470 25967419 : tree tmpl = TREE_OPERAND (check, 0);
471 25967419 : tree targs = TREE_OPERAND (check, 1);
472 :
473 : /* Substitute through the arguments of the concept check. */
474 25967419 : if (args)
475 18876657 : targs = tsubst_template_args (targs, args, info.complain, info.in_decl);
476 25967419 : if (targs == error_mark_node)
477 : return error_mark_node;
478 25967419 : if (template_args_equal (targs, generic_targs_for (tmpl)))
479 : /* Canonicalize generic arguments as NULL_TREE, as an optimization. */
480 3360662 : targs = NULL_TREE;
481 :
482 : /* Build the substitution for the concept definition. */
483 25967419 : tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
484 25967419 : if (targs && args)
485 : /* As an optimization, coerce the arguments only if necessary
486 : (i.e. if they were substituted). */
487 18490577 : targs = coerce_template_parms (parms, targs, tmpl, tf_none);
488 25967419 : if (targs == error_mark_node)
489 : return error_mark_node;
490 :
491 25967419 : if (!norm_cache)
492 78298 : norm_cache = hash_table<norm_hasher>::create_ggc (31);
493 25967419 : norm_entry *entry = nullptr;
494 25967419 : if (!info.generate_diagnostics)
495 : {
496 : /* Cache the normal form of the substituted concept-id (when not
497 : diagnosing). */
498 25964013 : norm_entry elt = {tmpl, targs, NULL_TREE};
499 25964013 : norm_entry **slot = norm_cache->find_slot (&elt, INSERT);
500 25964013 : if (*slot)
501 5363725 : return (*slot)->norm;
502 20600288 : entry = ggc_alloc<norm_entry> ();
503 20600288 : *entry = elt;
504 20600288 : *slot = entry;
505 : }
506 :
507 20603694 : tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
508 20603694 : info.update_context (check, args);
509 20603694 : tree norm = normalize_expression (def, targs, info);
510 20603694 : if (entry)
511 20600288 : entry->norm = norm;
512 : return norm;
513 : }
514 :
515 : /* A structural hasher for ATOMIC_CONSTRs. */
516 :
517 : struct atom_hasher : default_hash_traits<tree>
518 : {
519 177904833 : static hashval_t hash (tree t)
520 : {
521 177904833 : ++comparing_specializations;
522 177904833 : hashval_t val = hash_atomic_constraint (t);
523 177904833 : --comparing_specializations;
524 177904833 : return val;
525 : }
526 :
527 160372795 : static bool equal (tree t1, tree t2)
528 : {
529 160372795 : ++comparing_specializations;
530 160372795 : bool eq = atomic_constraints_identical_p (t1, t2);
531 160372795 : --comparing_specializations;
532 160372795 : return eq;
533 : }
534 : };
535 :
536 : /* Used by normalize_atom to cache ATOMIC_CONSTRs. */
537 :
538 : static GTY((deletable)) hash_table<atom_hasher> *atom_cache;
539 :
540 : /* The normal form of an atom is an atomic constraint. */
541 :
542 : static tree
543 49440339 : normalize_atom (tree t, tree args, norm_info info)
544 : {
545 : /* Concept checks are not atomic. */
546 49440339 : if (concept_check_p (t))
547 25967419 : return normalize_concept_check (t, args, info);
548 :
549 : /* Build the parameter mapping for the atom. */
550 23472920 : tree map = build_parameter_mapping (t, args, info.ctx_parms ());
551 :
552 : /* Build a new info object for the atom. */
553 23472920 : tree ci = build_tree_list (t, info.context);
554 :
555 23472920 : tree atom = build1 (ATOMIC_CONSTR, ci, map);
556 :
557 : /* Remember whether the expression of this atomic constraint belongs to
558 : a concept definition by inspecting in_decl, which should always be set
559 : in this case either by norm_info::update_context (when recursing into a
560 : concept-id during normalization) or by normalize_concept_definition
561 : (when starting out with a concept-id). */
562 46504157 : if (info.in_decl && concept_definition_p (info.in_decl))
563 20936250 : ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom) = true;
564 :
565 23472920 : if (!info.generate_diagnostics)
566 : {
567 : /* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
568 : later can cheaply compare two atoms using just pointer equality. */
569 23468501 : if (!atom_cache)
570 86604 : atom_cache = hash_table<atom_hasher>::create_ggc (31);
571 23468501 : tree *slot = atom_cache->find_slot (atom, INSERT);
572 23468501 : if (*slot)
573 : return *slot;
574 :
575 : /* Find all template parameters used in the targets of the parameter
576 : mapping, and store a list of them in the TREE_TYPE of the mapping.
577 : This list will be used by sat_hasher to determine the subset of
578 : supplied template arguments that the satisfaction value of the atom
579 : depends on. */
580 22851984 : if (map)
581 : {
582 22851306 : tree targets = make_tree_vec (list_length (map));
583 22851306 : int i = 0;
584 63219433 : for (tree node = map; node; node = TREE_CHAIN (node))
585 : {
586 40368127 : tree target = TREE_PURPOSE (node);
587 40368127 : TREE_VEC_ELT (targets, i++) = target;
588 : }
589 22851306 : tree target_parms = find_template_parameters (targets,
590 : info.initial_parms);
591 22851306 : TREE_TYPE (map) = target_parms;
592 : }
593 :
594 22851984 : *slot = atom;
595 : }
596 : return atom;
597 : }
598 :
599 : /* Returns the normal form of an expression. */
600 :
601 : static tree
602 73051061 : normalize_expression (tree t, tree args, norm_info info)
603 : {
604 73051061 : if (!t)
605 : return NULL_TREE;
606 :
607 73051061 : if (t == error_mark_node)
608 : return error_mark_node;
609 :
610 73050946 : switch (TREE_CODE (t))
611 : {
612 22858492 : case TRUTH_ANDIF_EXPR:
613 22858492 : return normalize_logical_operation (t, args, CONJ_CONSTR, info);
614 752115 : case TRUTH_ORIF_EXPR:
615 752115 : return normalize_logical_operation (t, args, DISJ_CONSTR, info);
616 49440339 : default:
617 49440339 : return normalize_atom (t, args, info);
618 : }
619 : }
620 :
621 : /* Cache of the normalized form of constraints. Marked as deletable because it
622 : can all be recalculated. */
623 : static GTY((deletable)) hash_map<tree,tree> *normalized_map;
624 :
625 : static tree
626 5226153 : get_normalized_constraints (tree t, norm_info info)
627 : {
628 5226153 : auto_timevar time (TV_CONSTRAINT_NORM);
629 5226153 : return normalize_expression (t, NULL_TREE, info);
630 5226153 : }
631 :
632 : /* Returns the normalized constraints from a constraint-info object
633 : or NULL_TREE if the constraints are null. IN_DECL provides the
634 : declaration to which the constraints belong. */
635 :
636 : static tree
637 3274058 : get_normalized_constraints_from_info (tree ci, tree in_decl, bool diag = false)
638 : {
639 3274058 : if (ci == NULL_TREE)
640 : return NULL_TREE;
641 :
642 : /* Substitution errors during normalization are fatal. */
643 3274050 : ++processing_template_decl;
644 3274050 : norm_info info (in_decl, diag);
645 6548100 : tree t = get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci), info);
646 3274050 : --processing_template_decl;
647 :
648 3274050 : return t;
649 : }
650 :
651 : /* Returns the normalized constraints for the declaration D. */
652 :
653 : static tree
654 509293282 : get_normalized_constraints_from_decl (tree d, bool diag = false)
655 : {
656 509293282 : tree tmpl;
657 509293282 : tree decl;
658 :
659 : /* For inherited constructors, consider the original declaration;
660 : it has the correct template information attached. */
661 509293282 : d = strip_inheriting_ctors (d);
662 :
663 509293282 : if (regenerated_lambda_fn_p (d))
664 : {
665 : /* If this lambda was regenerated, DECL_TEMPLATE_PARMS doesn't contain
666 : all in-scope template parameters, but the lambda from which it was
667 : ultimately regenerated does, so use that instead. */
668 1619749 : tree lambda = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (d));
669 1619749 : lambda = most_general_lambda (lambda);
670 1619749 : d = lambda_function (lambda);
671 : }
672 :
673 509293282 : if (TREE_CODE (d) == TEMPLATE_DECL)
674 : {
675 377261216 : tmpl = d;
676 377261216 : decl = DECL_TEMPLATE_RESULT (tmpl);
677 : }
678 : else
679 : {
680 132032066 : if (tree ti = DECL_TEMPLATE_INFO (d))
681 91805165 : tmpl = TI_TEMPLATE (ti);
682 : else
683 : tmpl = NULL_TREE;
684 91805165 : decl = d;
685 : }
686 :
687 : /* Get the most general template for the declaration, and compute
688 : arguments from that. This ensures that the arguments used for
689 : normalization are always template parameters and not arguments
690 : used for outer specializations. For example:
691 :
692 : template<typename T>
693 : struct S {
694 : template<typename U> requires C<T, U> void f(U);
695 : };
696 :
697 : S<int>::f(0);
698 :
699 : When we normalize the requirements for S<int>::f, we want the
700 : arguments to be {T, U}, not {int, U}. One reason for this is that
701 : accepting the latter causes the template parameter level of U
702 : to be reduced in a way that makes it overly difficult substitute
703 : concrete arguments (i.e., eventually {int, int} during satisfaction. */
704 469066381 : if (tmpl && DECL_LANG_SPECIFIC (tmpl)
705 560871531 : && (!DECL_TEMPLATE_SPECIALIZATION (tmpl)
706 : /* DECL_TEMPLATE_SPECIALIZATION means TMPL is either a partial
707 : specialization, or an explicit specialization of a member
708 : template. In the former case all is well: TMPL's constraints
709 : are in terms of its parameters. But in the latter case TMPL's
710 : parameters are partially instantiated whereas its constraints
711 : aren't, so we need to instead use (the parameters of) the most
712 : general template. The following test distinguishes between a
713 : partial specialization and such an explicit specialization. */
714 32191248 : || (TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (tmpl))
715 16095624 : < TMPL_ARGS_DEPTH (DECL_TI_ARGS (tmpl)))))
716 452972030 : tmpl = most_general_template (tmpl);
717 :
718 509293282 : d = tmpl ? tmpl : decl;
719 :
720 : /* If we're not diagnosing errors, use cached constraints, if any. */
721 509293282 : if (!diag)
722 1018439928 : if (tree *p = hash_map_safe_get (normalized_map, d))
723 426055495 : return *p;
724 :
725 83237787 : tree norm = NULL_TREE;
726 83237787 : if (tree ci = get_constraints (d))
727 : {
728 2625705 : push_access_scope_guard pas (decl);
729 2625705 : norm = get_normalized_constraints_from_info (ci, tmpl, diag);
730 2625705 : }
731 :
732 83237787 : if (!diag)
733 83236783 : hash_map_safe_put<hm_ggc> (normalized_map, d, norm);
734 :
735 83237787 : return norm;
736 : }
737 :
738 : /* Returns the normal form of TMPL's definition. */
739 :
740 : static tree
741 3746962 : normalize_concept_definition (tree tmpl, bool diag)
742 : {
743 3746962 : if (!norm_cache)
744 1788 : norm_cache = hash_table<norm_hasher>::create_ggc (31);
745 3746962 : norm_entry entry = {tmpl, NULL_TREE, NULL_TREE};
746 :
747 3746962 : if (!diag)
748 3746689 : if (norm_entry *found = norm_cache->find (&entry))
749 3416563 : return found->norm;
750 :
751 330399 : gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
752 330399 : tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
753 330399 : ++processing_template_decl;
754 330399 : norm_info info (tmpl, diag);
755 330399 : tree norm = get_normalized_constraints (def, info);
756 330399 : --processing_template_decl;
757 :
758 330399 : if (!diag)
759 : {
760 330126 : norm_entry **slot = norm_cache->find_slot (&entry, INSERT);
761 330126 : entry.norm = norm;
762 330126 : *slot = ggc_alloc<norm_entry> ();
763 330126 : **slot = entry;
764 : }
765 :
766 : return norm;
767 : }
768 :
769 : /* Normalize an EXPR as a constraint. */
770 :
771 : static tree
772 12072283 : normalize_constraint_expression (tree expr, norm_info info)
773 : {
774 12072283 : if (!expr || expr == error_mark_node)
775 : return expr;
776 :
777 12072283 : if (!info.generate_diagnostics)
778 24144167 : if (tree *p = hash_map_safe_get (normalized_map, expr))
779 10450579 : return *p;
780 :
781 1621704 : ++processing_template_decl;
782 1621704 : tree norm = get_normalized_constraints (expr, info);
783 1621704 : --processing_template_decl;
784 :
785 1621704 : if (!info.generate_diagnostics)
786 1621552 : hash_map_safe_put<hm_ggc> (normalized_map, expr, norm);
787 :
788 : return norm;
789 : }
790 :
791 : /* 17.4.1.2p2. Two constraints are identical if they are formed
792 : from the same expression and the targets of the parameter mapping
793 : are equivalent. */
794 :
795 : bool
796 398513206 : atomic_constraints_identical_p (tree t1, tree t2)
797 : {
798 398513206 : gcc_assert (TREE_CODE (t1) == ATOMIC_CONSTR);
799 398513206 : gcc_assert (TREE_CODE (t2) == ATOMIC_CONSTR);
800 :
801 398513206 : if (ATOMIC_CONSTR_EXPR (t1) != ATOMIC_CONSTR_EXPR (t2))
802 : return false;
803 :
804 84833478 : if (!parameter_mapping_equivalent_p (t1, t2))
805 : return false;
806 :
807 : return true;
808 : }
809 :
810 : /* True if T1 and T2 are equivalent, meaning they have the same syntactic
811 : structure and all corresponding constraints are identical. */
812 :
813 : bool
814 16770576 : constraints_equivalent_p (tree t1, tree t2)
815 : {
816 16770576 : gcc_assert (CONSTR_P (t1));
817 16770576 : gcc_assert (CONSTR_P (t2));
818 :
819 16770576 : if (TREE_CODE (t1) != TREE_CODE (t2))
820 : return false;
821 :
822 16567353 : switch (TREE_CODE (t1))
823 : {
824 8326377 : case CONJ_CONSTR:
825 8326377 : case DISJ_CONSTR:
826 8326377 : if (!constraints_equivalent_p (TREE_OPERAND (t1, 0),
827 8326377 : TREE_OPERAND (t2, 0)))
828 : return false;
829 8091337 : if (!constraints_equivalent_p (TREE_OPERAND (t1, 1),
830 8091337 : TREE_OPERAND (t2, 1)))
831 : return false;
832 : break;
833 8240976 : case ATOMIC_CONSTR:
834 8240976 : if (!atomic_constraints_identical_p (t1, t2))
835 : return false;
836 : break;
837 : default:
838 : gcc_unreachable ();
839 : }
840 : return true;
841 : }
842 :
843 : /* Compute the hash value for T. */
844 :
845 : hashval_t
846 1931679356 : hash_atomic_constraint (tree t)
847 : {
848 1931679356 : gcc_assert (TREE_CODE (t) == ATOMIC_CONSTR);
849 :
850 : /* Hash the identity of the expression. */
851 1931679356 : hashval_t val = htab_hash_pointer (ATOMIC_CONSTR_EXPR (t));
852 :
853 : /* Hash the targets of the parameter map. */
854 1931679356 : tree p = ATOMIC_CONSTR_MAP (t);
855 5005151233 : while (p)
856 : {
857 3073471877 : val = iterative_hash_template_arg (TREE_PURPOSE (p), val);
858 3073471877 : p = TREE_CHAIN (p);
859 : }
860 :
861 1931679356 : return val;
862 : }
863 :
864 : namespace inchash
865 : {
866 :
867 : static void
868 76467675 : add_constraint (tree t, hash& h)
869 : {
870 152037060 : h.add_int (TREE_CODE (t));
871 152037060 : switch (TREE_CODE (t))
872 : {
873 75569385 : case CONJ_CONSTR:
874 75569385 : case DISJ_CONSTR:
875 75569385 : add_constraint (TREE_OPERAND (t, 0), h);
876 75569385 : add_constraint (TREE_OPERAND (t, 1), h);
877 75569385 : break;
878 76467675 : case ATOMIC_CONSTR:
879 76467675 : h.merge_hash (hash_atomic_constraint (t));
880 76467675 : break;
881 0 : default:
882 0 : gcc_unreachable ();
883 : }
884 76467675 : }
885 :
886 : }
887 :
888 : /* Computes a hash code for the constraint T. */
889 :
890 : hashval_t
891 898290 : iterative_hash_constraint (tree t, hashval_t val)
892 : {
893 898290 : gcc_assert (CONSTR_P (t));
894 898290 : inchash::hash h (val);
895 898290 : inchash::add_constraint (t, h);
896 898290 : return h.end ();
897 : }
898 :
899 : // -------------------------------------------------------------------------- //
900 : // Constraint Semantic Processing
901 : //
902 : // The following functions are called by the parser and substitution rules
903 : // to create and evaluate constraint-related nodes.
904 :
905 : // The constraints associated with the current template parameters.
906 : tree
907 101590613 : current_template_constraints (void)
908 : {
909 101590613 : if (!current_template_parms)
910 : return NULL_TREE;
911 101590610 : tree tmpl_constr = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
912 101590610 : return build_constraints (tmpl_constr, NULL_TREE);
913 : }
914 :
915 : /* If the recently parsed TYPE declares or defines a template or
916 : template specialization, get its corresponding constraints from the
917 : current template parameters and bind them to TYPE's declaration. */
918 :
919 : tree
920 37984623 : associate_classtype_constraints (tree type)
921 : {
922 37984623 : if (!type || type == error_mark_node || !CLASS_TYPE_P (type))
923 : return type;
924 :
925 : /* An explicit class template specialization has no template parameters. */
926 37983853 : if (!current_template_parms)
927 : return type;
928 :
929 27752832 : if (CLASSTYPE_IS_TEMPLATE (type) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type))
930 : {
931 26600939 : tree decl = TYPE_STUB_DECL (type);
932 26600939 : tree ci = current_template_constraints ();
933 :
934 : /* An implicitly instantiated member template declaration already
935 : has associated constraints. If it is defined outside of its
936 : class, then we need match these constraints against those of
937 : original declaration. */
938 26600939 : if (tree orig_ci = get_constraints (decl))
939 : {
940 1209750 : if (int extra_levels = (TMPL_PARMS_DEPTH (current_template_parms)
941 7457349 : - TMPL_ARGS_DEPTH (TYPE_TI_ARGS (type))))
942 : {
943 : /* If there is a discrepancy between the current template depth
944 : and the template depth of the original declaration, then we
945 : must be redeclaring a class template as part of a friend
946 : declaration within another class template. Before matching
947 : constraints, we need to reduce the template parameter level
948 : within the current constraints via substitution. */
949 9 : tree outer_gtargs = template_parms_to_args (current_template_parms);
950 9 : TREE_VEC_LENGTH (outer_gtargs) = extra_levels;
951 9 : ci = tsubst_constraint_info (ci, outer_gtargs, tf_none, NULL_TREE);
952 : }
953 1209750 : if (!equivalent_constraints (ci, orig_ci))
954 : {
955 6 : auto_diagnostic_group d;
956 6 : error ("%qT does not match original declaration", type);
957 6 : tree tmpl = CLASSTYPE_TI_TEMPLATE (type);
958 6 : location_t loc = DECL_SOURCE_LOCATION (tmpl);
959 6 : inform (loc, "original template declaration here");
960 : /* Fall through, so that we define the type anyway. */
961 6 : }
962 1209750 : return type;
963 : }
964 25391189 : set_constraints (decl, ci);
965 : }
966 : return type;
967 : }
968 :
969 : /* Create an empty constraint info block. */
970 :
971 : static inline tree_constraint_info*
972 20461979 : build_constraint_info ()
973 : {
974 20461979 : return (tree_constraint_info *)make_node (CONSTRAINT_INFO);
975 : }
976 :
977 : /* Build a constraint-info object that contains the associated constraints
978 : of a declaration. This also includes the declaration's template
979 : requirements (TREQS) and any trailing requirements for a function
980 : declarator (DREQS). Note that both TREQS and DREQS must be constraints.
981 :
982 : If the declaration has neither template nor declaration requirements
983 : this returns NULL_TREE, indicating an unconstrained declaration. */
984 :
985 : tree
986 299003401 : build_constraints (tree tr, tree dr)
987 : {
988 299003401 : if (!tr && !dr)
989 : return NULL_TREE;
990 :
991 20461979 : tree_constraint_info* ci = build_constraint_info ();
992 20461979 : ci->template_reqs = tr;
993 20461979 : ci->declarator_reqs = dr;
994 20461979 : ci->associated_constr = combine_constraint_expressions (tr, dr);
995 :
996 20461979 : return (tree)ci;
997 : }
998 :
999 : /* Add constraint RHS to the end of CONSTRAINT_INFO ci. */
1000 :
1001 : tree
1002 70 : append_constraint (tree ci, tree rhs)
1003 : {
1004 70 : tree tr = ci ? CI_TEMPLATE_REQS (ci) : NULL_TREE;
1005 24 : tree dr = ci ? CI_DECLARATOR_REQS (ci) : NULL_TREE;
1006 70 : dr = combine_constraint_expressions (dr, rhs);
1007 70 : if (ci)
1008 : {
1009 12 : CI_DECLARATOR_REQS (ci) = dr;
1010 12 : tree ac = combine_constraint_expressions (tr, dr);
1011 24 : CI_ASSOCIATED_CONSTRAINTS (ci) = ac;
1012 : }
1013 : else
1014 58 : ci = build_constraints (tr, dr);
1015 70 : return ci;
1016 : }
1017 :
1018 : /* A mapping from declarations to constraint information. */
1019 :
1020 : static GTY ((cache)) decl_tree_cache_map *decl_constraints;
1021 :
1022 : /* Returns the template constraints of declaration T. If T is not
1023 : constrained, return NULL_TREE. Note that T must be non-null. */
1024 :
1025 : tree
1026 1047100066 : get_constraints (const_tree t)
1027 : {
1028 1047100066 : if (!flag_concepts)
1029 : return NULL_TREE;
1030 1039251901 : if (!decl_constraints)
1031 : return NULL_TREE;
1032 :
1033 1026646705 : gcc_assert (DECL_P (t));
1034 1026646705 : if (TREE_CODE (t) == TEMPLATE_DECL)
1035 190444665 : t = DECL_TEMPLATE_RESULT (t);
1036 1026646705 : tree* found = decl_constraints->get (const_cast<tree> (t));
1037 1026646705 : if (found)
1038 111354512 : return *found;
1039 : else
1040 : return NULL_TREE;
1041 : }
1042 :
1043 : /* Associate the given constraint information CI with the declaration
1044 : T. If T is a template, then the constraints are associated with
1045 : its underlying declaration. Don't build associations if CI is
1046 : NULL_TREE. */
1047 :
1048 : void
1049 289415532 : set_constraints (tree t, tree ci)
1050 : {
1051 289415532 : if (!ci)
1052 : return;
1053 38046729 : gcc_assert (t && flag_concepts);
1054 38046729 : if (TREE_CODE (t) == TEMPLATE_DECL)
1055 138696 : t = DECL_TEMPLATE_RESULT (t);
1056 38046729 : bool found = hash_map_safe_put<hm_ggc> (decl_constraints, t, ci);
1057 38046729 : gcc_assert (!found);
1058 : }
1059 :
1060 : /* Remove the associated constraints of the declaration T. */
1061 :
1062 : void
1063 14983291 : remove_constraints (tree t)
1064 : {
1065 14983291 : gcc_checking_assert (DECL_P (t));
1066 14983291 : if (TREE_CODE (t) == TEMPLATE_DECL)
1067 177 : t = DECL_TEMPLATE_RESULT (t);
1068 :
1069 14983291 : if (decl_constraints)
1070 14366516 : decl_constraints->remove (t);
1071 14983291 : }
1072 :
1073 : /* If DECL is a friend, substitute into REQS to produce requirements suitable
1074 : for declaration matching. */
1075 :
1076 : tree
1077 204901692 : maybe_substitute_reqs_for (tree reqs, const_tree decl)
1078 : {
1079 204901692 : if (reqs == NULL_TREE)
1080 : return NULL_TREE;
1081 :
1082 16261128 : decl = STRIP_TEMPLATE (decl);
1083 16261128 : if (DECL_UNIQUE_FRIEND_P (decl) && DECL_TEMPLATE_INFO (decl))
1084 : {
1085 173790 : tree tmpl = DECL_TI_TEMPLATE (decl);
1086 173790 : tree outer_args = outer_template_args (decl);
1087 173790 : processing_template_decl_sentinel s;
1088 173790 : if (PRIMARY_TEMPLATE_P (tmpl)
1089 173790 : || uses_template_parms (outer_args))
1090 173790 : ++processing_template_decl;
1091 173790 : reqs = tsubst_constraint (reqs, outer_args,
1092 : tf_warning_or_error, NULL_TREE);
1093 173790 : }
1094 : return reqs;
1095 : }
1096 :
1097 : /* Returns the trailing requires clause of the declarator of
1098 : a template declaration T or NULL_TREE if none. */
1099 :
1100 : tree
1101 399108176 : get_trailing_function_requirements (tree t)
1102 : {
1103 399108176 : tree ci = get_constraints (t);
1104 399108176 : if (!ci)
1105 : return NULL_TREE;
1106 100453080 : return CI_DECLARATOR_REQS (ci);
1107 : }
1108 :
1109 : /* Construct a sequence of template arguments by prepending
1110 : ARG to REST. Either ARG or REST may be null. */
1111 :
1112 : static tree
1113 40703812 : build_concept_check_arguments (tree arg, tree rest)
1114 : {
1115 40703812 : gcc_assert (!rest || TREE_CODE (rest) == TREE_VEC);
1116 40703812 : tree args;
1117 40703812 : if (arg)
1118 : {
1119 30535147 : int n = rest ? TREE_VEC_LENGTH (rest) : 0;
1120 20796532 : args = make_tree_vec (n + 1);
1121 20796532 : TREE_VEC_ELT (args, 0) = arg;
1122 20796532 : if (rest)
1123 21030905 : for (int i = 0; i < n; ++i)
1124 11292290 : TREE_VEC_ELT (args, i + 1) = TREE_VEC_ELT (rest, i);
1125 9738615 : int def = rest ? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest) : 0;
1126 20796532 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, def + 1);
1127 : }
1128 : else
1129 : args = rest;
1130 40703812 : return args;
1131 : }
1132 :
1133 : /* Construct an expression that checks TMPL using ARGS. */
1134 :
1135 : tree
1136 19907280 : build_concept_check (tree tmpl, tree args, tsubst_flags_t complain)
1137 : {
1138 19907280 : return build_concept_check (tmpl, NULL_TREE, args, complain);
1139 : }
1140 :
1141 : /* Construct an expression that checks the concept given by TMPL. */
1142 :
1143 : tree
1144 40703812 : build_concept_check (tree tmpl, tree arg, tree rest, tsubst_flags_t complain)
1145 : {
1146 40703812 : if (TREE_DEPRECATED (DECL_TEMPLATE_RESULT (tmpl)))
1147 9 : warn_deprecated_use (DECL_TEMPLATE_RESULT (tmpl), NULL_TREE);
1148 :
1149 40703812 : tree parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
1150 40703812 : tree args = build_concept_check_arguments (arg, rest);
1151 40703812 : args = coerce_template_parms (parms, args, tmpl, complain);
1152 40703812 : if (args == error_mark_node)
1153 : return error_mark_node;
1154 38329198 : return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
1155 : }
1156 :
1157 : /* Build a template-id that can participate in a concept check. */
1158 :
1159 : static tree
1160 15513623 : build_concept_id (tree decl, tree args)
1161 : {
1162 0 : return build_concept_check (decl, args, tf_warning_or_error);
1163 : }
1164 :
1165 : /* Build a template-id that can participate in a concept check, preserving
1166 : the source location of the original template-id. */
1167 :
1168 : tree
1169 15513623 : build_concept_id (tree expr)
1170 : {
1171 15513623 : gcc_assert (TREE_CODE (expr) == TEMPLATE_ID_EXPR);
1172 15513623 : tree id = build_concept_id (TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
1173 15513623 : protected_set_expr_location (id, cp_expr_location (expr));
1174 15513623 : return id;
1175 : }
1176 :
1177 : /* Build as template-id with a placeholder that can be used as a
1178 : type constraint.
1179 :
1180 : Note that this will diagnose errors if the initial concept check
1181 : cannot be built. */
1182 :
1183 : tree
1184 11615995 : build_type_constraint (tree decl, tree args, tsubst_flags_t complain)
1185 : {
1186 11615995 : tree proto = template_parm_to_arg (concept_prototype_parameter (decl));
1187 11615995 : ++processing_template_decl;
1188 11615995 : tree check = build_concept_check (decl, proto, args, complain);
1189 11615995 : --processing_template_decl;
1190 11615995 : return check;
1191 : }
1192 :
1193 : /* Returns a TYPE_DECL that contains sufficient information to
1194 : build a template parameter of the same kind as PROTO and
1195 : constrained by the concept declaration CNC. Note that PROTO
1196 : is the first template parameter of CNC.
1197 :
1198 : If specified, ARGS provides additional arguments to the
1199 : constraint check. */
1200 : tree
1201 7761974 : build_constrained_parameter (tree cnc, tree proto, tree args)
1202 : {
1203 7761974 : tree name = DECL_NAME (cnc);
1204 7761974 : tree type = TREE_TYPE (proto);
1205 7761974 : tree decl = build_decl (input_location, TYPE_DECL, name, type);
1206 7761974 : CONSTRAINED_PARM_PROTOTYPE (decl) = proto;
1207 7761974 : CONSTRAINED_PARM_CONCEPT (decl) = cnc;
1208 7761974 : CONSTRAINED_PARM_EXTRA_ARGS (decl) = args;
1209 7761974 : return decl;
1210 : }
1211 :
1212 : /* Create a constraint expression for the given DECL that evaluates the
1213 : requirements specified by CONSTR, a TYPE_DECL that contains all the
1214 : information necessary to build the requirements (see finish_concept_name
1215 : for the layout of that TYPE_DECL).
1216 :
1217 : Note that the constraints are neither reduced nor decomposed. That is
1218 : done only after the requires clause has been parsed (or not). */
1219 :
1220 : tree
1221 164155359 : finish_shorthand_constraint (tree decl, tree constr, bool is_non_type)
1222 : {
1223 : /* No requirements means no constraints. */
1224 164155359 : if (!constr)
1225 : return NULL_TREE;
1226 :
1227 7762055 : if (error_operand_p (constr))
1228 : return NULL_TREE;
1229 :
1230 7762055 : tree proto, con, args;
1231 7762055 : if (is_non_type)
1232 : {
1233 : /* This function should not see constrained auto&, auto* NTTPs, and a
1234 : simple constrained auto NTTP type should by now have been replaced
1235 : by ordinary auto; see finish_constrained_parameter. */
1236 105 : gcc_checking_assert (is_auto (TREE_TYPE (decl))
1237 : && !is_constrained_auto (TREE_TYPE (decl)));
1238 105 : gcc_checking_assert (TREE_CODE (constr) == TEMPLATE_ID_EXPR);
1239 105 : tree tmpl = TREE_OPERAND (constr, 0);
1240 105 : proto = concept_prototype_parameter (tmpl);
1241 105 : con = DECL_TEMPLATE_RESULT (tmpl);
1242 105 : args = TREE_OPERAND (constr, 1);
1243 : }
1244 : else
1245 : {
1246 7761950 : proto = CONSTRAINED_PARM_PROTOTYPE (constr);
1247 7761950 : con = CONSTRAINED_PARM_CONCEPT (constr);
1248 7761950 : args = CONSTRAINED_PARM_EXTRA_ARGS (constr);
1249 : }
1250 :
1251 7762055 : bool variadic_concept_p = template_parameter_pack_p (proto);
1252 7762055 : bool declared_pack_p = template_parameter_pack_p (decl);
1253 7762055 : bool apply_to_each_p = (cxx_dialect >= cxx20) ? true : !variadic_concept_p;
1254 :
1255 : /* Get the argument and overload used for the requirement
1256 : and adjust it if we're going to expand later. */
1257 7762055 : tree arg = template_parm_to_arg (decl);
1258 7762055 : if (apply_to_each_p && declared_pack_p)
1259 17644 : arg = PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg), 0));
1260 :
1261 : /* Build the concept constraint-expression. */
1262 7762055 : tree tmpl = DECL_TI_TEMPLATE (con);
1263 7762055 : tree check;
1264 7762055 : if (is_non_type)
1265 : {
1266 105 : arg = finish_decltype_type (arg, /*id_expr=*/true, tf_warning_or_error);
1267 105 : if (ARGUMENT_PACK_P (TREE_VEC_ELT (args, 0)))
1268 4 : args = expand_template_argument_pack (args);
1269 : else
1270 101 : args = copy_template_args (args);
1271 105 : TREE_VEC_ELT (args, 0) = arg;
1272 105 : check = build_concept_check (tmpl, args, tf_warning_or_error);
1273 : }
1274 : else
1275 7761950 : check = build_concept_check (tmpl, arg, args, tf_warning_or_error);
1276 :
1277 : /* Make the check a fold-expression if needed.
1278 : Use UNKNOWN_LOCATION so write_template_args can tell the
1279 : difference between this and a fold the user wrote. */
1280 7762055 : if (apply_to_each_p && declared_pack_p)
1281 17644 : check = finish_left_unary_fold_expr (UNKNOWN_LOCATION,
1282 : check, TRUTH_ANDIF_EXPR);
1283 :
1284 : return check;
1285 : }
1286 :
1287 : /* Returns a conjunction of shorthand requirements for the template
1288 : parameter list PARMS. Note that the requirements are stored in
1289 : the TYPE of each tree node. */
1290 :
1291 : tree
1292 86510190 : get_shorthand_constraints (tree parms)
1293 : {
1294 86510190 : tree result = NULL_TREE;
1295 86510190 : parms = INNERMOST_TEMPLATE_PARMS (parms);
1296 247328542 : for (int i = 0; i < TREE_VEC_LENGTH (parms); ++i)
1297 : {
1298 160818352 : tree parm = TREE_VEC_ELT (parms, i);
1299 160818352 : tree constr = TEMPLATE_PARM_CONSTRAINTS (parm);
1300 160818352 : result = combine_constraint_expressions (result, constr);
1301 : }
1302 86510190 : return result;
1303 : }
1304 :
1305 : /* Returns true iff the placeholders C1 and C2 are equivalent. C1
1306 : and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */
1307 :
1308 : bool
1309 644149707 : equivalent_placeholder_constraints (tree c1, tree c2)
1310 : {
1311 644149707 : if (c1 && TREE_CODE (c1) == TEMPLATE_TYPE_PARM)
1312 : /* A constrained auto. */
1313 644149707 : c1 = PLACEHOLDER_TYPE_CONSTRAINTS (c1);
1314 644149707 : if (c2 && TREE_CODE (c2) == TEMPLATE_TYPE_PARM)
1315 644149707 : c2 = PLACEHOLDER_TYPE_CONSTRAINTS (c2);
1316 :
1317 644149707 : if (c1 == c2)
1318 : return true;
1319 5173897 : if (!c1 || !c2)
1320 : return false;
1321 4847312 : if (c1 == error_mark_node || c2 == error_mark_node)
1322 : /* We get here during satisfaction; when a deduction constraint
1323 : fails, substitution can produce an error_mark_node for the
1324 : placeholder constraints. */
1325 : return false;
1326 :
1327 4847312 : gcc_assert (concept_check_p (c1) && concept_check_p (c2));
1328 4847312 : tree t1 = TREE_OPERAND (c1, 0);
1329 4847312 : tree a1 = TREE_OPERAND (c1, 1);
1330 4847312 : tree t2 = TREE_OPERAND (c2, 0);
1331 4847312 : tree a2 = TREE_OPERAND (c2, 1);
1332 :
1333 4847312 : if (t1 != t2)
1334 : return false;
1335 :
1336 2606049 : int len1 = TREE_VEC_LENGTH (a1);
1337 2606049 : int len2 = TREE_VEC_LENGTH (a2);
1338 2606049 : if (len1 != len2)
1339 : return false;
1340 :
1341 : /* Skip the first argument so we don't infinitely recurse.
1342 : Also, they may differ in template parameter index. */
1343 3707276 : for (int i = 1; i < len1; ++i)
1344 1477859 : if (!template_args_equal (TREE_VEC_ELT (a1, i),
1345 1477859 : TREE_VEC_ELT (a2, i)))
1346 : return false;
1347 : return true;
1348 : }
1349 :
1350 : /* Return a hash value for the placeholder ATOMIC_CONSTR C. */
1351 :
1352 : hashval_t
1353 160410617 : iterative_hash_placeholder_constraint (tree c, hashval_t val)
1354 : {
1355 160410617 : gcc_assert (concept_check_p (c));
1356 160410617 : tree t = TREE_OPERAND (c, 0);
1357 160410617 : tree a = TREE_OPERAND (c, 1);
1358 :
1359 : /* Like hash_tmpl_and_args, but skip the first argument. */
1360 160410617 : val = iterative_hash_object (DECL_UID (t), val);
1361 :
1362 307139207 : for (int i = TREE_VEC_LENGTH (a)-1; i > 0; --i)
1363 146728590 : val = iterative_hash_template_arg (TREE_VEC_ELT (a, i), val);
1364 :
1365 160410617 : return val;
1366 : }
1367 :
1368 : /* Substitute through the expression of a simple requirement or
1369 : compound requirement. */
1370 :
1371 : static tree
1372 17324793 : tsubst_valid_expression_requirement (tree t, tree args, sat_info info)
1373 : {
1374 17324793 : tsubst_flags_t quiet = info.complain & ~tf_warning_or_error;
1375 17324793 : tree r = tsubst_expr (t, args, quiet, info.in_decl);
1376 17322093 : if (r != error_mark_node
1377 17322093 : && (processing_template_decl
1378 16542702 : || convert_to_void (r, ICV_STATEMENT, quiet) != error_mark_node))
1379 16546257 : return r;
1380 :
1381 775836 : if (info.diagnose_unsatisfaction_p ())
1382 : {
1383 195 : location_t loc = cp_expr_loc_or_input_loc (t);
1384 195 : if (diagnosing_failed_constraint::replay_errors_p ())
1385 : {
1386 10 : inform (loc, "the required expression %qE is invalid, because", t);
1387 10 : auto_diagnostic_nesting_level sentinel;
1388 10 : if (r == error_mark_node)
1389 8 : tsubst_expr (t, args, info.complain, info.in_decl);
1390 : else
1391 2 : convert_to_void (r, ICV_STATEMENT, info.complain);
1392 10 : }
1393 : else
1394 185 : inform (loc, "the required expression %qE is invalid", t);
1395 : }
1396 775641 : else if (info.noisy ())
1397 : {
1398 0 : r = tsubst_expr (t, args, info.complain, info.in_decl);
1399 0 : convert_to_void (r, ICV_STATEMENT, info.complain);
1400 : }
1401 :
1402 775836 : return error_mark_node;
1403 : }
1404 :
1405 :
1406 : /* Substitute through the simple requirement. */
1407 :
1408 : static tree
1409 5794940 : tsubst_simple_requirement (tree t, tree args, sat_info info)
1410 : {
1411 5794940 : tree t0 = TREE_OPERAND (t, 0);
1412 5794940 : tree expr = tsubst_valid_expression_requirement (t0, args, info);
1413 5792240 : if (expr == error_mark_node)
1414 : return error_mark_node;
1415 5149555 : if (processing_template_decl)
1416 267 : return finish_simple_requirement (EXPR_LOCATION (t), expr);
1417 5149288 : return boolean_true_node;
1418 : }
1419 :
1420 : /* Subroutine of tsubst_type_requirement that performs the actual substitution
1421 : and diagnosing. Also used by tsubst_compound_requirement. */
1422 :
1423 : static tree
1424 16876792 : tsubst_type_requirement_1 (tree t, tree args, sat_info info, location_t loc)
1425 : {
1426 16876792 : tsubst_flags_t quiet = info.complain & ~tf_warning_or_error;
1427 16876792 : tree r = tsubst (t, args, quiet, info.in_decl);
1428 16876792 : if (r != error_mark_node)
1429 : return r;
1430 :
1431 630327 : if (info.diagnose_unsatisfaction_p ())
1432 : {
1433 23 : if (diagnosing_failed_constraint::replay_errors_p ())
1434 : {
1435 : /* Replay the substitution error. */
1436 2 : inform (loc, "the required type %qT is invalid, because", t);
1437 2 : tsubst (t, args, info.complain, info.in_decl);
1438 : }
1439 : else
1440 21 : inform (loc, "the required type %qT is invalid", t);
1441 : }
1442 630304 : else if (info.noisy ())
1443 0 : tsubst (t, args, info.complain, info.in_decl);
1444 :
1445 630327 : return error_mark_node;
1446 : }
1447 :
1448 :
1449 : /* Substitute through the type requirement. */
1450 :
1451 : static tree
1452 5480105 : tsubst_type_requirement (tree t, tree args, sat_info info)
1453 : {
1454 5480105 : tree t0 = TREE_OPERAND (t, 0);
1455 5480105 : tree type = tsubst_type_requirement_1 (t0, args, info, EXPR_LOCATION (t));
1456 5480105 : if (type == error_mark_node)
1457 : return error_mark_node;
1458 4849778 : if (processing_template_decl)
1459 4 : return finish_type_requirement (EXPR_LOCATION (t), type);
1460 4849774 : return boolean_true_node;
1461 : }
1462 :
1463 : /* True if TYPE can be deduced from EXPR. */
1464 :
1465 : static bool
1466 11045872 : type_deducible_p (tree expr, tree type, tree placeholder, tree args,
1467 : subst_info info)
1468 : {
1469 : /* Make sure deduction is performed against ( EXPR ), so that
1470 : references are preserved in the result. */
1471 11045872 : expr = force_paren_expr_uneval (expr);
1472 :
1473 11045872 : tree deduced_type = do_auto_deduction (type, expr, placeholder,
1474 : info.complain, adc_requirement,
1475 : /*outer_targs=*/args);
1476 :
1477 11045872 : return deduced_type != error_mark_node;
1478 : }
1479 :
1480 : /* True if EXPR can not be converted to TYPE. */
1481 :
1482 : static bool
1483 5 : expression_convertible_p (tree expr, tree type, subst_info info)
1484 : {
1485 5 : tree conv =
1486 5 : perform_direct_initialization_if_possible (type, expr, false,
1487 : info.complain);
1488 5 : if (conv == error_mark_node)
1489 : return false;
1490 0 : if (conv == NULL_TREE)
1491 : {
1492 0 : if (info.complain & tf_error)
1493 : {
1494 0 : location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
1495 0 : error_at (loc, "cannot convert %qE to %qT", expr, type);
1496 : }
1497 0 : return false;
1498 : }
1499 : return true;
1500 : }
1501 :
1502 :
1503 : /* Substitute through the compound requirement. */
1504 :
1505 : static tree
1506 11529853 : tsubst_compound_requirement (tree t, tree args, sat_info info)
1507 : {
1508 11529853 : tree t0 = TREE_OPERAND (t, 0);
1509 11529853 : tree t1 = TREE_OPERAND (t, 1);
1510 11529853 : tree expr = tsubst_valid_expression_requirement (t0, args, info);
1511 11529853 : if (expr == error_mark_node)
1512 : return error_mark_node;
1513 :
1514 11396702 : location_t loc = cp_expr_loc_or_input_loc (expr);
1515 :
1516 11396702 : subst_info quiet (info.complain & ~tf_warning_or_error, info.in_decl);
1517 :
1518 : /* Check the noexcept condition. */
1519 11396702 : bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t);
1520 347512 : if (noexcept_p && !processing_template_decl
1521 11744211 : && !expr_noexcept_p (expr, quiet.complain))
1522 : {
1523 20 : if (info.diagnose_unsatisfaction_p ())
1524 5 : inform (loc, "%qE is not %<noexcept%>", expr);
1525 : else
1526 15 : return error_mark_node;
1527 : }
1528 :
1529 : /* Substitute through the type expression, if any. */
1530 11396687 : tree type = tsubst_type_requirement_1 (t1, args, info, EXPR_LOCATION (t));
1531 11396687 : if (type == error_mark_node)
1532 : return error_mark_node;
1533 :
1534 : /* Check expression against the result type. */
1535 11396687 : if (type && !processing_template_decl)
1536 : {
1537 11045865 : if (tree placeholder = type_uses_auto (type))
1538 : {
1539 11045860 : if (!type_deducible_p (expr, type, placeholder, args, quiet))
1540 : {
1541 21473 : if (info.diagnose_unsatisfaction_p ())
1542 : {
1543 40 : if (diagnosing_failed_constraint::replay_errors_p ())
1544 : {
1545 12 : inform (loc,
1546 : "%qE does not satisfy return-type-requirement, "
1547 : "because", t0);
1548 : /* Further explain the reason for the error. */
1549 12 : type_deducible_p (expr, type, placeholder, args, info);
1550 : }
1551 : else
1552 28 : inform (loc,
1553 : "%qE does not satisfy return-type-requirement", t0);
1554 : }
1555 21473 : return error_mark_node;
1556 : }
1557 : }
1558 5 : else if (!expression_convertible_p (expr, type, quiet))
1559 : {
1560 5 : if (info.diagnose_unsatisfaction_p ())
1561 : {
1562 0 : if (diagnosing_failed_constraint::replay_errors_p ())
1563 : {
1564 0 : inform (loc, "cannot convert %qE to %qT because", t0, type);
1565 : /* Further explain the reason for the error. */
1566 0 : expression_convertible_p (expr, type, info);
1567 : }
1568 : else
1569 0 : inform (loc, "cannot convert %qE to %qT", t0, type);
1570 : }
1571 5 : return error_mark_node;
1572 : }
1573 : }
1574 :
1575 11375209 : if (processing_template_decl)
1576 3302 : return finish_compound_requirement (EXPR_LOCATION (t),
1577 3302 : expr, type, noexcept_p);
1578 11371907 : return boolean_true_node;
1579 : }
1580 :
1581 : /* Substitute through the nested requirement. */
1582 :
1583 : static tree
1584 1025931 : tsubst_nested_requirement (tree t, tree args, sat_info info)
1585 : {
1586 1025931 : if (processing_template_decl)
1587 : {
1588 0 : tree req = TREE_OPERAND (t, 0);
1589 0 : req = tsubst_constraint (req, args, info.complain, info.in_decl);
1590 0 : if (req == error_mark_node)
1591 : return error_mark_node;
1592 0 : return finish_nested_requirement (EXPR_LOCATION (t), req);
1593 : }
1594 :
1595 1025931 : sat_info quiet (info.complain & ~tf_warning_or_error, info.in_decl);
1596 1025931 : tree result = constraint_satisfaction_value (t, args, quiet);
1597 1025931 : if (result == boolean_true_node)
1598 : return boolean_true_node;
1599 :
1600 38996 : if (result == boolean_false_node
1601 38996 : && info.diagnose_unsatisfaction_p ())
1602 : {
1603 77 : tree expr = TREE_OPERAND (t, 0);
1604 77 : location_t loc = cp_expr_location (t);
1605 77 : if (diagnosing_failed_constraint::replay_errors_p ())
1606 : {
1607 : /* Replay the substitution error. */
1608 27 : inform (loc, "nested requirement %qE is not satisfied, because", expr);
1609 27 : constraint_satisfaction_value (t, args, info);
1610 : }
1611 : else
1612 50 : inform (loc, "nested requirement %qE is not satisfied", expr);
1613 : }
1614 :
1615 38996 : return error_mark_node;
1616 : }
1617 :
1618 : /* Substitute ARGS into the requirement T. */
1619 :
1620 : static tree
1621 23830829 : tsubst_requirement (tree t, tree args, sat_info info)
1622 : {
1623 23830829 : iloc_sentinel loc_s (cp_expr_location (t));
1624 23830829 : switch (TREE_CODE (t))
1625 : {
1626 5794940 : case SIMPLE_REQ:
1627 5794940 : return tsubst_simple_requirement (t, args, info);
1628 5480105 : case TYPE_REQ:
1629 5480105 : return tsubst_type_requirement (t, args, info);
1630 11529853 : case COMPOUND_REQ:
1631 11529853 : return tsubst_compound_requirement (t, args, info);
1632 1025931 : case NESTED_REQ:
1633 1025931 : return tsubst_nested_requirement (t, args, info);
1634 0 : default:
1635 0 : break;
1636 : }
1637 0 : gcc_unreachable ();
1638 23828129 : }
1639 :
1640 : static tree
1641 7276620 : declare_constraint_vars (tree parms, tree vars)
1642 : {
1643 7276620 : tree s = vars;
1644 18831680 : for (tree t = parms; t; t = DECL_CHAIN (t))
1645 : {
1646 11555060 : if (DECL_PACK_P (t))
1647 : {
1648 3064 : tree pack = extract_fnparm_pack (t, &s);
1649 3064 : register_local_specialization (pack, t);
1650 : }
1651 : else
1652 : {
1653 11551996 : register_local_specialization (s, t);
1654 11551996 : s = DECL_CHAIN (s);
1655 : }
1656 : }
1657 7276620 : return vars;
1658 : }
1659 :
1660 : /* Substitute through as if checking function parameter types. This
1661 : will diagnose common parameter type errors. Returns error_mark_node
1662 : if an error occurred. */
1663 :
1664 : static tree
1665 7276662 : check_constraint_variables (tree t, tree args, subst_info info)
1666 : {
1667 7276662 : tree types = NULL_TREE;
1668 7276662 : tree p = t;
1669 18831771 : while (p && !VOID_TYPE_P (p))
1670 : {
1671 11555109 : types = tree_cons (NULL_TREE, TREE_TYPE (p), types);
1672 11555109 : p = TREE_CHAIN (p);
1673 : }
1674 7276662 : types = chainon (nreverse (types), void_list_node);
1675 7276662 : return tsubst_function_parms (types, args, info.complain, info.in_decl);
1676 : }
1677 :
1678 : /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
1679 : into the parameter list T, producing a sequence of constraint
1680 : variables, declared in the current scope.
1681 :
1682 : Note that the caller must establish a local specialization stack
1683 : prior to calling this function since this substitution will
1684 : declare the substituted parameters. */
1685 :
1686 : static tree
1687 7276662 : tsubst_constraint_variables (tree t, tree args, subst_info info)
1688 : {
1689 : /* Perform a trial substitution to check for type errors. */
1690 7276662 : tree parms = check_constraint_variables (t, args, info);
1691 7276662 : if (parms == error_mark_node)
1692 : return error_mark_node;
1693 :
1694 : /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
1695 : of PARM_DECLs. */
1696 7276620 : int saved_unevaluated_operand = cp_unevaluated_operand;
1697 7276620 : cp_unevaluated_operand = 0;
1698 7276620 : tree vars = tsubst (t, args, info.complain, info.in_decl);
1699 7276620 : cp_unevaluated_operand = saved_unevaluated_operand;
1700 7276620 : if (vars == error_mark_node)
1701 : return error_mark_node;
1702 7276620 : return declare_constraint_vars (t, vars);
1703 : }
1704 :
1705 : /* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
1706 : substitution of template arguments into a requires-expression
1707 : may result in the formation of invalid types or expressions
1708 : in its requirements ... In such cases, the expression evaluates
1709 : to false; it does not cause the program to be ill-formed.
1710 :
1711 : When substituting through a REQUIRES_EXPR as part of template
1712 : instantiation, we call this routine with info.quiet() true.
1713 :
1714 : When evaluating a REQUIRES_EXPR that appears outside a template in
1715 : cp_parser_requires_expression, we call this routine with
1716 : info.noisy() true.
1717 :
1718 : Finally, when diagnosing unsatisfaction from diagnose_atomic_constraint
1719 : and when diagnosing a false REQUIRES_EXPR via diagnose_constraints,
1720 : we call this routine with info.diagnose_unsatisfaction_p() true. */
1721 :
1722 : static tree
1723 14898817 : tsubst_requires_expr (tree t, tree args, sat_info info)
1724 : {
1725 14898817 : local_specialization_stack stack (lss_copy);
1726 :
1727 : /* We need to check access during the substitution. */
1728 14898817 : deferring_access_check_sentinel acs (dk_no_deferred);
1729 :
1730 : /* A requires-expression is an unevaluated context. */
1731 14898817 : cp_unevaluated u;
1732 :
1733 14898817 : args = add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t), args,
1734 : info.complain, info.in_decl);
1735 14898817 : if (processing_template_decl
1736 14898817 : && !processing_constraint_expression_p ())
1737 : {
1738 : /* We're partially instantiating a generic lambda. Substituting into
1739 : this requires-expression now may cause its requirements to get
1740 : checked out of order, so instead just remember the template
1741 : arguments and wait until we can substitute them all at once.
1742 :
1743 : Except if this requires-expr is part of associated constraints
1744 : that we're substituting into directly (for e.g. declaration
1745 : matching or dguide constraint rewriting), in which case we need
1746 : to partially substitute. */
1747 734 : t = copy_node (t);
1748 734 : REQUIRES_EXPR_EXTRA_ARGS (t) = NULL_TREE;
1749 734 : REQUIRES_EXPR_EXTRA_ARGS (t) = build_extra_args (t, args, info.complain);
1750 734 : return t;
1751 : }
1752 :
1753 14898083 : tree parms = REQUIRES_EXPR_PARMS (t);
1754 14898083 : if (parms)
1755 : {
1756 7276662 : parms = tsubst_constraint_variables (parms, args, info);
1757 7276662 : if (parms == error_mark_node)
1758 42 : return boolean_false_node;
1759 : }
1760 :
1761 14898041 : tree result = boolean_true_node;
1762 14898041 : if (processing_template_decl)
1763 2818 : result = NULL_TREE;
1764 37259853 : for (tree reqs = REQUIRES_EXPR_REQS (t); reqs; reqs = TREE_CHAIN (reqs))
1765 : {
1766 23830829 : tree req = TREE_VALUE (reqs);
1767 23830829 : req = tsubst_requirement (req, args, info);
1768 23828129 : if (req == error_mark_node)
1769 : {
1770 1466652 : result = boolean_false_node;
1771 1466652 : if (info.diagnose_unsatisfaction_p ())
1772 : /* Keep going so that we diagnose all failed requirements. */;
1773 : else
1774 : break;
1775 : }
1776 22361477 : else if (processing_template_decl)
1777 3573 : result = tree_cons (NULL_TREE, req, result);
1778 : }
1779 14895341 : if (processing_template_decl && result != boolean_false_node)
1780 2818 : result = finish_requires_expr (EXPR_LOCATION (t), parms, nreverse (result));
1781 : return result;
1782 14896117 : }
1783 :
1784 : /* Public wrapper for the above. */
1785 :
1786 : tree
1787 14898364 : tsubst_requires_expr (tree t, tree args,
1788 : tsubst_flags_t complain, tree in_decl)
1789 : {
1790 14898364 : sat_info info (complain, in_decl);
1791 14898364 : return tsubst_requires_expr (t, args, info);
1792 : }
1793 :
1794 : /* Substitute ARGS into the constraint information CI, producing a new
1795 : constraint record. */
1796 :
1797 : tree
1798 763313 : tsubst_constraint_info (tree t, tree args,
1799 : tsubst_flags_t complain, tree in_decl)
1800 : {
1801 763313 : if (!t || t == error_mark_node || !check_constraint_info (t))
1802 : return NULL_TREE;
1803 :
1804 159350 : tree tr = tsubst_constraint (CI_TEMPLATE_REQS (t), args, complain, in_decl);
1805 318700 : tree dr = tsubst_constraint (CI_DECLARATOR_REQS (t), args, complain, in_decl);
1806 159350 : return build_constraints (tr, dr);
1807 : }
1808 :
1809 : /* Substitute through a parameter mapping, in order to get the actual
1810 : arguments used to instantiate an atomic constraint. This may fail
1811 : if the substitution into arguments produces something ill-formed. */
1812 :
1813 : static tree
1814 85397275 : tsubst_parameter_mapping (tree map, tree args, subst_info info)
1815 : {
1816 85397275 : if (!map)
1817 : return NULL_TREE;
1818 :
1819 85396537 : tsubst_flags_t complain = info.complain;
1820 85396537 : tree in_decl = info.in_decl;
1821 :
1822 85396537 : tree result = NULL_TREE;
1823 233154714 : for (tree p = map; p; p = TREE_CHAIN (p))
1824 : {
1825 147760692 : if (p == error_mark_node)
1826 : return error_mark_node;
1827 147760692 : tree parm = TREE_VALUE (p);
1828 147760692 : tree arg = TREE_PURPOSE (p);
1829 147760692 : tree new_arg;
1830 147760692 : if (ARGUMENT_PACK_P (arg))
1831 4922990 : new_arg = tsubst_argument_pack (arg, args, complain, in_decl);
1832 : else
1833 : {
1834 142837702 : new_arg = tsubst_template_arg (arg, args, complain, in_decl);
1835 142837702 : if (TYPE_P (new_arg))
1836 142512036 : new_arg = canonicalize_type_argument (new_arg, complain);
1837 : }
1838 147760692 : if (TREE_CODE (new_arg) == TYPE_ARGUMENT_PACK)
1839 : {
1840 4920597 : tree pack_args = ARGUMENT_PACK_ARGS (new_arg);
1841 9612744 : for (tree& pack_arg : tree_vec_range (pack_args))
1842 4692147 : if (TYPE_P (pack_arg))
1843 4692147 : pack_arg = canonicalize_type_argument (pack_arg, complain);
1844 : }
1845 147760692 : if (new_arg == error_mark_node)
1846 : return error_mark_node;
1847 :
1848 147758177 : result = tree_cons (new_arg, parm, result);
1849 : }
1850 85394022 : return nreverse (result);
1851 : }
1852 :
1853 : tree
1854 1091 : tsubst_parameter_mapping (tree map, tree args, tsubst_flags_t complain, tree in_decl)
1855 : {
1856 1091 : return tsubst_parameter_mapping (map, args, subst_info (complain, in_decl));
1857 : }
1858 :
1859 : /*---------------------------------------------------------------------------
1860 : Constraint satisfaction
1861 : ---------------------------------------------------------------------------*/
1862 :
1863 : /* True if we are currently satisfying a constraint. */
1864 :
1865 : static bool satisfying_constraint;
1866 :
1867 : /* A vector of incomplete types (and of declarations with undeduced return type),
1868 : appended to by note_failed_type_completion. The
1869 : satisfaction caches use this in order to keep track of "potentially unstable"
1870 : satisfaction results.
1871 :
1872 : Since references to entries in this vector are stored only in the
1873 : GC-deletable sat_cache, it's safe to make this deletable as well. */
1874 :
1875 : static GTY((deletable)) vec<tree, va_gc> *failed_type_completions;
1876 :
1877 : /* A map of where types were found to be incomplete in SFINAE context, for
1878 : warning if they are later completed. */
1879 :
1880 : static GTY((cache)) hash_map<tree, location_t, decl_location_traits> *failed_completions_map;
1881 :
1882 : /* Called whenever a type completion (or return type deduction) failure occurs
1883 : that definitely affects the meaning of the program, by e.g. inducing
1884 : substitution failure. */
1885 :
1886 : void
1887 4636 : note_failed_type_completion (tree t, tsubst_flags_t complain)
1888 : {
1889 4636 : if (dependent_template_arg_p (t))
1890 : return;
1891 :
1892 4599 : gcc_checking_assert ((TYPE_P (t) && !COMPLETE_TYPE_P (t))
1893 : || (DECL_P (t) && undeduced_auto_decl (t)));
1894 :
1895 4599 : if (satisfying_constraint)
1896 183 : vec_safe_push (failed_type_completions, t);
1897 :
1898 4599 : if (TYPE_P (t))
1899 : {
1900 3974 : if (!CLASS_TYPE_P (t))
1901 : return;
1902 3661 : t = TYPE_MAIN_DECL (t);
1903 : }
1904 4286 : if (!(complain & tf_error)
1905 7978 : && warning_enabled_at (DECL_SOURCE_LOCATION (t),
1906 3692 : OPT_Wsfinae_incomplete_))
1907 : {
1908 3690 : if (warn_sfinae_incomplete > 1)
1909 : {
1910 0 : if (TREE_CODE (t) == TYPE_DECL)
1911 0 : warning (OPT_Wsfinae_incomplete_,
1912 0 : "failed to complete %qT in SFINAE context", TREE_TYPE (t));
1913 : else
1914 0 : warning (OPT_Wsfinae_incomplete_,
1915 : "failed to deduce %qD in SFINAE context", t);
1916 : }
1917 3690 : if (!failed_completions_map)
1918 101 : failed_completions_map
1919 101 : = hash_map<tree, location_t, decl_location_traits>::create_ggc ();
1920 3690 : failed_completions_map->put (t, input_location);
1921 : }
1922 : }
1923 :
1924 : /* If T was previously found to be incomplete in SFINAE context, return the
1925 : location where that happened, otherwise UNKNOWN_LOCATION. */
1926 :
1927 : location_t
1928 58003451 : failed_completion_location (tree t)
1929 : {
1930 58003451 : if (failed_completions_map)
1931 : {
1932 109379 : if (TYPE_P (t))
1933 91144 : t = TYPE_MAIN_DECL (t);
1934 109379 : if (location_t *p = failed_completions_map->get (t))
1935 17 : return *p;
1936 : }
1937 : return UNKNOWN_LOCATION;
1938 : }
1939 :
1940 : /* Returns true if the range [BEGIN, END) of elements within the
1941 : failed_type_completions vector contains a complete type (or a
1942 : declaration with a non-placeholder return type). */
1943 :
1944 : static bool
1945 908072095 : some_type_complete_p (int begin, int end)
1946 : {
1947 908072680 : for (int i = begin; i < end; i++)
1948 : {
1949 648 : tree t = (*failed_type_completions)[i];
1950 648 : if (TYPE_P (t) && COMPLETE_TYPE_P (t))
1951 : return true;
1952 603 : if (DECL_P (t) && !undeduced_auto_decl (t))
1953 : return true;
1954 : }
1955 : return false;
1956 : }
1957 :
1958 : /* Hash functions and data types for satisfaction cache entries. */
1959 :
1960 : struct GTY((for_user)) sat_entry
1961 : {
1962 : /* The relevant ATOMIC_CONSTR. */
1963 : tree atom;
1964 :
1965 : /* The relevant template arguments. */
1966 : tree args;
1967 :
1968 : /* The result of satisfaction of ATOM+ARGS.
1969 : This is either boolean_true_node, boolean_false_node or error_mark_node,
1970 : where error_mark_node indicates ill-formed satisfaction.
1971 : It's set to NULL_TREE while computing satisfaction of ATOM+ARGS for
1972 : the first time. */
1973 : tree result;
1974 :
1975 : /* The value of input_location when satisfaction of ATOM+ARGS was first
1976 : performed. */
1977 : location_t location;
1978 :
1979 : /* The range of elements appended to the failed_type_completions vector
1980 : during computation of this satisfaction result, encoded as a begin/end
1981 : pair of offsets. */
1982 : int ftc_begin, ftc_end;
1983 :
1984 : /* True if we want to diagnose the above instability when it's detected.
1985 : We don't always want to do so, in order to avoid emitting duplicate
1986 : diagnostics in some cases. */
1987 : bool diagnose_instability;
1988 :
1989 : /* True if we're in the middle of computing this satisfaction result.
1990 : Used during both quiet and noisy satisfaction to detect self-recursive
1991 : satisfaction. */
1992 : bool evaluating;
1993 : };
1994 :
1995 : struct sat_hasher : ggc_ptr_hash<sat_entry>
1996 : {
1997 6040252508 : static hashval_t hash (sat_entry *e)
1998 : {
1999 6040252508 : auto cso = make_temp_override (comparing_specializations);
2000 6040252508 : ++comparing_specializations;
2001 :
2002 6040252508 : if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e->atom))
2003 : {
2004 : /* Atoms with instantiated mappings are built during satisfaction.
2005 : They live only inside the sat_cache, and we build one to query
2006 : the cache with each time we instantiate a mapping. */
2007 1677306848 : gcc_assert (!e->args);
2008 1677306848 : return hash_atomic_constraint (e->atom);
2009 : }
2010 :
2011 : /* Atoms with uninstantiated mappings are built during normalization.
2012 : Since normalize_atom caches the atoms it returns, we can assume
2013 : pointer-based identity for fast hashing and comparison. Even if this
2014 : assumption is violated, that's okay, we'll just get a cache miss. */
2015 4362945660 : hashval_t value = htab_hash_pointer (e->atom);
2016 :
2017 4362945660 : if (tree map = ATOMIC_CONSTR_MAP (e->atom))
2018 : /* Only the parameters that are used in the targets of the mapping
2019 : affect the satisfaction value of the atom. So we consider only
2020 : the arguments for these parameters, and ignore the rest. */
2021 4362941425 : for (tree target_parms = TREE_TYPE (map);
2022 9574141340 : target_parms;
2023 5211199915 : target_parms = TREE_CHAIN (target_parms))
2024 : {
2025 5211199915 : int level, index;
2026 5211199915 : tree parm = TREE_VALUE (target_parms);
2027 5211199915 : template_parm_level_and_index (parm, &level, &index);
2028 5211199915 : tree arg = TMPL_ARG (e->args, level, index);
2029 5211199915 : value = iterative_hash_template_arg (arg, value);
2030 : }
2031 : return value;
2032 6040252508 : }
2033 :
2034 6532403887 : static bool equal (sat_entry *e1, sat_entry *e2)
2035 : {
2036 6532403887 : auto cso = make_temp_override (comparing_specializations);
2037 6532403887 : ++comparing_specializations;
2038 :
2039 6532403887 : if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1->atom)
2040 6532403887 : != ATOMIC_CONSTR_MAP_INSTANTIATED_P (e2->atom))
2041 : return false;
2042 :
2043 : /* See sat_hasher::hash. */
2044 4575680256 : if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1->atom))
2045 : {
2046 229899435 : gcc_assert (!e1->args && !e2->args);
2047 229899435 : return atomic_constraints_identical_p (e1->atom, e2->atom);
2048 : }
2049 :
2050 4345780821 : if (e1->atom != e2->atom)
2051 : return false;
2052 :
2053 746305168 : if (tree map = ATOMIC_CONSTR_MAP (e1->atom))
2054 746303820 : for (tree target_parms = TREE_TYPE (map);
2055 1519265849 : target_parms;
2056 772962029 : target_parms = TREE_CHAIN (target_parms))
2057 : {
2058 781981245 : int level, index;
2059 781981245 : tree parm = TREE_VALUE (target_parms);
2060 781981245 : template_parm_level_and_index (parm, &level, &index);
2061 781981245 : tree arg1 = TMPL_ARG (e1->args, level, index);
2062 781981245 : tree arg2 = TMPL_ARG (e2->args, level, index);
2063 781981245 : if (!template_args_equal (arg1, arg2))
2064 9019216 : return false;
2065 : }
2066 : return true;
2067 6532403887 : }
2068 : };
2069 :
2070 : /* Cache the result of satisfy_atom. */
2071 : static GTY((deletable)) hash_table<sat_hasher> *sat_cache;
2072 :
2073 : /* Cache the result of satisfy_declaration_constraints. */
2074 : static GTY((deletable)) hash_map<tree, tree> *decl_satisfied_cache;
2075 :
2076 : /* A tool used by satisfy_atom to help manage satisfaction caching and to
2077 : diagnose "unstable" satisfaction values. We insert into the cache only
2078 : when performing satisfaction quietly. */
2079 :
2080 : struct satisfaction_cache
2081 : {
2082 : satisfaction_cache (tree, tree, sat_info);
2083 : tree get ();
2084 : tree save (tree);
2085 :
2086 : sat_entry *entry;
2087 : sat_info info;
2088 : int ftc_begin;
2089 : };
2090 :
2091 : /* Constructor for the satisfaction_cache class. We're performing satisfaction
2092 : of ATOM+ARGS according to INFO. */
2093 :
2094 908072137 : satisfaction_cache
2095 908072137 : ::satisfaction_cache (tree atom, tree args, sat_info info)
2096 908072137 : : entry(nullptr), info(info), ftc_begin(-1)
2097 : {
2098 908072137 : if (!sat_cache)
2099 70064 : sat_cache = hash_table<sat_hasher>::create_ggc (31);
2100 :
2101 : /* When noisy, we query the satisfaction cache in order to diagnose
2102 : "unstable" satisfaction values. */
2103 908072137 : if (info.noisy ())
2104 : {
2105 : /* When noisy, constraints have been re-normalized, and that breaks the
2106 : pointer-based identity assumption of sat_cache (for atoms with
2107 : uninstantiated mappings). So undo this re-normalization by looking in
2108 : the atom_cache for the corresponding atom that was used during quiet
2109 : satisfaction. */
2110 7296 : if (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom))
2111 : {
2112 3661 : if (tree found = atom_cache->find (atom))
2113 3661 : atom = found;
2114 : else
2115 : /* The lookup should always succeed, but if it fails then let's
2116 : just leave 'entry' empty, effectively disabling the cache. */
2117 0 : return;
2118 : }
2119 : }
2120 :
2121 : /* Look up or create the corresponding satisfaction entry. */
2122 908072137 : sat_entry elt;
2123 908072137 : elt.atom = atom;
2124 908072137 : elt.args = args;
2125 908072137 : sat_entry **slot = sat_cache->find_slot (&elt, INSERT);
2126 908072137 : if (*slot)
2127 788389868 : entry = *slot;
2128 119682269 : else if (info.quiet ())
2129 : {
2130 119682263 : entry = ggc_alloc<sat_entry> ();
2131 119682263 : entry->atom = atom;
2132 119682263 : entry->args = args;
2133 119682263 : entry->result = NULL_TREE;
2134 119682263 : entry->location = input_location;
2135 119682263 : entry->ftc_begin = entry->ftc_end = -1;
2136 119682263 : entry->diagnose_instability = false;
2137 119682263 : if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom))
2138 : /* We always want to diagnose instability of an atom with an
2139 : instantiated parameter mapping. For atoms with an uninstantiated
2140 : mapping, we set this flag (in satisfy_atom) only if substitution
2141 : into its mapping previously failed. */
2142 34289754 : entry->diagnose_instability = true;
2143 119682263 : entry->evaluating = false;
2144 119682263 : *slot = entry;
2145 : }
2146 : else
2147 : {
2148 : /* We're evaluating this atom for the first time, and doing so noisily.
2149 : This shouldn't happen outside of error recovery situations involving
2150 : unstable satisfaction. Let's just leave 'entry' empty, effectively
2151 : disabling the cache, and remove the empty slot. */
2152 6 : gcc_checking_assert (seen_error ());
2153 : /* Appease hash_table::check_complete_insertion. */
2154 6 : *slot = ggc_alloc<sat_entry> ();
2155 6 : sat_cache->clear_slot (slot);
2156 : }
2157 : }
2158 :
2159 : /* Returns the cached satisfaction result if we have one and we're not
2160 : recomputing the satisfaction result from scratch. Otherwise returns
2161 : NULL_TREE. */
2162 :
2163 : tree
2164 908072137 : satisfaction_cache::get ()
2165 : {
2166 908072137 : if (!entry)
2167 : return NULL_TREE;
2168 :
2169 908072131 : if (entry->evaluating)
2170 : {
2171 : /* If we get here, it means satisfaction is self-recursive. */
2172 36 : gcc_checking_assert (!entry->result || seen_error ());
2173 36 : if (info.noisy ())
2174 18 : error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry->atom)),
2175 : "satisfaction of atomic constraint %qE depends on itself",
2176 18 : entry->atom);
2177 36 : return error_mark_node;
2178 : }
2179 :
2180 : /* This satisfaction result is "potentially unstable" if a type for which
2181 : type completion failed during its earlier computation is now complete. */
2182 908072095 : bool maybe_unstable = some_type_complete_p (entry->ftc_begin,
2183 : entry->ftc_end);
2184 :
2185 908072095 : if (info.noisy () || maybe_unstable || !entry->result)
2186 : {
2187 : /* We're computing the satisfaction result from scratch. */
2188 119689577 : entry->evaluating = true;
2189 119689577 : ftc_begin = vec_safe_length (failed_type_completions);
2190 119689577 : return NULL_TREE;
2191 : }
2192 : else
2193 : return entry->result;
2194 : }
2195 :
2196 : /* RESULT is the computed satisfaction result. If RESULT differs from the
2197 : previously cached result, this routine issues an appropriate error.
2198 : Otherwise, when evaluating quietly, updates the cache appropriately. */
2199 :
2200 : tree
2201 119684183 : satisfaction_cache::save (tree result)
2202 : {
2203 119684183 : if (!entry)
2204 : return result;
2205 :
2206 119684177 : gcc_checking_assert (entry->evaluating);
2207 119684177 : entry->evaluating = false;
2208 :
2209 119684177 : if (entry->result && result != entry->result)
2210 : {
2211 42 : if (info.quiet ())
2212 : /* Return error_mark_node to force satisfaction to get replayed
2213 : noisily. */
2214 21 : return error_mark_node;
2215 : else
2216 : {
2217 21 : if (entry->diagnose_instability)
2218 : {
2219 12 : auto_diagnostic_group d;
2220 12 : error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry->atom)),
2221 : "satisfaction value of atomic constraint %qE changed "
2222 12 : "from %qE to %qE", entry->atom, entry->result, result);
2223 12 : inform (entry->location,
2224 : "satisfaction value first evaluated to %qE from here",
2225 12 : entry->result);
2226 12 : }
2227 : /* For sake of error recovery, allow this latest satisfaction result
2228 : to prevail. */
2229 21 : entry->result = result;
2230 21 : return result;
2231 : }
2232 : }
2233 :
2234 119684135 : if (info.quiet ())
2235 : {
2236 119676884 : entry->result = result;
2237 : /* Store into this entry the list of relevant failed type completions
2238 : that occurred during (re)computation of the satisfaction result. */
2239 119676884 : gcc_checking_assert (ftc_begin != -1);
2240 119676884 : entry->ftc_begin = ftc_begin;
2241 119915478 : entry->ftc_end = vec_safe_length (failed_type_completions);
2242 : }
2243 :
2244 : return result;
2245 : }
2246 :
2247 : /* Substitute ARGS into constraint-expression T during instantiation of
2248 : a member of a class template. */
2249 :
2250 : tree
2251 1880822 : tsubst_constraint (tree t, tree args, tsubst_flags_t complain, tree in_decl)
2252 : {
2253 : /* We also don't want to evaluate concept-checks when substituting the
2254 : constraint-expressions of a declaration. */
2255 1880822 : processing_constraint_expression_sentinel s;
2256 1880822 : cp_unevaluated u;
2257 1880822 : tree expr = tsubst_expr (t, args, complain, in_decl);
2258 3761644 : return expr;
2259 1880822 : }
2260 :
2261 : static tree satisfy_constraint_r (tree, tree, sat_info info);
2262 :
2263 : /* Compute the satisfaction of a conjunction. */
2264 :
2265 : static tree
2266 705119732 : satisfy_conjunction (tree t, tree args, sat_info info)
2267 : {
2268 705119732 : tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, info);
2269 705119732 : if (lhs == error_mark_node || lhs == boolean_false_node)
2270 : return lhs;
2271 696700835 : return satisfy_constraint_r (TREE_OPERAND (t, 1), args, info);
2272 : }
2273 :
2274 : /* The current depth at which we're replaying an error during recursive
2275 : diagnosis of a constraint satisfaction failure. */
2276 :
2277 : static int current_constraint_diagnosis_depth;
2278 :
2279 : /* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded
2280 : CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint
2281 : satisfaction error. */
2282 :
2283 : static bool concepts_diagnostics_max_depth_exceeded_p;
2284 :
2285 : /* Recursive subroutine of collect_operands_of_disjunction. T is a normalized
2286 : subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs)
2287 : and E is the corresponding unnormalized subexpression (composed of
2288 : TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */
2289 :
2290 : static void
2291 22 : collect_operands_of_disjunction_r (tree t, tree e,
2292 : auto_vec<tree_pair> *operands)
2293 : {
2294 36 : if (TREE_CODE (e) == TRUTH_ORIF_EXPR)
2295 : {
2296 14 : collect_operands_of_disjunction_r (TREE_OPERAND (t, 0),
2297 14 : TREE_OPERAND (e, 0), operands);
2298 14 : collect_operands_of_disjunction_r (TREE_OPERAND (t, 1),
2299 14 : TREE_OPERAND (e, 1), operands);
2300 : }
2301 : else
2302 : {
2303 22 : tree_pair p = std::make_pair (t, e);
2304 22 : operands->safe_push (p);
2305 : }
2306 22 : }
2307 :
2308 : /* Recursively collect the normalized and unnormalized operands of the
2309 : disjunction T and append them to OPERANDS in order. */
2310 :
2311 : static void
2312 8 : collect_operands_of_disjunction (tree t, auto_vec<tree_pair> *operands)
2313 : {
2314 8 : collect_operands_of_disjunction_r (t, CONSTR_EXPR (t), operands);
2315 8 : }
2316 :
2317 : /* Compute the satisfaction of a disjunction. */
2318 :
2319 : static tree
2320 70488546 : satisfy_disjunction (tree t, tree args, sat_info info)
2321 : {
2322 : /* Evaluate each operand with unsatisfaction diagnostics disabled. */
2323 70488546 : sat_info sub = info;
2324 70488546 : sub.diagnose_unsatisfaction = false;
2325 :
2326 70488546 : tree lhs = satisfy_constraint_r (TREE_OPERAND (t, 0), args, sub);
2327 70488546 : if (lhs == boolean_true_node || lhs == error_mark_node)
2328 : return lhs;
2329 :
2330 34098582 : tree rhs = satisfy_constraint_r (TREE_OPERAND (t, 1), args, sub);
2331 34098582 : if (rhs == boolean_true_node || rhs == error_mark_node)
2332 : return rhs;
2333 :
2334 : /* Both branches evaluated to false. Explain the satisfaction failure in
2335 : each branch. */
2336 3705479 : if (info.diagnose_unsatisfaction_p ())
2337 : {
2338 62 : diagnosing_failed_constraint failure (t, args, info.noisy ());
2339 62 : cp_expr disj_expr = CONSTR_EXPR (t);
2340 62 : inform (disj_expr.get_location (),
2341 : "no operand of the disjunction is satisfied");
2342 62 : if (diagnosing_failed_constraint::replay_errors_p ())
2343 : {
2344 8 : auto_diagnostic_nesting_level sentinel;
2345 : /* Replay the error in each branch of the disjunction. */
2346 8 : auto_vec<tree_pair> operands;
2347 8 : collect_operands_of_disjunction (t, &operands);
2348 30 : for (unsigned i = 0; i < operands.length (); i++)
2349 : {
2350 22 : tree norm_op = operands[i].first;
2351 22 : tree op = operands[i].second;
2352 22 : location_t loc = make_location (cp_expr_location (op),
2353 : disj_expr.get_start (),
2354 : disj_expr.get_finish ());
2355 22 : inform (loc, "the operand %qE is unsatisfied because", op);
2356 22 : auto_diagnostic_nesting_level sentinel;
2357 22 : satisfy_constraint_r (norm_op, args, info);
2358 22 : }
2359 8 : }
2360 62 : }
2361 :
2362 3705479 : return boolean_false_node;
2363 : }
2364 :
2365 : /* Ensures that T is a truth value and not (accidentally, as sometimes
2366 : happens) an integer value. */
2367 :
2368 : tree
2369 34286940 : satisfaction_value (tree t)
2370 : {
2371 34286940 : if (t == error_mark_node || t == boolean_true_node || t == boolean_false_node)
2372 : return t;
2373 :
2374 2 : gcc_assert (TREE_CODE (t) == INTEGER_CST
2375 : && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t),
2376 : boolean_type_node));
2377 2 : if (integer_zerop (t))
2378 0 : return boolean_false_node;
2379 : else
2380 2 : return boolean_true_node;
2381 : }
2382 :
2383 : /* Build a new template argument vector corresponding to the parameter
2384 : mapping of the atomic constraint T, using arguments from ARGS. */
2385 :
2386 : static tree
2387 34293407 : get_mapped_args (tree t, tree args)
2388 : {
2389 34293407 : tree map = ATOMIC_CONSTR_MAP (t);
2390 :
2391 : /* No map, no arguments. */
2392 34293407 : if (!map)
2393 : return NULL_TREE;
2394 :
2395 : /* Determine the depth of the resulting argument vector. */
2396 34292669 : int depth;
2397 34292669 : if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t))
2398 : /* The expression of this atomic constraint comes from a concept
2399 : definition, whose template depth is always one, so the resulting
2400 : argument vector will also have depth one. */
2401 : depth = 1;
2402 : else
2403 : /* Otherwise, the expression of this atomic constraint comes from
2404 : the context of the constrained entity, whose template depth is that
2405 : of ARGS. */
2406 24229684 : depth = TMPL_ARGS_DEPTH (args);
2407 :
2408 : /* Place each argument at its corresponding position in the argument
2409 : list. Note that the list will be sparse (not all arguments supplied),
2410 : but instantiation is guaranteed to only use the parameters in the
2411 : mapping, so null arguments would never be used. */
2412 34292669 : auto_vec< vec<tree> > lists (depth);
2413 34292669 : lists.quick_grow_cleared (depth);
2414 87163652 : for (tree p = map; p; p = TREE_CHAIN (p))
2415 : {
2416 52870983 : int level;
2417 52870983 : int index;
2418 52870983 : template_parm_level_and_index (TREE_VALUE (p), &level, &index);
2419 :
2420 : /* Insert the argument into its corresponding position. */
2421 52870983 : vec<tree> &list = lists[level - 1];
2422 70558619 : if (index >= (int)list.length ())
2423 48813478 : list.safe_grow_cleared (index + 1, /*exact=*/false);
2424 52870983 : list[index] = TREE_PURPOSE (p);
2425 : }
2426 :
2427 : /* Build the new argument list. */
2428 34292669 : args = make_tree_vec (lists.length ());
2429 140493138 : for (unsigned i = 0; i != lists.length (); ++i)
2430 : {
2431 35953900 : vec<tree> &list = lists[i];
2432 35953900 : tree level = make_tree_vec (list.length ());
2433 90008721 : for (unsigned j = 0; j < list.length (); ++j)
2434 54054821 : TREE_VEC_ELT (level, j) = list[j];
2435 35953900 : SET_TMPL_ARGS_LEVEL (args, i + 1, level);
2436 35953900 : list.release ();
2437 : }
2438 34292669 : SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, 0);
2439 :
2440 34292669 : if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)
2441 34292669 : && TMPL_ARGS_DEPTH (args) == 1)
2442 : {
2443 : /* Get rid of the redundant outer TREE_VEC. */
2444 32637984 : tree level = TMPL_ARGS_LEVEL (args, 1);
2445 32637984 : ggc_free (args);
2446 32637984 : args = level;
2447 : }
2448 :
2449 34292669 : return args;
2450 34292669 : }
2451 :
2452 : static void diagnose_atomic_constraint (tree, tree, tree, sat_info);
2453 :
2454 : /* Compute the satisfaction of an atomic constraint. */
2455 :
2456 : static tree
2457 822678464 : satisfy_atom (tree t, tree args, sat_info info)
2458 : {
2459 : /* In case there is a diagnostic, we want to establish the context
2460 : prior to printing errors. If no errors occur, this context is
2461 : removed before returning. */
2462 822678464 : diagnosing_failed_constraint failure (t, args, info.noisy ());
2463 :
2464 822678464 : satisfaction_cache cache (t, args, info);
2465 822678464 : if (tree r = cache.get ())
2466 : return r;
2467 :
2468 : /* Perform substitution quietly. */
2469 85396176 : subst_info quiet (tf_none, NULL_TREE);
2470 :
2471 : /* Instantiate the parameter mapping. */
2472 85396176 : tree map = tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, quiet);
2473 85396176 : if (map == error_mark_node)
2474 : {
2475 : /* If instantiation of the parameter mapping fails, the constraint is
2476 : not satisfied. Replay the substitution. */
2477 2503 : if (info.diagnose_unsatisfaction_p ())
2478 8 : tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t), args, info);
2479 2503 : if (info.quiet ())
2480 : /* Since instantiation of the parameter mapping failed, we
2481 : want to diagnose potential instability of this satisfaction
2482 : result. */
2483 2495 : cache.entry->diagnose_instability = true;
2484 2503 : return cache.save (boolean_false_node);
2485 : }
2486 :
2487 : /* Now build a new atom using the instantiated mapping. We use
2488 : this atom as a second key to the satisfaction cache, and we
2489 : also pass it to diagnose_atomic_constraint so that diagnostics
2490 : which refer to the atom display the instantiated mapping. */
2491 85393673 : t = copy_node (t);
2492 85393673 : ATOMIC_CONSTR_MAP (t) = map;
2493 85393673 : gcc_assert (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (t));
2494 85393673 : ATOMIC_CONSTR_MAP_INSTANTIATED_P (t) = true;
2495 85393673 : satisfaction_cache inst_cache (t, /*args=*/NULL_TREE, info);
2496 85393673 : if (tree r = inst_cache.get ())
2497 : {
2498 51100266 : cache.entry->location = inst_cache.entry->location;
2499 51100266 : return cache.save (r);
2500 : }
2501 :
2502 : /* Rebuild the argument vector from the parameter mapping. */
2503 34293407 : args = get_mapped_args (t, args);
2504 :
2505 : /* Apply the parameter mapping (i.e., just substitute). */
2506 34293407 : tree expr = ATOMIC_CONSTR_EXPR (t);
2507 34293407 : tree result = tsubst_expr (expr, args, quiet.complain, quiet.in_decl);
2508 34290707 : if (result == error_mark_node)
2509 : {
2510 : /* If substitution results in an invalid type or expression, the
2511 : constraint is not satisfied. Replay the substitution. */
2512 3712 : if (info.diagnose_unsatisfaction_p ())
2513 20 : tsubst_expr (expr, args, info.complain, info.in_decl);
2514 3712 : return cache.save (inst_cache.save (boolean_false_node));
2515 : }
2516 :
2517 : /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary,
2518 : and EXPR shall be a constant expression of type bool. */
2519 34286995 : result = force_rvalue (result, info.complain);
2520 34286995 : if (result == error_mark_node)
2521 0 : return cache.save (inst_cache.save (error_mark_node));
2522 34286995 : tree substituted = result;
2523 34286995 : if (!same_type_p (TREE_TYPE (result), boolean_type_node))
2524 : {
2525 55 : if (info.noisy ())
2526 30 : diagnose_atomic_constraint (t, args, substituted, info);
2527 55 : return cache.save (inst_cache.save (error_mark_node));
2528 : }
2529 :
2530 : /* Compute the value of the constraint. */
2531 34286940 : if (info.noisy ())
2532 : {
2533 3576 : iloc_sentinel ils (EXPR_LOCATION (result));
2534 3576 : result = cxx_constant_value (result);
2535 3576 : }
2536 : else
2537 : {
2538 34283364 : result = maybe_constant_value (result, NULL_TREE, mce_true);
2539 34283364 : if (!TREE_CONSTANT (result))
2540 22 : result = error_mark_node;
2541 : }
2542 34286940 : result = satisfaction_value (result);
2543 34286940 : if (result == boolean_false_node && info.diagnose_unsatisfaction_p ())
2544 1173 : diagnose_atomic_constraint (t, args, substituted, info);
2545 :
2546 34286940 : return cache.save (inst_cache.save (result));
2547 822675764 : }
2548 :
2549 : /* Determine if the normalized constraint T is satisfied.
2550 : Returns boolean_true_node if the expression/constraint is
2551 : satisfied, boolean_false_node if not, and error_mark_node
2552 : if there was an error evaluating the constraint.
2553 :
2554 : The parameter mapping of atomic constraints is simply the
2555 : set of template arguments that will be substituted into
2556 : the expression, regardless of template parameters appearing
2557 : within. Whether a template argument is used in the atomic
2558 : constraint only matters for subsumption. */
2559 :
2560 : static tree
2561 1598286879 : satisfy_constraint_r (tree t, tree args, sat_info info)
2562 : {
2563 1598286879 : if (t == error_mark_node)
2564 : return error_mark_node;
2565 :
2566 1598286742 : switch (TREE_CODE (t))
2567 : {
2568 705119732 : case CONJ_CONSTR:
2569 705119732 : return satisfy_conjunction (t, args, info);
2570 70488546 : case DISJ_CONSTR:
2571 70488546 : return satisfy_disjunction (t, args, info);
2572 822678464 : case ATOMIC_CONSTR:
2573 822678464 : return satisfy_atom (t, args, info);
2574 0 : default:
2575 0 : gcc_unreachable ();
2576 : }
2577 : }
2578 :
2579 : /* Check that the normalized constraint T is satisfied for ARGS. */
2580 :
2581 : static tree
2582 91879162 : satisfy_normalized_constraints (tree t, tree args, sat_info info)
2583 : {
2584 91879162 : auto_timevar time (TV_CONSTRAINT_SAT);
2585 :
2586 91879162 : auto ovr = make_temp_override (satisfying_constraint, true);
2587 :
2588 : /* Turn off template processing. Constraint satisfaction only applies
2589 : to non-dependent terms, so we want to ensure full checking here. */
2590 91879162 : processing_template_decl_sentinel proc (true);
2591 :
2592 : /* We need to check access during satisfaction. */
2593 91879162 : deferring_access_check_sentinel acs (dk_no_deferred);
2594 :
2595 : /* Constraints are unevaluated operands. */
2596 91879162 : cp_unevaluated u;
2597 :
2598 91879162 : return satisfy_constraint_r (t, args, info);
2599 91876462 : }
2600 :
2601 : /* Return the normal form of the constraints on the placeholder 'auto'
2602 : type T. */
2603 :
2604 : static tree
2605 11046313 : normalize_placeholder_type_constraints (tree t, bool diag)
2606 : {
2607 11046313 : gcc_assert (is_auto (t));
2608 11046313 : tree ci = PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t);
2609 11046313 : if (!ci)
2610 : return NULL_TREE;
2611 :
2612 11046313 : tree constr = TREE_VALUE (ci);
2613 : /* The TREE_PURPOSE contains the set of template parameters that were in
2614 : scope for this placeholder type; use them as the initial template
2615 : parameters for normalization. */
2616 11046313 : tree initial_parms = TREE_PURPOSE (ci);
2617 :
2618 : /* The 'auto' itself is used as the first argument in its own constraints,
2619 : and its level is one greater than its template depth. So in order to
2620 : capture all used template parameters, we need to add an extra level of
2621 : template parameters to the context; a dummy level suffices. */
2622 11046313 : initial_parms
2623 22092385 : = tree_cons (size_int (initial_parms
2624 : ? TMPL_PARMS_DEPTH (initial_parms) + 1 : 1),
2625 : make_tree_vec (0), initial_parms);
2626 :
2627 11046313 : norm_info info (diag);
2628 11046313 : info.initial_parms = initial_parms;
2629 11046313 : return normalize_constraint_expression (constr, info);
2630 : }
2631 :
2632 : /* Evaluate the constraints of T using ARGS, returning a satisfaction value.
2633 : Here, T can be a concept-id, nested-requirement, placeholder 'auto', or
2634 : requires-expression. */
2635 :
2636 : static tree
2637 15819414 : satisfy_nondeclaration_constraints (tree t, tree args, sat_info info)
2638 : {
2639 15819414 : if (t == error_mark_node)
2640 : return error_mark_node;
2641 :
2642 : /* Handle REQUIRES_EXPR directly, bypassing satisfaction. */
2643 15819410 : if (TREE_CODE (t) == REQUIRES_EXPR)
2644 : {
2645 165 : auto ovr = make_temp_override (current_constraint_diagnosis_depth);
2646 165 : if (info.noisy ())
2647 35 : ++current_constraint_diagnosis_depth;
2648 165 : return tsubst_requires_expr (t, args, info);
2649 165 : }
2650 :
2651 : /* Get the normalized constraints. */
2652 15819245 : tree norm;
2653 15819245 : if (concept_check_p (t))
2654 : {
2655 3746962 : gcc_assert (!args);
2656 3746962 : args = TREE_OPERAND (t, 1);
2657 3746962 : tree tmpl = get_concept_check_template (t);
2658 3746962 : norm = normalize_concept_definition (tmpl, info.noisy ());
2659 : }
2660 12072283 : else if (TREE_CODE (t) == NESTED_REQ)
2661 : {
2662 1025970 : norm_info ninfo (info.noisy ());
2663 : /* The TREE_TYPE contains the set of template parameters that were in
2664 : scope for this nested requirement; use them as the initial template
2665 : parameters for normalization. */
2666 1025970 : ninfo.initial_parms = TREE_TYPE (t);
2667 1025970 : norm = normalize_constraint_expression (TREE_OPERAND (t, 0), ninfo);
2668 : }
2669 11046313 : else if (is_auto (t))
2670 : {
2671 11046313 : norm = normalize_placeholder_type_constraints (t, info.noisy ());
2672 11046313 : if (!norm)
2673 0 : return boolean_true_node;
2674 : }
2675 : else
2676 0 : gcc_unreachable ();
2677 :
2678 : /* Perform satisfaction. */
2679 15819245 : return satisfy_normalized_constraints (norm, args, info);
2680 : }
2681 :
2682 : /* Evaluate the associated constraints of the template specialization T
2683 : according to INFO, returning a satisfaction value. */
2684 :
2685 : static tree
2686 869629972 : satisfy_declaration_constraints (tree t, sat_info info)
2687 : {
2688 869629972 : gcc_assert (DECL_P (t) && TREE_CODE (t) != TEMPLATE_DECL);
2689 869629972 : const tree saved_t = t;
2690 :
2691 : /* For inherited constructors, consider the original declaration;
2692 : it has the correct template information attached. */
2693 869629972 : t = strip_inheriting_ctors (t);
2694 869629972 : tree inh_ctor_targs = NULL_TREE;
2695 869629972 : if (t != saved_t)
2696 369352 : if (tree ti = DECL_TEMPLATE_INFO (saved_t))
2697 : /* The inherited constructor points to an instantiation of a constructor
2698 : template; remember its template arguments. */
2699 28213 : inh_ctor_targs = TI_ARGS (ti);
2700 :
2701 : /* Update the declaration for diagnostics. */
2702 869629972 : info.in_decl = t;
2703 :
2704 869629972 : if (info.quiet ())
2705 1739121137 : if (tree *result = hash_map_safe_get (decl_satisfied_cache, saved_t))
2706 745242076 : return *result;
2707 :
2708 124387896 : tree args = NULL_TREE;
2709 124387896 : if (tree ti = DECL_TEMPLATE_INFO (t))
2710 : {
2711 : /* The initial parameter mapping is the complete set of
2712 : template arguments substituted into the declaration. */
2713 84446275 : args = TI_ARGS (ti);
2714 84446275 : if (inh_ctor_targs)
2715 11887 : args = add_outermost_template_args (args, inh_ctor_targs);
2716 : }
2717 :
2718 124387896 : if (regenerated_lambda_fn_p (t))
2719 : {
2720 : /* The TI_ARGS of a regenerated lambda contains only the innermost
2721 : set of template arguments. Augment this with the outer template
2722 : arguments that were used to regenerate the lambda. */
2723 1610554 : gcc_assert (!args || TMPL_ARGS_DEPTH (args) == 1);
2724 1031917 : tree regen_args = lambda_regenerating_args (t);
2725 1031917 : if (args)
2726 578637 : args = add_to_template_args (regen_args, args);
2727 : else
2728 : args = regen_args;
2729 : }
2730 :
2731 : /* If the innermost arguments are dependent, or if the outer arguments
2732 : are dependent and are needed by the constraints, we can't check
2733 : satisfaction yet so pretend they're satisfied for now. */
2734 124387896 : if (uses_template_parms (args)
2735 124387896 : && ((DECL_TEMPLATE_INFO (t)
2736 282206 : && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))
2737 93604 : && (TMPL_ARGS_DEPTH (args) == 1
2738 22848 : || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args))))
2739 258306 : || uses_outer_template_parms_in_constraints (t)))
2740 23978 : return boolean_true_node;
2741 :
2742 : /* Get the normalized constraints. */
2743 124363918 : tree norm = get_normalized_constraints_from_decl (t, info.noisy ());
2744 :
2745 124363918 : unsigned ftc_count = vec_safe_length (failed_type_completions);
2746 :
2747 124363918 : tree result = boolean_true_node;
2748 124363918 : if (norm)
2749 : {
2750 3469045 : if (!push_tinst_level (t))
2751 : return result;
2752 3468587 : push_to_top_level ();
2753 3468587 : push_access_scope (t);
2754 3468587 : result = satisfy_normalized_constraints (norm, args, info);
2755 3468587 : pop_access_scope (t);
2756 3468587 : pop_from_top_level ();
2757 3468587 : pop_tinst_level ();
2758 : }
2759 :
2760 : /* True if this satisfaction is (heuristically) potentially unstable, i.e.
2761 : if its result may depend on where in the program it was performed. */
2762 124363460 : bool maybe_unstable_satisfaction = false;
2763 124465429 : if (ftc_count != vec_safe_length (failed_type_completions))
2764 : /* Type completion failure occurred during satisfaction. The satisfaction
2765 : result may (or may not) materially depend on the completeness of a type,
2766 : so we consider it potentially unstable. */
2767 : maybe_unstable_satisfaction = true;
2768 :
2769 124363460 : if (maybe_unstable_satisfaction)
2770 : /* Don't cache potentially unstable satisfaction, to allow satisfy_atom
2771 : to check the stability the next time around. */;
2772 124363460 : else if (info.quiet ())
2773 124363370 : hash_map_safe_put<hm_ggc> (decl_satisfied_cache, saved_t, result);
2774 :
2775 124363460 : return result;
2776 : }
2777 :
2778 : /* Evaluate the associated constraints of the template T using ARGS as the
2779 : innermost set of template arguments and according to INFO, returning a
2780 : satisfaction value. */
2781 :
2782 : static tree
2783 475683244 : satisfy_declaration_constraints (tree t, tree args, sat_info info)
2784 : {
2785 475683244 : tree orig_args = args;
2786 :
2787 : /* Update the declaration for diagnostics. */
2788 475683244 : info.in_decl = t;
2789 :
2790 475683244 : gcc_assert (TREE_CODE (t) == TEMPLATE_DECL);
2791 :
2792 475683244 : if (regenerated_lambda_fn_p (t))
2793 : {
2794 : /* As in the two-parameter version of this function. */
2795 1175696 : gcc_assert (TMPL_ARGS_DEPTH (args) == 1);
2796 587848 : tree lambda = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t));
2797 587848 : tree outer_args = TI_ARGS (LAMBDA_EXPR_REGEN_INFO (lambda));
2798 587848 : args = add_to_template_args (outer_args, args);
2799 : }
2800 : else
2801 475095396 : args = add_outermost_template_args (t, args);
2802 :
2803 : /* If the innermost arguments are dependent, or if the outer arguments
2804 : are dependent and are needed by the constraints, we can't check
2805 : satisfaction yet so pretend they're satisfied for now. */
2806 475683244 : if (uses_template_parms (args)
2807 589671020 : && (TMPL_ARGS_DEPTH (args) == 1
2808 7399356 : || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args))
2809 303835 : || uses_outer_template_parms_in_constraints (t)))
2810 113683941 : return boolean_true_node;
2811 :
2812 361999303 : tree result = boolean_true_node;
2813 361999303 : if (tree norm = get_normalized_constraints_from_decl (t, info.noisy ()))
2814 : {
2815 72591330 : if (!push_tinst_level (t, orig_args))
2816 : return result;
2817 72591330 : tree pattern = DECL_TEMPLATE_RESULT (t);
2818 72591330 : push_to_top_level ();
2819 72591330 : push_access_scope (pattern);
2820 72591330 : result = satisfy_normalized_constraints (norm, args, info);
2821 72588630 : pop_access_scope (pattern);
2822 72588630 : pop_from_top_level ();
2823 72588630 : pop_tinst_level ();
2824 : }
2825 :
2826 : return result;
2827 : }
2828 :
2829 : /* A wrapper around satisfy_declaration_constraints and
2830 : satisfy_nondeclaration_constraints which additionally replays
2831 : quiet ill-formed satisfaction noisily, so that ill-formed
2832 : satisfaction always gets diagnosed. */
2833 :
2834 : static tree
2835 1361132630 : constraint_satisfaction_value (tree t, tree args, sat_info info)
2836 : {
2837 1361132630 : tree r;
2838 1361132630 : if (DECL_P (t))
2839 : {
2840 1345313216 : if (args)
2841 475683244 : r = satisfy_declaration_constraints (t, args, info);
2842 : else
2843 869629972 : r = satisfy_declaration_constraints (t, info);
2844 : }
2845 : else
2846 15819414 : r = satisfy_nondeclaration_constraints (t, args, info);
2847 316 : if (r == error_mark_node && info.quiet ()
2848 1361130077 : && !(DECL_P (t) && warning_suppressed_p (t)))
2849 : {
2850 : /* Replay the error noisily. */
2851 147 : sat_info noisy (tf_warning_or_error, info.in_decl);
2852 147 : constraint_satisfaction_value (t, args, noisy);
2853 147 : if (DECL_P (t) && !args)
2854 : /* Avoid giving these errors again. */
2855 0 : suppress_warning (t);
2856 : }
2857 1361129930 : return r;
2858 : }
2859 :
2860 : /* True iff the result of satisfying T using ARGS is BOOLEAN_TRUE_NODE
2861 : and false otherwise, even in the case of errors.
2862 :
2863 : Here, T can be:
2864 : - a template declaration
2865 : - a template specialization (in which case ARGS must be empty)
2866 : - a concept-id (in which case ARGS must be empty)
2867 : - a nested-requirement
2868 : - a placeholder 'auto'
2869 : - a requires-expression. */
2870 :
2871 : bool
2872 1358068595 : constraints_satisfied_p (tree t, tree args/*= NULL_TREE */)
2873 : {
2874 1358068595 : if (!flag_concepts)
2875 : return true;
2876 :
2877 1356358414 : sat_info quiet (tf_none, NULL_TREE);
2878 1356358414 : return constraint_satisfaction_value (t, args, quiet) == boolean_true_node;
2879 : }
2880 :
2881 : /* Evaluate a concept check of the form C<ARGS>. This is only used for the
2882 : evaluation of template-ids as id-expressions. */
2883 :
2884 : tree
2885 3746689 : evaluate_concept_check (tree check)
2886 : {
2887 3746689 : if (check == error_mark_node)
2888 : return error_mark_node;
2889 :
2890 3746689 : gcc_assert (concept_check_p (check));
2891 :
2892 : /* We don't want any declarations instantiated from a concept evaluation
2893 : to enter the binding table for the current scope, such as lambdas, so
2894 : leave that scope. But maintain the access context (PR104111). */
2895 3746689 : tree scope = current_scope ();
2896 3746689 : if (CLASS_TYPE_P (scope))
2897 738713 : scope = TYPE_MAIN_DECL (scope);
2898 3007976 : else if (TREE_CODE (scope) != FUNCTION_DECL)
2899 197463 : scope = NULL_TREE;
2900 :
2901 738713 : push_to_top_level ();
2902 3746689 : if (scope)
2903 3549226 : push_access_scope (scope);
2904 :
2905 : /* Check for satisfaction without diagnostics. */
2906 3746689 : sat_info quiet (tf_none, NULL_TREE);
2907 3746689 : tree r = constraint_satisfaction_value (check, /*args=*/NULL_TREE, quiet);
2908 :
2909 3746689 : if (scope)
2910 3549226 : pop_access_scope (scope);
2911 3746689 : pop_from_top_level ();
2912 3746689 : return r;
2913 : }
2914 :
2915 : /* Evaluate the requires-expression T, returning either boolean_true_node
2916 : or boolean_false_node. This is used during folding and constexpr
2917 : evaluation. */
2918 :
2919 : tree
2920 130 : evaluate_requires_expr (tree t)
2921 : {
2922 130 : gcc_assert (TREE_CODE (t) == REQUIRES_EXPR);
2923 130 : sat_info quiet (tf_none, NULL_TREE);
2924 130 : return constraint_satisfaction_value (t, /*args=*/NULL_TREE, quiet);
2925 : }
2926 :
2927 : /*---------------------------------------------------------------------------
2928 : Semantic analysis of requires-expressions
2929 : ---------------------------------------------------------------------------*/
2930 :
2931 : /* Finish a requires expression for the given PARMS (possibly
2932 : null) and the non-empty sequence of requirements. */
2933 :
2934 : tree
2935 2747350 : finish_requires_expr (location_t loc, tree parms, tree reqs)
2936 : {
2937 : /* Build the node. */
2938 2747350 : tree r = build_min (REQUIRES_EXPR, boolean_type_node, parms, reqs, NULL_TREE);
2939 2747350 : TREE_SIDE_EFFECTS (r) = false;
2940 2747350 : TREE_CONSTANT (r) = true;
2941 2747350 : SET_EXPR_LOCATION (r, loc);
2942 2747350 : return r;
2943 : }
2944 :
2945 : /* Construct a requirement for the validity of EXPR. */
2946 :
2947 : tree
2948 1443430 : finish_simple_requirement (location_t loc, tree expr)
2949 : {
2950 1443430 : tree r = build_nt (SIMPLE_REQ, expr);
2951 1443430 : SET_EXPR_LOCATION (r, loc);
2952 1443430 : return r;
2953 : }
2954 :
2955 : /* Construct a requirement for the validity of TYPE. */
2956 :
2957 : tree
2958 734471 : finish_type_requirement (location_t loc, tree type)
2959 : {
2960 734471 : tree r = build_nt (TYPE_REQ, type);
2961 734471 : SET_EXPR_LOCATION (r, loc);
2962 734471 : return r;
2963 : }
2964 :
2965 : /* Construct a requirement for the validity of EXPR, along with
2966 : its properties. If TYPE is non-null, then it specifies either
2967 : an implicit conversion or argument deduction constraint,
2968 : depending on whether any placeholders occur in the type name.
2969 : NOEXCEPT_P is true iff the noexcept keyword was specified. */
2970 :
2971 : tree
2972 1410816 : finish_compound_requirement (location_t loc, tree expr, tree type, bool noexcept_p)
2973 : {
2974 1410816 : tree req = build_nt (COMPOUND_REQ, expr, type);
2975 1410816 : SET_EXPR_LOCATION (req, loc);
2976 1410816 : COMPOUND_REQ_NOEXCEPT_P (req) = noexcept_p;
2977 1410816 : return req;
2978 : }
2979 :
2980 : /* Finish a nested requirement. */
2981 :
2982 : tree
2983 233356 : finish_nested_requirement (location_t loc, tree expr)
2984 : {
2985 : /* Build the requirement, saving the set of in-scope template
2986 : parameters as its type. */
2987 233356 : tree r = build1 (NESTED_REQ, current_template_parms, expr);
2988 233356 : SET_EXPR_LOCATION (r, loc);
2989 233356 : return r;
2990 : }
2991 :
2992 : /*---------------------------------------------------------------------------
2993 : Equivalence of constraints
2994 : ---------------------------------------------------------------------------*/
2995 :
2996 : /* Returns true when A and B are equivalent constraints. */
2997 : bool
2998 28403976 : equivalent_constraints (tree a, tree b)
2999 : {
3000 28403976 : gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO);
3001 28403976 : gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO);
3002 28403976 : return cp_tree_equal (a, b);
3003 : }
3004 :
3005 : /* Returns true if the template declarations A and B have equivalent
3006 : constraints. This is the case when A's constraints subsume B's and
3007 : when B's also constrain A's. */
3008 : bool
3009 146 : equivalently_constrained (tree d1, tree d2)
3010 : {
3011 146 : gcc_assert (TREE_CODE (d1) == TREE_CODE (d2));
3012 146 : return equivalent_constraints (get_constraints (d1), get_constraints (d2));
3013 : }
3014 :
3015 : /*---------------------------------------------------------------------------
3016 : Partial ordering of constraints
3017 : ---------------------------------------------------------------------------*/
3018 :
3019 : /* Returns true when the constraints in CI strictly subsume
3020 : the associated constraints of TMPL. */
3021 :
3022 : bool
3023 648266 : strictly_subsumes (tree ci, tree tmpl)
3024 : {
3025 648266 : tree n1 = get_normalized_constraints_from_info (ci, NULL_TREE);
3026 648266 : tree n2 = get_normalized_constraints_from_decl (tmpl);
3027 :
3028 648266 : return subsumes (n1, n2) && !subsumes (n2, n1);
3029 : }
3030 :
3031 : /* Returns true when the template template parameter constraints in CI
3032 : subsume the associated constraints of the template template argument
3033 : TMPL. */
3034 :
3035 : bool
3036 87 : ttp_subsumes (tree ci, tree tmpl)
3037 : {
3038 87 : tree n1 = get_normalized_constraints_from_info (ci, tmpl);
3039 87 : tree n2 = get_normalized_constraints_from_decl (tmpl);
3040 :
3041 87 : return subsumes (n1, n2);
3042 : }
3043 :
3044 : /* Determines which of the declarations, A or B, is more constrained.
3045 : That is, which declaration's constraints subsume but are not subsumed
3046 : by the other's?
3047 :
3048 : Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
3049 : than D1, and 0 otherwise. */
3050 :
3051 : int
3052 3577976 : more_constrained (tree d1, tree d2)
3053 : {
3054 3577976 : tree n1 = get_normalized_constraints_from_decl (d1);
3055 3577976 : tree n2 = get_normalized_constraints_from_decl (d2);
3056 :
3057 3577976 : int winner = 0;
3058 3577976 : if (subsumes (n1, n2))
3059 3280138 : ++winner;
3060 3577976 : if (subsumes (n2, n1))
3061 2471813 : --winner;
3062 3577976 : return winner;
3063 : }
3064 :
3065 : /* Return whether D1 is at least as constrained as D2. */
3066 :
3067 : bool
3068 7562878 : at_least_as_constrained (tree d1, tree d2)
3069 : {
3070 7562878 : tree n1 = get_normalized_constraints_from_decl (d1);
3071 7562878 : tree n2 = get_normalized_constraints_from_decl (d2);
3072 :
3073 7562878 : return subsumes (n1, n2);
3074 : }
3075 :
3076 : /*---------------------------------------------------------------------------
3077 : Constraint diagnostics
3078 : ---------------------------------------------------------------------------*/
3079 :
3080 : /* Returns the best location to diagnose a constraint error. */
3081 :
3082 : static location_t
3083 1203 : get_constraint_error_location (tree t)
3084 : {
3085 1203 : if (location_t loc = cp_expr_location (t))
3086 : return loc;
3087 :
3088 : /* If we have a specific location give it. */
3089 1203 : tree expr = CONSTR_EXPR (t);
3090 1203 : if (location_t loc = cp_expr_location (expr))
3091 : return loc;
3092 :
3093 : /* If the constraint is normalized from a requires-clause, give
3094 : the location as that of the constrained declaration. */
3095 80 : tree cxt = CONSTR_CONTEXT (t);
3096 80 : tree src = cxt ? TREE_VALUE (cxt) : NULL_TREE;
3097 78 : if (!src)
3098 : /* TODO: This only happens for constrained non-template declarations. */
3099 : ;
3100 78 : else if (DECL_P (src))
3101 63 : return DECL_SOURCE_LOCATION (src);
3102 : /* Otherwise, give the location as the defining concept. */
3103 15 : else if (concept_check_p (src))
3104 : {
3105 15 : tree tmpl = TREE_OPERAND (src, 0);
3106 15 : return DECL_SOURCE_LOCATION (tmpl);
3107 : }
3108 :
3109 2 : return input_location;
3110 : }
3111 :
3112 : /* Emit a diagnostic for a failed trait. */
3113 :
3114 : void
3115 783 : diagnose_trait_expr (location_t loc, tree expr, tree args)
3116 : {
3117 : /* Build a "fake" version of the instantiated trait, so we can
3118 : get the instantiated types from result. */
3119 783 : ++processing_template_decl;
3120 783 : expr = tsubst_expr (expr, args, tf_none, NULL_TREE);
3121 783 : --processing_template_decl;
3122 :
3123 783 : tree t1 = TRAIT_EXPR_TYPE1 (expr);
3124 783 : tree t2 = TRAIT_EXPR_TYPE2 (expr);
3125 783 : gcc_checking_assert (t1 != error_mark_node && t2 != error_mark_node);
3126 :
3127 783 : iloc_sentinel ils (loc);
3128 :
3129 : /* For traits intrinsically about the properties of user-defined types,
3130 : decl_loc will point to the declaration of that type. */
3131 783 : location_t decl_loc = location_of (t1);
3132 783 : if (decl_loc == input_location)
3133 511 : decl_loc = loc;
3134 :
3135 783 : switch (TRAIT_EXPR_KIND (expr))
3136 : {
3137 4 : case CPTK_HAS_NOTHROW_ASSIGN:
3138 4 : inform (decl_loc, "%qT is not nothrow copy assignable", t1);
3139 4 : break;
3140 4 : case CPTK_HAS_NOTHROW_CONSTRUCTOR:
3141 4 : inform (decl_loc, "%qT is not nothrow default constructible", t1);
3142 4 : break;
3143 4 : case CPTK_HAS_NOTHROW_COPY:
3144 4 : inform (decl_loc, "%qT is not nothrow copy constructible", t1);
3145 4 : break;
3146 4 : case CPTK_HAS_TRIVIAL_ASSIGN:
3147 4 : inform (decl_loc, "%qT is not trivially copy assignable", t1);
3148 4 : break;
3149 4 : case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
3150 4 : inform (decl_loc, "%qT is not trivially default constructible", t1);
3151 4 : break;
3152 4 : case CPTK_HAS_TRIVIAL_COPY:
3153 4 : inform (decl_loc, "%qT is not trivially copy constructible", t1);
3154 4 : break;
3155 4 : case CPTK_HAS_TRIVIAL_DESTRUCTOR:
3156 4 : inform (decl_loc, "%qT is not trivially destructible", t1);
3157 4 : break;
3158 30 : case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
3159 30 : inform (decl_loc, "%qT does not have unique object "
3160 : "representations, because", t1);
3161 30 : type_has_unique_obj_representations (t1, /*explain=*/true);
3162 30 : break;
3163 19 : case CPTK_HAS_VIRTUAL_DESTRUCTOR:
3164 19 : {
3165 19 : location_t dtor_loc = decl_loc;
3166 19 : if (NON_UNION_CLASS_TYPE_P (t1))
3167 6 : if (tree dtor = CLASSTYPE_DESTRUCTOR (t1))
3168 3 : dtor_loc = DECL_SOURCE_LOCATION (dtor);
3169 19 : inform (dtor_loc, "%qT does not have a virtual destructor", t1);
3170 : }
3171 19 : break;
3172 4 : case CPTK_IS_ABSTRACT:
3173 4 : inform (decl_loc, "%qT is not an abstract class", t1);
3174 4 : break;
3175 3 : case CPTK_IS_AGGREGATE:
3176 3 : inform (decl_loc, "%qT is not an aggregate", t1);
3177 3 : break;
3178 0 : case CPTK_IS_ARRAY:
3179 0 : inform (loc, "%qT is not an array", t1);
3180 0 : break;
3181 15 : case CPTK_IS_ASSIGNABLE:
3182 15 : inform (loc, "%qT is not assignable from %qT, because", t1, t2);
3183 15 : is_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
3184 15 : break;
3185 1 : case CPTK_IS_BASE_OF:
3186 1 : inform (location_of (t2), "%qT is not a base of %qT", t1, t2);
3187 1 : break;
3188 0 : case CPTK_IS_BOUNDED_ARRAY:
3189 0 : inform (loc, "%qT is not a bounded array", t1);
3190 0 : break;
3191 103 : case CPTK_IS_CLASS:
3192 103 : inform (decl_loc, "%qT is not a class", t1);
3193 103 : break;
3194 0 : case CPTK_IS_CONST:
3195 0 : inform (loc, "%qT is not a const type", t1);
3196 0 : break;
3197 135 : case CPTK_IS_CONSTRUCTIBLE:
3198 135 : if (!TREE_VEC_LENGTH (t2))
3199 76 : inform (loc, "%qT is not default constructible, because", t1);
3200 : else
3201 59 : inform (loc, "%qT is not constructible from %qT, because", t1, t2);
3202 135 : is_xible (INIT_EXPR, t1, t2, /*explain=*/true);
3203 135 : break;
3204 17 : case CPTK_IS_CONVERTIBLE:
3205 : /* The errors produced here all seem to mention "convertible" in the
3206 : diagnostic, so an extra inform here appears redundant. */
3207 17 : is_convertible (t1, t2, /*explain=*/true);
3208 17 : break;
3209 12 : case CPTK_IS_DESTRUCTIBLE:
3210 12 : inform (loc, "%qT is not destructible, because", t1);
3211 12 : is_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
3212 12 : break;
3213 4 : case CPTK_IS_EMPTY:
3214 4 : inform (decl_loc, "%qT is not an empty class", t1);
3215 4 : break;
3216 0 : case CPTK_IS_ENUM:
3217 0 : inform (decl_loc, "%qT is not an enum", t1);
3218 0 : break;
3219 4 : case CPTK_IS_FINAL:
3220 4 : inform (decl_loc, "%qT is not a final class", t1);
3221 4 : break;
3222 0 : case CPTK_IS_FUNCTION:
3223 0 : inform (loc, "%qT is not a function", t1);
3224 0 : break;
3225 0 : case CPTK_IS_IMPLICIT_LIFETIME:
3226 0 : inform (decl_loc, "%qT is not an implicit-lifetime type", t1);
3227 0 : break;
3228 20 : case CPTK_IS_INVOCABLE:
3229 20 : {
3230 20 : if (!TREE_VEC_LENGTH (t2))
3231 11 : inform (loc, "%qT is not invocable, because", t1);
3232 : else
3233 9 : inform (loc, "%qT is not invocable by %qT, because", t1, t2);
3234 20 : build_invoke (t1, t2, tf_error);
3235 : }
3236 20 : break;
3237 24 : case CPTK_IS_LAYOUT_COMPATIBLE:
3238 24 : inform (loc, "%qT is not layout compatible with %qT, because", t1, t2);
3239 24 : layout_compatible_type_p (t1, t2, /*explain=*/true);
3240 24 : break;
3241 0 : case CPTK_IS_LITERAL_TYPE:
3242 0 : inform (decl_loc, "%qT is not a literal type", t1);
3243 0 : break;
3244 0 : case CPTK_IS_MEMBER_FUNCTION_POINTER:
3245 0 : inform (loc, "%qT is not a member function pointer", t1);
3246 0 : break;
3247 0 : case CPTK_IS_MEMBER_OBJECT_POINTER:
3248 0 : inform (loc, "%qT is not a member object pointer", t1);
3249 0 : break;
3250 0 : case CPTK_IS_MEMBER_POINTER:
3251 0 : inform (loc, "%qT is not a member pointer", t1);
3252 0 : break;
3253 6 : case CPTK_IS_NOTHROW_ASSIGNABLE:
3254 6 : inform (loc, "%qT is not nothrow assignable from %qT, because", t1, t2);
3255 6 : is_nothrow_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
3256 6 : break;
3257 15 : case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
3258 15 : if (!TREE_VEC_LENGTH (t2))
3259 6 : inform (loc, "%qT is not nothrow default constructible, because", t1);
3260 : else
3261 9 : inform (loc, "%qT is not nothrow constructible from %qT, because",
3262 : t1, t2);
3263 15 : is_nothrow_xible (INIT_EXPR, t1, t2, /*explain=*/true);
3264 15 : break;
3265 6 : case CPTK_IS_NOTHROW_CONVERTIBLE:
3266 6 : inform (loc, "%qT is not nothrow convertible from %qT, because", t1, t2);
3267 6 : is_nothrow_convertible (t1, t2, /*explain=*/true);
3268 6 : break;
3269 8 : case CPTK_IS_NOTHROW_DESTRUCTIBLE:
3270 8 : inform (loc, "%qT is not nothrow destructible, because", t1);
3271 8 : is_nothrow_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
3272 8 : break;
3273 9 : case CPTK_IS_NOTHROW_INVOCABLE:
3274 9 : {
3275 9 : if (!TREE_VEC_LENGTH (t2))
3276 6 : inform (loc, "%qT is not nothrow invocable, because", t1);
3277 : else
3278 3 : inform (loc, "%qT is not nothrow invocable by %qT, because", t1, t2);
3279 9 : tree call = build_invoke (t1, t2, tf_error);
3280 9 : if (call != error_mark_node)
3281 9 : explain_not_noexcept (call);
3282 : }
3283 : break;
3284 46 : case CPTK_IS_OBJECT:
3285 46 : inform (loc, "%qT is not an object type", t1);
3286 46 : break;
3287 15 : case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
3288 15 : inform (location_of (t2),
3289 : "%qT is not a pointer-interconvertible base of %qT, because",
3290 : t1, t2);
3291 15 : pointer_interconvertible_base_of_p (t1, t2, /*explain=*/true);
3292 15 : break;
3293 4 : case CPTK_IS_POD:
3294 4 : inform (loc, "%qT is not a POD type", t1);
3295 4 : break;
3296 0 : case CPTK_IS_POINTER:
3297 0 : inform (loc, "%qT is not a pointer", t1);
3298 0 : break;
3299 4 : case CPTK_IS_POLYMORPHIC:
3300 4 : inform (decl_loc, "%qT is not a polymorphic type", t1);
3301 4 : break;
3302 0 : case CPTK_IS_REFERENCE:
3303 0 : inform (loc, "%qT is not a reference", t1);
3304 0 : break;
3305 178 : case CPTK_IS_SAME:
3306 178 : inform (loc, "%q#T is not the same as %q#T", t1, t2);
3307 178 : break;
3308 0 : case CPTK_IS_SCOPED_ENUM:
3309 0 : inform (decl_loc, "%qT is not a scoped enum", t1);
3310 0 : break;
3311 4 : case CPTK_IS_STD_LAYOUT:
3312 4 : inform (decl_loc, "%qT is not a standard layout type", t1);
3313 4 : break;
3314 4 : case CPTK_IS_TRIVIAL:
3315 4 : inform (decl_loc, "%qT is not a trivial type", t1);
3316 4 : break;
3317 6 : case CPTK_IS_TRIVIALLY_ASSIGNABLE:
3318 6 : inform (loc, "%qT is not trivially assignable from %qT, because", t1, t2);
3319 6 : is_trivially_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
3320 6 : break;
3321 15 : case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
3322 15 : if (!TREE_VEC_LENGTH (t2))
3323 6 : inform (loc, "%qT is not trivially default constructible, because", t1);
3324 : else
3325 9 : inform (loc, "%qT is not trivially constructible from %qT, because",
3326 : t1, t2);
3327 15 : is_trivially_xible (INIT_EXPR, t1, t2, /*explain=*/true);
3328 15 : break;
3329 7 : case CPTK_IS_TRIVIALLY_COPYABLE:
3330 7 : inform (decl_loc, "%qT is not trivially copyable", t1);
3331 7 : break;
3332 6 : case CPTK_IS_TRIVIALLY_DESTRUCTIBLE:
3333 6 : inform (loc, "%qT is not trivially destructible, because", t1);
3334 6 : is_trivially_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
3335 6 : break;
3336 0 : case CPTK_IS_UNBOUNDED_ARRAY:
3337 0 : inform (loc, "%qT is not an unbounded array", t1);
3338 0 : break;
3339 4 : case CPTK_IS_UNION:
3340 4 : inform (decl_loc, "%qT is not a union", t1);
3341 4 : break;
3342 6 : case CPTK_IS_VIRTUAL_BASE_OF:
3343 6 : inform (location_of (t2), "%qT is not a virtual base of %qT", t1, t2);
3344 6 : break;
3345 0 : case CPTK_IS_VOLATILE:
3346 0 : inform (loc, "%qT is not a volatile type", t1);
3347 0 : break;
3348 0 : case CPTK_IS_CONSTEVAL_ONLY:
3349 0 : inform (decl_loc, "%qT is not consteval-only", t1);
3350 0 : break;
3351 0 : case CPTK_RANK:
3352 0 : inform (loc, "%qT cannot yield a rank", t1);
3353 0 : break;
3354 0 : case CPTK_TYPE_ORDER:
3355 0 : inform (loc, "%qT and %qT cannot be ordered", t1, t2);
3356 0 : break;
3357 0 : case CPTK_STRUCTURED_BINDING_SIZE:
3358 0 : inform (loc, "%qT is not destructurable", t1);
3359 0 : break;
3360 0 : case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY:
3361 0 : inform (loc, "%qT is not a reference that binds to a temporary "
3362 : "object of type %qT (direct-initialization)", t1, t2);
3363 0 : break;
3364 0 : case CPTK_REF_CONVERTS_FROM_TEMPORARY:
3365 0 : inform (loc, "%qT is not a reference that binds to a temporary "
3366 : "object of type %qT (copy-initialization)", t1, t2);
3367 0 : break;
3368 21 : case CPTK_IS_DEDUCIBLE:
3369 21 : inform (loc, "%qD is not deducible from %qT", t1, t2);
3370 21 : break;
3371 : #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
3372 : case CPTK_##CODE:
3373 : #include "cp-trait.def"
3374 : #undef DEFTRAIT_TYPE
3375 : /* Type-yielding traits aren't expressions. */
3376 0 : gcc_unreachable ();
3377 : /* We deliberately omit the default case so that when adding a new
3378 : trait we'll get reminded (by way of a warning) to handle it here. */
3379 : }
3380 783 : }
3381 :
3382 : /* Attempt to detect if this is a standard type trait, defined in terms
3383 : of a compiler builtin (above). If so, this will allow us to provide
3384 : more helpful diagnostics. */
3385 :
3386 : bool
3387 1808 : maybe_diagnose_standard_trait (location_t loc, tree expr)
3388 : {
3389 1808 : gcc_assert (TREE_CODE (expr) != TRAIT_EXPR);
3390 1808 : expr = tree_strip_nop_conversions (expr);
3391 :
3392 : /* TODO: in some cases it would be possible to provide more helpful
3393 : diagnostics for negations of traits, e.g. '!is_same_v<T1, T2>'. */
3394 :
3395 1808 : tree args = NULL_TREE;
3396 1808 : if (VAR_P (expr) && DECL_LANG_SPECIFIC (expr) && DECL_USE_TEMPLATE (expr))
3397 : {
3398 801 : tree tinfo = DECL_TEMPLATE_INFO (expr);
3399 801 : if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)) && TI_PARTIAL_INFO (tinfo))
3400 12 : tinfo = TI_PARTIAL_INFO (tinfo);
3401 789 : else if (DECL_TEMPLATE_SPECIALIZATION (expr))
3402 : /* In an explicit specialisation we no longer know what the original
3403 : initializer looked like. */
3404 : tinfo = NULL_TREE;
3405 :
3406 792 : if (tinfo)
3407 : {
3408 792 : expr = DECL_INITIAL (DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo)));
3409 792 : args = TI_ARGS (tinfo);
3410 : }
3411 : }
3412 :
3413 1808 : if (expr && TREE_CODE (expr) == TRAIT_EXPR)
3414 : {
3415 410 : diagnose_trait_expr (loc, expr, args);
3416 410 : return true;
3417 : }
3418 :
3419 : return false;
3420 : }
3421 :
3422 : /* Diagnose a substitution failure in the atomic constraint T using ARGS. */
3423 :
3424 : static void
3425 1203 : diagnose_atomic_constraint (tree t, tree args, tree substituted, sat_info info)
3426 : {
3427 : /* If the constraint is already ill-formed, we've previously diagnosed
3428 : the reason. We should still say why the constraints aren't satisfied. */
3429 1203 : if (t == error_mark_node)
3430 : {
3431 0 : location_t loc;
3432 0 : if (info.in_decl)
3433 0 : loc = DECL_SOURCE_LOCATION (info.in_decl);
3434 : else
3435 0 : loc = input_location;
3436 0 : inform (loc, "invalid constraints");
3437 0 : return;
3438 : }
3439 :
3440 1203 : location_t loc = get_constraint_error_location (t);
3441 1203 : iloc_sentinel loc_s (loc);
3442 :
3443 : /* Generate better diagnostics for certain kinds of expressions. */
3444 1203 : tree expr = ATOMIC_CONSTR_EXPR (t);
3445 1203 : STRIP_ANY_LOCATION_WRAPPER (expr);
3446 :
3447 1203 : if (TREE_CODE (expr) == REQUIRES_EXPR)
3448 : {
3449 288 : gcc_checking_assert (info.diagnose_unsatisfaction_p ());
3450 : /* Clear in_decl before replaying the substitution to avoid emitting
3451 : seemingly unhelpful "in declaration ..." notes that follow some
3452 : substitution failure error messages. */
3453 288 : info.in_decl = NULL_TREE;
3454 288 : tsubst_requires_expr (expr, args, info);
3455 : }
3456 915 : else if (!same_type_p (TREE_TYPE (substituted), boolean_type_node))
3457 30 : error_at (loc, "constraint %qE has type %qT, not %<bool%>",
3458 30 : t, TREE_TYPE (substituted));
3459 : else
3460 : {
3461 885 : inform (loc, "the expression %qE evaluated to %<false%>", t);
3462 885 : if (TREE_CODE (expr) == TRAIT_EXPR)
3463 373 : diagnose_trait_expr (loc, expr, args);
3464 : else
3465 512 : maybe_diagnose_standard_trait (loc, substituted);
3466 : }
3467 1203 : }
3468 :
3469 : GTY(()) tree current_failed_constraint;
3470 :
3471 822678526 : diagnosing_failed_constraint::
3472 822678526 : diagnosing_failed_constraint (tree t, tree args, bool diag)
3473 822678526 : : diagnosing_error (diag)
3474 : {
3475 822678526 : if (diagnosing_error)
3476 : {
3477 3723 : current_failed_constraint
3478 3723 : = tree_cons (args, t, current_failed_constraint);
3479 3723 : ++current_constraint_diagnosis_depth;
3480 : }
3481 822678526 : }
3482 :
3483 822675826 : diagnosing_failed_constraint::
3484 : ~diagnosing_failed_constraint ()
3485 : {
3486 822675826 : if (diagnosing_error)
3487 : {
3488 3723 : --current_constraint_diagnosis_depth;
3489 3723 : if (current_failed_constraint)
3490 2372 : current_failed_constraint = TREE_CHAIN (current_failed_constraint);
3491 : }
3492 :
3493 822675826 : }
3494 :
3495 : /* Whether we are allowed to replay an error that underlies a constraint failure
3496 : at the current diagnosis depth. */
3497 :
3498 : bool
3499 397 : diagnosing_failed_constraint::replay_errors_p ()
3500 : {
3501 397 : if (current_constraint_diagnosis_depth >= concepts_diagnostics_max_depth)
3502 : {
3503 338 : concepts_diagnostics_max_depth_exceeded_p = true;
3504 338 : return false;
3505 : }
3506 : else
3507 : return true;
3508 : }
3509 :
3510 : /* Emit diagnostics detailing the failure ARGS to satisfy the constraints
3511 : of T. Here, T and ARGS are as in constraints_satisfied_p. */
3512 :
3513 : void
3514 1292 : diagnose_constraints (location_t loc, tree t, tree args)
3515 : {
3516 1292 : inform (loc, "constraints not satisfied");
3517 :
3518 1292 : if (concepts_diagnostics_max_depth == 0)
3519 0 : return;
3520 :
3521 1292 : auto_diagnostic_nesting_level sentinel;
3522 :
3523 : /* Replay satisfaction, but diagnose unsatisfaction. */
3524 1292 : sat_info noisy (tf_warning_or_error, NULL_TREE, /*diag_unsat=*/true);
3525 1292 : constraint_satisfaction_value (t, args, noisy);
3526 :
3527 1292 : static bool suggested_p;
3528 1292 : if (concepts_diagnostics_max_depth_exceeded_p
3529 347 : && current_constraint_diagnosis_depth == 0
3530 344 : && !suggested_p)
3531 : {
3532 140 : inform (UNKNOWN_LOCATION,
3533 : "set %qs to at least %d for more detail",
3534 : "-fconcepts-diagnostics-depth=",
3535 140 : concepts_diagnostics_max_depth + 1);
3536 140 : suggested_p = true;
3537 : }
3538 1292 : }
3539 :
3540 : #include "gt-cp-constraint.h"
|
