1 /* Processing rules for constraints.
2 Copyright (C) 2013-2024 Free Software Foundation, Inc.
3 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
5 This file is part of GCC.
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)
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.
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/>. */
23 #include "coretypes.h"
29 #include "double-int.h"
36 #include "stringpool.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"
47 #include "type-utils.h"
49 static tree
satisfaction_value (tree t
);
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. */
55 processing_constraint_expression_sentinel::
56 processing_constraint_expression_sentinel ()
58 ++scope_chain
->x_processing_constraint
;
61 processing_constraint_expression_sentinel::
62 ~processing_constraint_expression_sentinel ()
64 --scope_chain
->x_processing_constraint
;
68 processing_constraint_expression_p ()
70 return scope_chain
->x_processing_constraint
!= 0;
73 /*---------------------------------------------------------------------------
74 Constraint expressions
75 ---------------------------------------------------------------------------*/
77 /* Information provided to substitution. */
81 subst_info (tsubst_flags_t cmp
, tree in
)
82 : complain (cmp
), in_decl (in
)
85 /* True if we should not diagnose errors. */
88 return complain
== tf_none
;
91 /* True if we should diagnose errors. */
97 tsubst_flags_t complain
;
101 /* Provides additional context for 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.
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
129 struct sat_info
: subst_info
131 sat_info (tsubst_flags_t cmp
, tree in
, bool diag_unsat
= false)
132 : subst_info (cmp
, in
), diagnose_unsatisfaction (diag_unsat
)
134 if (diagnose_unsatisfaction_p ())
135 gcc_checking_assert (noisy ());
138 /* True if we should diagnose the cause of satisfaction failure.
141 diagnose_unsatisfaction_p () const
143 return diagnose_unsatisfaction
;
146 bool diagnose_unsatisfaction
;
149 static tree
constraint_satisfaction_value (tree
, tree
, sat_info
);
151 /* True if T is known to be some type other than bool. Note that this
152 is false for dependent types and errors. */
155 known_non_bool_p (tree t
)
157 return (t
&& !WILDCARD_TYPE_P (t
) && TREE_CODE (t
) != BOOLEAN_TYPE
);
161 check_constraint_atom (cp_expr expr
)
163 if (known_non_bool_p (TREE_TYPE (expr
)))
165 error_at (expr
.get_location (),
166 "constraint expression does not have type %<bool%>");
170 /* Check that we're using function concepts correctly. */
171 if (concept_check_p (expr
))
173 tree id
= unpack_concept_check (expr
);
174 tree tmpl
= TREE_OPERAND (id
, 0);
175 if (OVL_P (tmpl
) && TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
177 error_at (EXPR_LOC_OR_LOC (expr
, input_location
),
178 "function concept must be called");
187 check_constraint_operands (location_t
, cp_expr lhs
, cp_expr rhs
)
189 return check_constraint_atom (lhs
) && check_constraint_atom (rhs
);
192 /* Validate the semantic properties of the constraint expression. */
195 finish_constraint_binary_op (location_t loc
,
200 gcc_assert (processing_constraint_expression_p ());
201 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
202 return error_mark_node
;
203 if (!check_constraint_operands (loc
, lhs
, rhs
))
204 return error_mark_node
;
206 = build_min_nt_loc (loc
, code
, lhs
.get_value (), rhs
.get_value ());
207 expr
.set_range (lhs
.get_start (), rhs
.get_finish ());
212 finish_constraint_or_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
214 return finish_constraint_binary_op (loc
, TRUTH_ORIF_EXPR
, lhs
, rhs
);
218 finish_constraint_and_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
220 return finish_constraint_binary_op (loc
, TRUTH_ANDIF_EXPR
, lhs
, rhs
);
224 finish_constraint_primary_expr (cp_expr expr
)
226 if (expr
== error_mark_node
)
227 return error_mark_node
;
228 if (!check_constraint_atom (expr
))
229 return cp_expr (error_mark_node
, expr
.get_location ());
233 /* Combine two constraint-expressions with a logical-and. */
236 combine_constraint_expressions (tree lhs
, tree rhs
)
238 processing_constraint_expression_sentinel pce
;
243 /* Use UNKNOWN_LOCATION so write_template_args can tell the difference
244 between this and a && the user wrote. */
245 return finish_constraint_and_expr (UNKNOWN_LOCATION
, lhs
, rhs
);
248 /* Extract the template-id from a concept check. For standard and variable
249 checks, this is simply T. For function concept checks, this is the
253 unpack_concept_check (tree t
)
255 gcc_assert (concept_check_p (t
));
257 if (TREE_CODE (t
) == CALL_EXPR
)
258 t
= CALL_EXPR_FN (t
);
260 gcc_assert (TREE_CODE (t
) == TEMPLATE_ID_EXPR
);
264 /* Extract the TEMPLATE_DECL from a concept check. */
267 get_concept_check_template (tree t
)
269 tree id
= unpack_concept_check (t
);
270 tree tmpl
= TREE_OPERAND (id
, 0);
272 tmpl
= OVL_FIRST (tmpl
);
276 /*---------------------------------------------------------------------------
277 Resolution of qualified concept names
278 ---------------------------------------------------------------------------*/
280 /* This facility is used to resolve constraint checks from requirement
281 expressions. A constraint check is a call to a function template declared
282 with the keyword 'concept'.
284 The result of resolution is a pair (a TREE_LIST) whose value is the
285 matched declaration, and whose purpose contains the coerced template
286 arguments that can be substituted into the call. */
288 /* Given an overload set OVL, try to find a unique definition that can be
289 instantiated by the template arguments ARGS.
291 This function is not called for arbitrary call expressions. In particular,
292 the call expression must be written with explicit template arguments
293 and no function arguments. For example:
297 If a single match is found, this returns a TREE_LIST whose VALUE
298 is the constraint function (not the template), and its PURPOSE is
299 the complete set of arguments substituted into the parameter list. */
302 resolve_function_concept_overload (tree ovl
, tree args
)
305 tree cands
= NULL_TREE
;
306 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
309 if (TREE_CODE (tmpl
) != TEMPLATE_DECL
)
312 /* Don't try to deduce checks for non-concepts. We often end up trying
313 to resolve constraints in functional casts as part of a
314 postfix-expression. We can save time and headaches by not
315 instantiating those declarations.
317 NOTE: This masks a potential error, caused by instantiating
318 non-deduced contexts using placeholder arguments. */
319 tree fn
= DECL_TEMPLATE_RESULT (tmpl
);
320 if (DECL_ARGUMENTS (fn
))
322 if (!DECL_DECLARED_CONCEPT_P (fn
))
325 /* Remember the candidate if we can deduce a substitution. */
326 ++processing_template_decl
;
327 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
328 if (tree subst
= coerce_template_parms (parms
, args
, tmpl
, tf_none
))
330 if (subst
== error_mark_node
)
333 cands
= tree_cons (subst
, fn
, cands
);
335 --processing_template_decl
;
339 /* We either had no candidates or failed deductions. */
340 return nerrs
? error_mark_node
: NULL_TREE
;
341 else if (TREE_CHAIN (cands
))
342 /* There are multiple candidates. */
343 return error_mark_node
;
348 /* Determine if the call expression CALL is a constraint check, and
349 return the concept declaration and arguments being checked. If CALL
350 does not denote a constraint check, return NULL. */
353 resolve_function_concept_check (tree call
)
355 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
357 /* A constraint check must be only a template-id expression.
358 If it's a call to a base-link, its function(s) should be a
359 template-id expression. If this is not a template-id, then
360 it cannot be a concept-check. */
361 tree target
= CALL_EXPR_FN (call
);
362 if (BASELINK_P (target
))
363 target
= BASELINK_FUNCTIONS (target
);
364 if (TREE_CODE (target
) != TEMPLATE_ID_EXPR
)
367 /* Get the overload set and template arguments and try to
368 resolve the target. */
369 tree ovl
= TREE_OPERAND (target
, 0);
371 /* This is a function call of a variable concept... ill-formed. */
372 if (TREE_CODE (ovl
) == TEMPLATE_DECL
)
374 error_at (location_of (call
),
375 "function call of variable concept %qE", call
);
376 return error_mark_node
;
379 tree args
= TREE_OPERAND (target
, 1);
380 return resolve_function_concept_overload (ovl
, args
);
383 /* Returns a pair containing the checked concept and its associated
384 prototype parameter. The result is a TREE_LIST whose TREE_VALUE
385 is the concept (non-template) and whose TREE_PURPOSE contains
386 the converted template arguments, including the deduced prototype
387 parameter (in position 0). */
390 resolve_concept_check (tree check
)
392 gcc_assert (concept_check_p (check
));
393 tree id
= unpack_concept_check (check
);
394 tree tmpl
= TREE_OPERAND (id
, 0);
396 /* If this is an overloaded function concept, perform overload
397 resolution (this only happens when deducing prototype parameters
398 and template introductions). */
399 if (TREE_CODE (tmpl
) == OVERLOAD
)
401 if (OVL_CHAIN (tmpl
))
402 return resolve_function_concept_check (check
);
403 tmpl
= OVL_FIRST (tmpl
);
406 tree args
= TREE_OPERAND (id
, 1);
407 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
408 ++processing_template_decl
;
409 tree result
= coerce_template_parms (parms
, args
, tmpl
, tf_none
);
410 --processing_template_decl
;
411 if (result
== error_mark_node
)
412 return error_mark_node
;
413 return build_tree_list (result
, DECL_TEMPLATE_RESULT (tmpl
));
416 /* Given a call expression or template-id expression to a concept EXPR
417 possibly including a wildcard, deduce the concept being checked and
418 the prototype parameter. Returns true if the constraint and prototype
419 can be deduced and false otherwise. Note that the CHECK and PROTO
420 arguments are set to NULL_TREE if this returns false. */
423 deduce_constrained_parameter (tree expr
, tree
& check
, tree
& proto
)
425 tree info
= resolve_concept_check (expr
);
426 if (info
&& info
!= error_mark_node
)
428 check
= TREE_VALUE (info
);
429 tree arg
= TREE_VEC_ELT (TREE_PURPOSE (info
), 0);
430 if (ARGUMENT_PACK_P (arg
))
431 arg
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0);
432 proto
= TREE_TYPE (arg
);
436 check
= proto
= NULL_TREE
;
440 /* Given a call expression or template-id expression to a concept, EXPR,
441 deduce the concept being checked and return the template arguments.
442 Returns NULL_TREE if deduction fails. */
444 deduce_concept_introduction (tree check
)
446 tree info
= resolve_concept_check (check
);
447 if (info
&& info
!= error_mark_node
)
448 return TREE_PURPOSE (info
);
452 /* Build a constrained placeholder type where SPEC is a type-constraint.
453 SPEC can be anything were concept_definition_p is true.
455 Returns a pair whose FIRST is the concept being checked and whose
456 SECOND is the prototype parameter. */
459 finish_type_constraints (tree spec
, tree args
, tsubst_flags_t complain
)
461 gcc_assert (concept_definition_p (spec
));
463 /* Build an initial concept check. */
464 tree check
= build_type_constraint (spec
, args
, complain
);
465 if (check
== error_mark_node
)
466 return std::make_pair (error_mark_node
, NULL_TREE
);
468 /* Extract the concept and prototype parameter from the check. */
471 if (!deduce_constrained_parameter (check
, con
, proto
))
472 return std::make_pair (error_mark_node
, NULL_TREE
);
474 return std::make_pair (con
, proto
);
477 /*---------------------------------------------------------------------------
478 Expansion of concept definitions
479 ---------------------------------------------------------------------------*/
481 /* Returns the expression of a function concept. */
484 get_returned_expression (tree fn
)
486 /* Extract the body of the function minus the return expression. */
487 tree body
= DECL_SAVED_TREE (fn
);
489 return error_mark_node
;
490 if (TREE_CODE (body
) == BIND_EXPR
)
491 body
= BIND_EXPR_BODY (body
);
492 if (TREE_CODE (body
) != RETURN_EXPR
)
493 return error_mark_node
;
495 return TREE_OPERAND (body
, 0);
498 /* Returns the initializer of a variable concept. */
501 get_variable_initializer (tree var
)
503 tree init
= DECL_INITIAL (var
);
505 return error_mark_node
;
506 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
507 && CONSTRUCTOR_NELTS (init
) == 1)
508 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
512 /* Returns the definition of a variable or function concept. */
515 get_concept_definition (tree decl
)
517 if (TREE_CODE (decl
) == OVERLOAD
)
518 decl
= OVL_FIRST (decl
);
520 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
521 decl
= DECL_TEMPLATE_RESULT (decl
);
523 if (TREE_CODE (decl
) == CONCEPT_DECL
)
524 return DECL_INITIAL (decl
);
526 return get_variable_initializer (decl
);
527 if (TREE_CODE (decl
) == FUNCTION_DECL
)
528 return get_returned_expression (decl
);
532 /*---------------------------------------------------------------------------
533 Normalization of expressions
535 This set of functions will transform an expression into a constraint
536 in a sequence of steps.
537 ---------------------------------------------------------------------------*/
540 debug_parameter_mapping (tree map
)
542 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
544 tree parm
= TREE_VALUE (p
);
545 tree arg
= TREE_PURPOSE (p
);
547 verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm
), arg
);
549 verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm
), arg
);
550 // debug_tree (parm);
556 debug_argument_list (tree args
)
558 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
560 tree arg
= TREE_VEC_ELT (args
, i
);
562 verbatim ("argument %qT", arg
);
564 verbatim ("argument %qE", arg
);
568 /* Associate each parameter in PARMS with its corresponding template
572 map_arguments (tree parms
, tree args
)
574 for (tree p
= parms
; p
; p
= TREE_CHAIN (p
))
579 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
580 TREE_PURPOSE (p
) = TMPL_ARG (args
, level
, index
);
583 TREE_PURPOSE (p
) = template_parm_to_arg (p
);
588 /* Build the parameter mapping for EXPR using ARGS, where CTX_PARMS
589 are the template parameters in scope for EXPR. */
592 build_parameter_mapping (tree expr
, tree args
, tree ctx_parms
)
594 tree parms
= find_template_parameters (expr
, ctx_parms
);
595 tree map
= map_arguments (parms
, args
);
599 /* True if the parameter mappings of two atomic constraints formed
600 from the same expression are equivalent. */
603 parameter_mapping_equivalent_p (tree t1
, tree t2
)
605 tree map1
= ATOMIC_CONSTR_MAP (t1
);
606 tree map2
= ATOMIC_CONSTR_MAP (t2
);
609 gcc_checking_assert (TREE_VALUE (map1
) == TREE_VALUE (map2
));
610 tree arg1
= TREE_PURPOSE (map1
);
611 tree arg2
= TREE_PURPOSE (map2
);
612 if (!template_args_equal (arg1
, arg2
))
614 map1
= TREE_CHAIN (map1
);
615 map2
= TREE_CHAIN (map2
);
617 gcc_checking_assert (!map1
&& !map2
);
621 /* Provides additional context for normalization. */
623 struct norm_info
: subst_info
625 explicit norm_info (tsubst_flags_t cmp
)
626 : norm_info (NULL_TREE
, cmp
)
629 /* Construct a top-level context for DECL. */
631 norm_info (tree in_decl
, tsubst_flags_t complain
)
632 : subst_info (tf_warning_or_error
| complain
, in_decl
)
636 initial_parms
= DECL_TEMPLATE_PARMS (in_decl
);
637 if (generate_diagnostics ())
638 context
= build_tree_list (NULL_TREE
, in_decl
);
641 initial_parms
= current_template_parms
;
644 bool generate_diagnostics() const
646 return complain
& tf_norm
;
649 void update_context(tree expr
, tree args
)
651 if (generate_diagnostics ())
653 tree map
= build_parameter_mapping (expr
, args
, ctx_parms ());
654 context
= tree_cons (map
, expr
, context
);
656 in_decl
= get_concept_check_template (expr
);
659 /* Returns the template parameters that are in scope for the current
660 normalization context. */
665 return DECL_TEMPLATE_PARMS (in_decl
);
667 return initial_parms
;
670 /* Provides information about the source of a constraint. This is a
671 TREE_LIST whose VALUE is either a concept check or a constrained
672 declaration. The PURPOSE, for concept checks is a parameter mapping
675 tree context
= NULL_TREE
;
677 /* The declaration whose constraints we're normalizing. The targets
678 of the parameter mapping of each atom will be in terms of the
679 template parameters of ORIG_DECL. */
681 tree initial_parms
= NULL_TREE
;
684 static tree
normalize_expression (tree
, tree
, norm_info
);
686 /* Transform a logical-or or logical-and expression into either
687 a conjunction or disjunction. */
690 normalize_logical_operation (tree t
, tree args
, tree_code c
, norm_info info
)
692 tree t0
= normalize_expression (TREE_OPERAND (t
, 0), args
, info
);
693 tree t1
= normalize_expression (TREE_OPERAND (t
, 1), args
, info
);
695 /* Build a new info object for the constraint. */
696 tree ci
= info
.generate_diagnostics()
697 ? build_tree_list (t
, info
.context
)
700 return build2 (c
, ci
, t0
, t1
);
703 /* Data types and hash functions for caching the normal form of a concept-id.
704 This essentially memoizes calls to normalize_concept_check. */
706 struct GTY((for_user
)) norm_entry
708 /* The CONCEPT_DECL of the concept-id. */
710 /* The arguments of the concept-id. */
712 /* The normal form of the concept-id. */
716 struct norm_hasher
: ggc_ptr_hash
<norm_entry
>
718 static hashval_t
hash (norm_entry
*e
)
720 ++comparing_specializations
;
721 hashval_t val
= iterative_hash_template_arg (e
->tmpl
, 0);
722 val
= iterative_hash_template_arg (e
->args
, val
);
723 --comparing_specializations
;
727 static bool equal (norm_entry
*e1
, norm_entry
*e2
)
729 ++comparing_specializations
;
730 bool eq
= e1
->tmpl
== e2
->tmpl
731 && template_args_equal (e1
->args
, e2
->args
);
732 --comparing_specializations
;
737 static GTY((deletable
)) hash_table
<norm_hasher
> *norm_cache
;
739 /* Normalize the concept check CHECK where ARGS are the
740 arguments to be substituted into CHECK's arguments. */
743 normalize_concept_check (tree check
, tree args
, norm_info info
)
745 tree id
= unpack_concept_check (check
);
746 tree tmpl
= TREE_OPERAND (id
, 0);
747 tree targs
= TREE_OPERAND (id
, 1);
749 /* A function concept is wrapped in an overload. */
750 if (TREE_CODE (tmpl
) == OVERLOAD
)
752 /* TODO: Can we diagnose this error during parsing? */
753 if (TREE_CODE (check
) == TEMPLATE_ID_EXPR
)
754 error_at (EXPR_LOC_OR_LOC (check
, input_location
),
755 "function concept must be called");
756 tmpl
= OVL_FIRST (tmpl
);
759 /* Substitute through the arguments of the concept check. */
761 targs
= tsubst_template_args (targs
, args
, info
.complain
, info
.in_decl
);
762 if (targs
== error_mark_node
)
763 return error_mark_node
;
764 if (template_args_equal (targs
, generic_targs_for (tmpl
)))
765 /* Canonicalize generic arguments as NULL_TREE, as an optimization. */
768 /* Build the substitution for the concept definition. */
769 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
771 /* As an optimization, coerce the arguments only if necessary
772 (i.e. if they were substituted). */
773 targs
= coerce_template_parms (parms
, targs
, tmpl
, tf_none
);
774 if (targs
== error_mark_node
)
775 return error_mark_node
;
778 norm_cache
= hash_table
<norm_hasher
>::create_ggc (31);
779 norm_entry
*entry
= nullptr;
780 if (!info
.generate_diagnostics ())
782 /* Cache the normal form of the substituted concept-id (when not
784 norm_entry elt
= {tmpl
, targs
, NULL_TREE
};
785 norm_entry
**slot
= norm_cache
->find_slot (&elt
, INSERT
);
787 return (*slot
)->norm
;
788 entry
= ggc_alloc
<norm_entry
> ();
793 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
794 info
.update_context (check
, args
);
795 tree norm
= normalize_expression (def
, targs
, info
);
801 /* Used by normalize_atom to cache ATOMIC_CONSTRs. */
803 static GTY((deletable
)) hash_table
<atom_hasher
> *atom_cache
;
805 /* The normal form of an atom depends on the expression. The normal
806 form of a function call to a function concept is a check constraint
807 for that concept. The normal form of a reference to a variable
808 concept is a check constraint for that concept. Otherwise, the
809 constraint is a predicate constraint. */
812 normalize_atom (tree t
, tree args
, norm_info info
)
814 /* Concept checks are not atomic. */
815 if (concept_check_p (t
))
816 return normalize_concept_check (t
, args
, info
);
818 /* Build the parameter mapping for the atom. */
819 tree map
= build_parameter_mapping (t
, args
, info
.ctx_parms ());
821 /* Build a new info object for the atom. */
822 tree ci
= build_tree_list (t
, info
.context
);
824 tree atom
= build1 (ATOMIC_CONSTR
, ci
, map
);
826 /* Remember whether the expression of this atomic constraint belongs to
827 a concept definition by inspecting in_decl, which should always be set
828 in this case either by norm_info::update_context (when recursing into a
829 concept-id during normalization) or by normalize_concept_definition
830 (when starting out with a concept-id). */
831 if (info
.in_decl
&& concept_definition_p (info
.in_decl
))
832 ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom
) = true;
834 if (!info
.generate_diagnostics ())
836 /* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
837 later can cheaply compare two atoms using just pointer equality. */
839 atom_cache
= hash_table
<atom_hasher
>::create_ggc (31);
840 tree
*slot
= atom_cache
->find_slot (atom
, INSERT
);
844 /* Find all template parameters used in the targets of the parameter
845 mapping, and store a list of them in the TREE_TYPE of the mapping.
846 This list will be used by sat_hasher to determine the subset of
847 supplied template arguments that the satisfaction value of the atom
851 tree targets
= make_tree_vec (list_length (map
));
853 for (tree node
= map
; node
; node
= TREE_CHAIN (node
))
855 tree target
= TREE_PURPOSE (node
);
856 TREE_VEC_ELT (targets
, i
++) = target
;
858 tree target_parms
= find_template_parameters (targets
,
860 TREE_TYPE (map
) = target_parms
;
868 /* Returns the normal form of an expression. */
871 normalize_expression (tree t
, tree args
, norm_info info
)
876 if (t
== error_mark_node
)
877 return error_mark_node
;
879 switch (TREE_CODE (t
))
881 case TRUTH_ANDIF_EXPR
:
882 return normalize_logical_operation (t
, args
, CONJ_CONSTR
, info
);
883 case TRUTH_ORIF_EXPR
:
884 return normalize_logical_operation (t
, args
, DISJ_CONSTR
, info
);
886 return normalize_atom (t
, args
, info
);
890 /* Cache of the normalized form of constraints. Marked as deletable because it
891 can all be recalculated. */
892 static GTY((deletable
)) hash_map
<tree
,tree
> *normalized_map
;
895 get_normalized_constraints (tree t
, norm_info info
)
897 auto_timevar
time (TV_CONSTRAINT_NORM
);
898 return normalize_expression (t
, NULL_TREE
, info
);
901 /* Returns the normalized constraints from a constraint-info object
902 or NULL_TREE if the constraints are null. IN_DECL provides the
903 declaration to which the constraints belong. */
906 get_normalized_constraints_from_info (tree ci
, tree in_decl
, bool diag
= false)
911 /* Substitution errors during normalization are fatal. */
912 ++processing_template_decl
;
913 norm_info
info (in_decl
, diag
? tf_norm
: tf_none
);
914 tree t
= get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci
), info
);
915 --processing_template_decl
;
920 /* Returns the normalized constraints for the declaration D. */
923 get_normalized_constraints_from_decl (tree d
, bool diag
= false)
928 /* For inherited constructors, consider the original declaration;
929 it has the correct template information attached. */
930 d
= strip_inheriting_ctors (d
);
932 if (regenerated_lambda_fn_p (d
))
934 /* If this lambda was regenerated, DECL_TEMPLATE_PARMS doesn't contain
935 all in-scope template parameters, but the lambda from which it was
936 ultimately regenerated does, so use that instead. */
937 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (d
));
938 lambda
= most_general_lambda (lambda
);
939 d
= lambda_function (lambda
);
942 if (TREE_CODE (d
) == TEMPLATE_DECL
)
945 decl
= DECL_TEMPLATE_RESULT (tmpl
);
949 if (tree ti
= DECL_TEMPLATE_INFO (d
))
950 tmpl
= TI_TEMPLATE (ti
);
956 /* Get the most general template for the declaration, and compute
957 arguments from that. This ensures that the arguments used for
958 normalization are always template parameters and not arguments
959 used for outer specializations. For example:
963 template<typename U> requires C<T, U> void f(U);
968 When we normalize the requirements for S<int>::f, we want the
969 arguments to be {T, U}, not {int, U}. One reason for this is that
970 accepting the latter causes the template parameter level of U
971 to be reduced in a way that makes it overly difficult substitute
972 concrete arguments (i.e., eventually {int, int} during satisfaction. */
975 if (DECL_LANG_SPECIFIC(tmpl
) && !DECL_TEMPLATE_SPECIALIZATION (tmpl
))
976 tmpl
= most_general_template (tmpl
);
979 d
= tmpl
? tmpl
: decl
;
981 /* If we're not diagnosing errors, use cached constraints, if any. */
983 if (tree
*p
= hash_map_safe_get (normalized_map
, d
))
986 tree norm
= NULL_TREE
;
987 if (tree ci
= get_constraints (d
))
989 push_access_scope_guard
pas (decl
);
990 norm
= get_normalized_constraints_from_info (ci
, tmpl
, diag
);
994 hash_map_safe_put
<hm_ggc
> (normalized_map
, d
, norm
);
999 /* Returns the normal form of TMPL's definition. */
1002 normalize_concept_definition (tree tmpl
, bool diag
)
1005 norm_cache
= hash_table
<norm_hasher
>::create_ggc (31);
1006 norm_entry entry
= {tmpl
, NULL_TREE
, NULL_TREE
};
1009 if (norm_entry
*found
= norm_cache
->find (&entry
))
1012 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1013 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
1014 ++processing_template_decl
;
1015 norm_info
info (tmpl
, diag
? tf_norm
: tf_none
);
1016 tree norm
= get_normalized_constraints (def
, info
);
1017 --processing_template_decl
;
1021 norm_entry
**slot
= norm_cache
->find_slot (&entry
, INSERT
);
1023 *slot
= ggc_alloc
<norm_entry
> ();
1030 /* Normalize an EXPR as a constraint. */
1033 normalize_constraint_expression (tree expr
, norm_info info
)
1035 if (!expr
|| expr
== error_mark_node
)
1038 if (!info
.generate_diagnostics ())
1039 if (tree
*p
= hash_map_safe_get (normalized_map
, expr
))
1042 ++processing_template_decl
;
1043 tree norm
= get_normalized_constraints (expr
, info
);
1044 --processing_template_decl
;
1046 if (!info
.generate_diagnostics ())
1047 hash_map_safe_put
<hm_ggc
> (normalized_map
, expr
, norm
);
1052 /* 17.4.1.2p2. Two constraints are identical if they are formed
1053 from the same expression and the targets of the parameter mapping
1057 atomic_constraints_identical_p (tree t1
, tree t2
)
1059 gcc_assert (TREE_CODE (t1
) == ATOMIC_CONSTR
);
1060 gcc_assert (TREE_CODE (t2
) == ATOMIC_CONSTR
);
1062 if (ATOMIC_CONSTR_EXPR (t1
) != ATOMIC_CONSTR_EXPR (t2
))
1065 if (!parameter_mapping_equivalent_p (t1
, t2
))
1071 /* True if T1 and T2 are equivalent, meaning they have the same syntactic
1072 structure and all corresponding constraints are identical. */
1075 constraints_equivalent_p (tree t1
, tree t2
)
1077 gcc_assert (CONSTR_P (t1
));
1078 gcc_assert (CONSTR_P (t2
));
1080 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1083 switch (TREE_CODE (t1
))
1087 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1089 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
1093 if (!atomic_constraints_identical_p(t1
, t2
))
1102 /* Compute the hash value for T. */
1105 hash_atomic_constraint (tree t
)
1107 gcc_assert (TREE_CODE (t
) == ATOMIC_CONSTR
);
1109 /* Hash the identity of the expression. */
1110 hashval_t val
= htab_hash_pointer (ATOMIC_CONSTR_EXPR (t
));
1112 /* Hash the targets of the parameter map. */
1113 tree p
= ATOMIC_CONSTR_MAP (t
);
1116 val
= iterative_hash_template_arg (TREE_PURPOSE (p
), val
);
1127 add_constraint (tree t
, hash
& h
)
1129 h
.add_int(TREE_CODE (t
));
1130 switch (TREE_CODE (t
))
1134 add_constraint (TREE_OPERAND (t
, 0), h
);
1135 add_constraint (TREE_OPERAND (t
, 1), h
);
1138 h
.merge_hash (hash_atomic_constraint (t
));
1147 /* Computes a hash code for the constraint T. */
1150 iterative_hash_constraint (tree t
, hashval_t val
)
1152 gcc_assert (CONSTR_P (t
));
1153 inchash::hash
h (val
);
1154 inchash::add_constraint (t
, h
);
1158 // -------------------------------------------------------------------------- //
1159 // Constraint Semantic Processing
1161 // The following functions are called by the parser and substitution rules
1162 // to create and evaluate constraint-related nodes.
1164 // The constraints associated with the current template parameters.
1166 current_template_constraints (void)
1168 if (!current_template_parms
)
1170 tree tmpl_constr
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
1171 return build_constraints (tmpl_constr
, NULL_TREE
);
1174 /* If the recently parsed TYPE declares or defines a template or
1175 template specialization, get its corresponding constraints from the
1176 current template parameters and bind them to TYPE's declaration. */
1179 associate_classtype_constraints (tree type
)
1181 if (!type
|| type
== error_mark_node
|| !CLASS_TYPE_P (type
))
1184 /* An explicit class template specialization has no template parameters. */
1185 if (!current_template_parms
)
1188 if (CLASSTYPE_IS_TEMPLATE (type
) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1190 tree decl
= TYPE_STUB_DECL (type
);
1191 tree ci
= current_template_constraints ();
1193 /* An implicitly instantiated member template declaration already
1194 has associated constraints. If it is defined outside of its
1195 class, then we need match these constraints against those of
1196 original declaration. */
1197 if (tree orig_ci
= get_constraints (decl
))
1199 if (int extra_levels
= (TMPL_PARMS_DEPTH (current_template_parms
)
1200 - TMPL_ARGS_DEPTH (TYPE_TI_ARGS (type
))))
1202 /* If there is a discrepancy between the current template depth
1203 and the template depth of the original declaration, then we
1204 must be redeclaring a class template as part of a friend
1205 declaration within another class template. Before matching
1206 constraints, we need to reduce the template parameter level
1207 within the current constraints via substitution. */
1208 tree outer_gtargs
= template_parms_to_args (current_template_parms
);
1209 TREE_VEC_LENGTH (outer_gtargs
) = extra_levels
;
1210 ci
= tsubst_constraint_info (ci
, outer_gtargs
, tf_none
, NULL_TREE
);
1212 if (!equivalent_constraints (ci
, orig_ci
))
1214 error ("%qT does not match original declaration", type
);
1215 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1216 location_t loc
= DECL_SOURCE_LOCATION (tmpl
);
1217 inform (loc
, "original template declaration here");
1218 /* Fall through, so that we define the type anyway. */
1222 set_constraints (decl
, ci
);
1227 /* Create an empty constraint info block. */
1229 static inline tree_constraint_info
*
1230 build_constraint_info ()
1232 return (tree_constraint_info
*)make_node (CONSTRAINT_INFO
);
1235 /* Build a constraint-info object that contains the associated constraints
1236 of a declaration. This also includes the declaration's template
1237 requirements (TREQS) and any trailing requirements for a function
1238 declarator (DREQS). Note that both TREQS and DREQS must be constraints.
1240 If the declaration has neither template nor declaration requirements
1241 this returns NULL_TREE, indicating an unconstrained declaration. */
1244 build_constraints (tree tr
, tree dr
)
1249 tree_constraint_info
* ci
= build_constraint_info ();
1250 ci
->template_reqs
= tr
;
1251 ci
->declarator_reqs
= dr
;
1252 ci
->associated_constr
= combine_constraint_expressions (tr
, dr
);
1257 /* Add constraint RHS to the end of CONSTRAINT_INFO ci. */
1260 append_constraint (tree ci
, tree rhs
)
1262 tree tr
= ci
? CI_TEMPLATE_REQS (ci
) : NULL_TREE
;
1263 tree dr
= ci
? CI_DECLARATOR_REQS (ci
) : NULL_TREE
;
1264 dr
= combine_constraint_expressions (dr
, rhs
);
1267 CI_DECLARATOR_REQS (ci
) = dr
;
1268 tree ac
= combine_constraint_expressions (tr
, dr
);
1269 CI_ASSOCIATED_CONSTRAINTS (ci
) = ac
;
1272 ci
= build_constraints (tr
, dr
);
1276 /* A mapping from declarations to constraint information. */
1278 static GTY ((cache
)) decl_tree_cache_map
*decl_constraints
;
1280 /* Returns the template constraints of declaration T. If T is not
1281 constrained, return NULL_TREE. Note that T must be non-null. */
1284 get_constraints (const_tree t
)
1288 if (!decl_constraints
)
1291 gcc_assert (DECL_P (t
));
1292 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1293 t
= DECL_TEMPLATE_RESULT (t
);
1294 tree
* found
= decl_constraints
->get (CONST_CAST_TREE (t
));
1301 /* Associate the given constraint information CI with the declaration
1302 T. If T is a template, then the constraints are associated with
1303 its underlying declaration. Don't build associations if CI is
1307 set_constraints (tree t
, tree ci
)
1311 gcc_assert (t
&& flag_concepts
);
1312 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1313 t
= DECL_TEMPLATE_RESULT (t
);
1314 bool found
= hash_map_safe_put
<hm_ggc
> (decl_constraints
, t
, ci
);
1315 gcc_assert (!found
);
1318 /* Remove the associated constraints of the declaration T. */
1321 remove_constraints (tree t
)
1323 gcc_checking_assert (DECL_P (t
));
1324 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1325 t
= DECL_TEMPLATE_RESULT (t
);
1327 if (decl_constraints
)
1328 decl_constraints
->remove (t
);
1331 /* If DECL is a friend, substitute into REQS to produce requirements suitable
1332 for declaration matching. */
1335 maybe_substitute_reqs_for (tree reqs
, const_tree decl
)
1337 if (reqs
== NULL_TREE
)
1340 decl
= STRIP_TEMPLATE (decl
);
1341 if (DECL_UNIQUE_FRIEND_P (decl
) && DECL_TEMPLATE_INFO (decl
))
1343 tree tmpl
= DECL_TI_TEMPLATE (decl
);
1344 tree outer_args
= outer_template_args (decl
);
1345 processing_template_decl_sentinel s
;
1346 if (PRIMARY_TEMPLATE_P (tmpl
)
1347 || uses_template_parms (outer_args
))
1348 ++processing_template_decl
;
1349 reqs
= tsubst_constraint (reqs
, outer_args
,
1350 tf_warning_or_error
, NULL_TREE
);
1355 /* Returns the trailing requires clause of the declarator of
1356 a template declaration T or NULL_TREE if none. */
1359 get_trailing_function_requirements (tree t
)
1361 tree ci
= get_constraints (t
);
1364 return CI_DECLARATOR_REQS (ci
);
1367 /* Construct a sequence of template arguments by prepending
1368 ARG to REST. Either ARG or REST may be null. */
1370 build_concept_check_arguments (tree arg
, tree rest
)
1372 gcc_assert (rest
? TREE_CODE (rest
) == TREE_VEC
: true);
1376 int n
= rest
? TREE_VEC_LENGTH (rest
) : 0;
1377 args
= make_tree_vec (n
+ 1);
1378 TREE_VEC_ELT (args
, 0) = arg
;
1380 for (int i
= 0; i
< n
; ++i
)
1381 TREE_VEC_ELT (args
, i
+ 1) = TREE_VEC_ELT (rest
, i
);
1382 int def
= rest
? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest
) : 0;
1383 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, def
+ 1);
1392 /* Builds an id-expression of the form `C<Args...>()` where C is a function
1396 build_function_check (tree tmpl
, tree args
, tsubst_flags_t
/*complain*/)
1398 if (TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1400 /* If we just got a template, wrap it in an overload so it looks like any
1401 other template-id. */
1402 tmpl
= ovl_make (tmpl
);
1403 TREE_TYPE (tmpl
) = boolean_type_node
;
1406 /* Perform function concept resolution now so we always have a single
1407 function of the overload set (even if we started with only one; the
1408 resolution function converts template arguments). Note that we still
1409 wrap this in an overload set so we don't upset other parts of the
1410 compiler that expect template-ids referring to function concepts
1411 to have an overload set. */
1412 tree info
= resolve_function_concept_overload (tmpl
, args
);
1413 if (info
== error_mark_node
)
1414 return error_mark_node
;
1417 error ("no matching concepts for %qE", tmpl
);
1418 return error_mark_node
;
1420 args
= TREE_PURPOSE (info
);
1421 tmpl
= DECL_TI_TEMPLATE (TREE_VALUE (info
));
1423 /* Rebuild the singleton overload set; mark the type bool. */
1424 tmpl
= ovl_make (tmpl
, NULL_TREE
);
1425 TREE_TYPE (tmpl
) = boolean_type_node
;
1427 /* Build the id-expression around the overload set. */
1428 tree id
= build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1430 /* Finally, build the call expression around the overload. */
1431 ++processing_template_decl
;
1432 vec
<tree
, va_gc
> *fargs
= make_tree_vector ();
1433 tree call
= build_min_nt_call_vec (id
, fargs
);
1434 TREE_TYPE (call
) = boolean_type_node
;
1435 release_tree_vector (fargs
);
1436 --processing_template_decl
;
1441 /* Builds an id-expression of the form `C<Args...>` where C is a variable
1445 build_variable_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1447 gcc_assert (variable_concept_p (tmpl
));
1448 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1449 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1450 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1451 if (args
== error_mark_node
)
1452 return error_mark_node
;
1453 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1456 /* Builds an id-expression of the form `C<Args...>` where C is a standard
1460 build_standard_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1462 gcc_assert (standard_concept_p (tmpl
));
1463 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1464 if (TREE_DEPRECATED (DECL_TEMPLATE_RESULT (tmpl
)))
1465 warn_deprecated_use (DECL_TEMPLATE_RESULT (tmpl
), NULL_TREE
);
1466 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1467 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1468 if (args
== error_mark_node
)
1469 return error_mark_node
;
1470 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1473 /* Construct an expression that checks TARGET using ARGS. */
1476 build_concept_check (tree target
, tree args
, tsubst_flags_t complain
)
1478 return build_concept_check (target
, NULL_TREE
, args
, complain
);
1481 /* Construct an expression that checks the concept given by DECL. If
1482 concept_definition_p (DECL) is false, this returns null. */
1485 build_concept_check (tree decl
, tree arg
, tree rest
, tsubst_flags_t complain
)
1487 tree args
= build_concept_check_arguments (arg
, rest
);
1489 if (standard_concept_p (decl
))
1490 return build_standard_check (decl
, args
, complain
);
1491 if (variable_concept_p (decl
))
1492 return build_variable_check (decl
, args
, complain
);
1493 if (function_concept_p (decl
))
1494 return build_function_check (decl
, args
, complain
);
1496 return error_mark_node
;
1499 /* Build a template-id that can participate in a concept check. */
1502 build_concept_id (tree decl
, tree args
)
1504 tree check
= build_concept_check (decl
, args
, tf_warning_or_error
);
1505 if (check
== error_mark_node
)
1506 return error_mark_node
;
1507 return unpack_concept_check (check
);
1510 /* Build a template-id that can participate in a concept check, preserving
1511 the source location of the original template-id. */
1514 build_concept_id (tree expr
)
1516 gcc_assert (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
);
1517 tree id
= build_concept_id (TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
1518 protected_set_expr_location (id
, cp_expr_location (expr
));
1522 /* Build as template-id with a placeholder that can be used as a
1525 Note that this will diagnose errors if the initial concept check
1529 build_type_constraint (tree decl
, tree args
, tsubst_flags_t complain
)
1531 tree wildcard
= build_nt (WILDCARD_DECL
);
1532 ++processing_template_decl
;
1533 tree check
= build_concept_check (decl
, wildcard
, args
, complain
);
1534 --processing_template_decl
;
1535 if (check
== error_mark_node
)
1536 return error_mark_node
;
1537 return unpack_concept_check (check
);
1540 /* Returns a TYPE_DECL that contains sufficient information to
1541 build a template parameter of the same kind as PROTO and
1542 constrained by the concept declaration CNC. Note that PROTO
1543 is the first template parameter of CNC.
1545 If specified, ARGS provides additional arguments to the
1546 constraint check. */
1548 build_constrained_parameter (tree cnc
, tree proto
, tree args
)
1550 tree name
= DECL_NAME (cnc
);
1551 tree type
= TREE_TYPE (proto
);
1552 tree decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
1553 CONSTRAINED_PARM_PROTOTYPE (decl
) = proto
;
1554 CONSTRAINED_PARM_CONCEPT (decl
) = cnc
;
1555 CONSTRAINED_PARM_EXTRA_ARGS (decl
) = args
;
1559 /* Create a constraint expression for the given DECL that evaluates the
1560 requirements specified by CONSTR, a TYPE_DECL that contains all the
1561 information necessary to build the requirements (see finish_concept_name
1562 for the layout of that TYPE_DECL).
1564 Note that the constraints are neither reduced nor decomposed. That is
1565 done only after the requires clause has been parsed (or not). */
1568 finish_shorthand_constraint (tree decl
, tree constr
)
1570 /* No requirements means no constraints. */
1574 if (error_operand_p (constr
))
1577 tree proto
= CONSTRAINED_PARM_PROTOTYPE (constr
);
1578 tree con
= CONSTRAINED_PARM_CONCEPT (constr
);
1579 tree args
= CONSTRAINED_PARM_EXTRA_ARGS (constr
);
1581 /* The TS lets use shorthand to constrain a pack of arguments, but the
1584 For the TS, consider:
1586 template<C... Ts> struct s;
1588 If C is variadic (and because Ts is a pack), we associate the
1589 constraint C<Ts...>. In all other cases, we associate
1590 the constraint (C<Ts> && ...).
1592 The standard behavior cannot be overridden by -fconcepts-ts. */
1593 bool variadic_concept_p
= template_parameter_pack_p (proto
);
1594 bool declared_pack_p
= template_parameter_pack_p (decl
);
1595 bool apply_to_each_p
= (cxx_dialect
>= cxx20
) ? true : !variadic_concept_p
;
1597 /* Get the argument and overload used for the requirement
1598 and adjust it if we're going to expand later. */
1599 tree arg
= template_parm_to_arg (decl
);
1600 if (apply_to_each_p
&& declared_pack_p
)
1601 arg
= PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0));
1603 /* Build the concept constraint-expression. */
1604 tree tmpl
= DECL_TI_TEMPLATE (con
);
1606 if (TREE_CODE (con
) == FUNCTION_DECL
)
1607 check
= ovl_make (tmpl
);
1608 check
= build_concept_check (check
, arg
, args
, tf_warning_or_error
);
1610 /* Make the check a fold-expression if needed.
1611 Use UNKNOWN_LOCATION so write_template_args can tell the
1612 difference between this and a fold the user wrote. */
1613 if (apply_to_each_p
&& declared_pack_p
)
1614 check
= finish_left_unary_fold_expr (UNKNOWN_LOCATION
,
1615 check
, TRUTH_ANDIF_EXPR
);
1620 /* Returns a conjunction of shorthand requirements for the template
1621 parameter list PARMS. Note that the requirements are stored in
1622 the TYPE of each tree node. */
1625 get_shorthand_constraints (tree parms
)
1627 tree result
= NULL_TREE
;
1628 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1629 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
1631 tree parm
= TREE_VEC_ELT (parms
, i
);
1632 tree constr
= TEMPLATE_PARM_CONSTRAINTS (parm
);
1633 result
= combine_constraint_expressions (result
, constr
);
1638 /* Get the deduced wildcard from a DEDUCED placeholder. If the deduced
1639 wildcard is a pack, return the first argument of that pack. */
1642 get_deduced_wildcard (tree wildcard
)
1644 if (ARGUMENT_PACK_P (wildcard
))
1645 wildcard
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard
), 0);
1646 gcc_assert (TREE_CODE (wildcard
) == WILDCARD_DECL
);
1650 /* Returns the prototype parameter for the nth deduced wildcard. */
1653 get_introduction_prototype (tree wildcards
, int index
)
1655 return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards
, index
)));
1658 /* Introduce a type template parameter. */
1661 introduce_type_template_parameter (tree wildcard
, bool& non_type_p
)
1664 return finish_template_type_parm (class_type_node
, DECL_NAME (wildcard
));
1667 /* Introduce a template template parameter. */
1670 introduce_template_template_parameter (tree wildcard
, bool& non_type_p
)
1673 begin_template_parm_list ();
1674 current_template_parms
= DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard
));
1675 end_template_parm_list ();
1676 return finish_template_template_parm (class_type_node
, DECL_NAME (wildcard
));
1679 /* Introduce a template non-type parameter. */
1682 introduce_nontype_template_parameter (tree wildcard
, bool& non_type_p
)
1685 tree parm
= copy_decl (TREE_TYPE (wildcard
));
1686 DECL_NAME (parm
) = DECL_NAME (wildcard
);
1690 /* Introduce a single template parameter. */
1693 build_introduced_template_parameter (tree wildcard
, bool& non_type_p
)
1695 tree proto
= TREE_TYPE (wildcard
);
1698 if (TREE_CODE (proto
) == TYPE_DECL
)
1699 parm
= introduce_type_template_parameter (wildcard
, non_type_p
);
1700 else if (TREE_CODE (proto
) == TEMPLATE_DECL
)
1701 parm
= introduce_template_template_parameter (wildcard
, non_type_p
);
1703 parm
= introduce_nontype_template_parameter (wildcard
, non_type_p
);
1705 /* Wrap in a TREE_LIST for process_template_parm. Note that introduced
1706 parameters do not retain the defaults from the source parameter. */
1707 return build_tree_list (NULL_TREE
, parm
);
1710 /* Introduce a single template parameter. */
1713 introduce_template_parameter (tree parms
, tree wildcard
)
1715 gcc_assert (!ARGUMENT_PACK_P (wildcard
));
1716 tree proto
= TREE_TYPE (wildcard
);
1717 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1719 /* Diagnose the case where we have C{...Args}. */
1720 if (WILDCARD_PACK_P (wildcard
))
1722 tree id
= DECL_NAME (wildcard
);
1723 error_at (loc
, "%qE cannot be introduced with an ellipsis %<...%>", id
);
1724 inform (DECL_SOURCE_LOCATION (proto
), "prototype declared here");
1728 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1729 return process_template_parm (parms
, loc
, parm
, non_type_p
, false);
1732 /* Introduce a template parameter pack. */
1735 introduce_template_parameter_pack (tree parms
, tree wildcard
)
1738 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1739 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1740 return process_template_parm (parms
, loc
, parm
, non_type_p
, true);
1743 /* Introduce the nth template parameter. */
1746 introduce_template_parameter (tree parms
, tree wildcards
, int& index
)
1748 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1749 return introduce_template_parameter (parms
, deduced
);
1752 /* Introduce either a template parameter pack or a list of template
1756 introduce_template_parameters (tree parms
, tree wildcards
, int& index
)
1758 /* If the prototype was a parameter, we better have deduced an
1759 argument pack, and that argument must be the last deduced value
1760 in the wildcard vector. */
1761 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1762 gcc_assert (ARGUMENT_PACK_P (deduced
));
1763 gcc_assert (index
== TREE_VEC_LENGTH (wildcards
));
1765 /* Introduce each element in the pack. */
1766 tree args
= ARGUMENT_PACK_ARGS (deduced
);
1767 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1769 tree arg
= TREE_VEC_ELT (args
, i
);
1770 if (WILDCARD_PACK_P (arg
))
1771 parms
= introduce_template_parameter_pack (parms
, arg
);
1773 parms
= introduce_template_parameter (parms
, arg
);
1779 /* Builds the template parameter list PARMS by chaining introduced
1780 parameters from the WILDCARD vector. INDEX is the position of
1781 the current parameter. */
1784 process_introduction_parms (tree parms
, tree wildcards
, int& index
)
1786 tree proto
= get_introduction_prototype (wildcards
, index
);
1787 if (template_parameter_pack_p (proto
))
1788 return introduce_template_parameters (parms
, wildcards
, index
);
1790 return introduce_template_parameter (parms
, wildcards
, index
);
1793 /* Ensure that all template parameters have been introduced for the concept
1794 named in CHECK. If not, emit a diagnostic.
1796 Note that implicitly introducing a parameter with a default argument
1797 creates a case where a parameter is declared, but unnamed, making
1798 it unusable in the definition. */
1801 check_introduction_list (tree intros
, tree check
)
1803 check
= unpack_concept_check (check
);
1804 tree tmpl
= TREE_OPERAND (check
, 0);
1806 tmpl
= OVL_FIRST (tmpl
);
1808 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
1809 if (TREE_VEC_LENGTH (intros
) < TREE_VEC_LENGTH (parms
))
1811 error_at (input_location
, "all template parameters of %qD must "
1812 "be introduced", tmpl
);
1819 /* Associates a constraint check to the current template based on the
1820 introduction parameters. INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs
1821 containing a chained PARM_DECL which contains the identifier as well as
1822 the source location. TMPL_DECL is the decl for the concept being used.
1823 If we take a concept, C, this will form a check in the form of
1824 C<INTRO_LIST> filling in any extra arguments needed by the defaults
1827 Returns NULL_TREE if no concept could be matched and error_mark_node if
1828 an error occurred when matching. */
1831 finish_template_introduction (tree tmpl_decl
,
1833 location_t intro_loc
)
1835 /* Build a concept check to deduce the actual parameters. */
1836 tree expr
= build_concept_check (tmpl_decl
, intro_list
, tf_none
);
1837 if (expr
== error_mark_node
)
1839 error_at (intro_loc
, "cannot deduce template parameters from "
1840 "introduction list");
1841 return error_mark_node
;
1844 if (!check_introduction_list (intro_list
, expr
))
1845 return error_mark_node
;
1847 tree parms
= deduce_concept_introduction (expr
);
1851 /* Build template parameter scope for introduction. */
1852 tree parm_list
= NULL_TREE
;
1853 begin_template_parm_list ();
1854 int nargs
= MIN (TREE_VEC_LENGTH (parms
), TREE_VEC_LENGTH (intro_list
));
1855 for (int n
= 0; n
< nargs
; )
1856 parm_list
= process_introduction_parms (parm_list
, parms
, n
);
1857 parm_list
= end_template_parm_list (parm_list
);
1859 /* Update the number of arguments to reflect the number of deduced
1860 template parameter introductions. */
1861 nargs
= TREE_VEC_LENGTH (parm_list
);
1863 /* Determine if any errors occurred during matching. */
1864 for (int i
= 0; i
< TREE_VEC_LENGTH (parm_list
); ++i
)
1865 if (TREE_VALUE (TREE_VEC_ELT (parm_list
, i
)) == error_mark_node
)
1867 end_template_decl ();
1868 return error_mark_node
;
1871 /* Build a concept check for our constraint. */
1872 tree check_args
= make_tree_vec (nargs
);
1874 for (; n
< TREE_VEC_LENGTH (parm_list
); ++n
)
1876 tree parm
= TREE_VEC_ELT (parm_list
, n
);
1877 TREE_VEC_ELT (check_args
, n
) = template_parm_to_arg (parm
);
1879 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args
, n
);
1881 /* If the template expects more parameters we should be able
1882 to use the defaults from our deduced concept. */
1883 for (; n
< TREE_VEC_LENGTH (parms
); ++n
)
1884 TREE_VEC_ELT (check_args
, n
) = TREE_VEC_ELT (parms
, n
);
1886 /* Associate the constraint. */
1887 tree check
= build_concept_check (tmpl_decl
,
1889 tf_warning_or_error
);
1890 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
) = check
;
1896 /* Given the concept check T from a constrained-type-specifier, extract
1897 its TMPL and ARGS. FIXME why do we need two different forms of
1898 constrained-type-specifier? */
1901 placeholder_extract_concept_and_args (tree t
, tree
&tmpl
, tree
&args
)
1903 if (concept_check_p (t
))
1905 t
= unpack_concept_check (t
);
1906 tmpl
= TREE_OPERAND (t
, 0);
1907 if (TREE_CODE (tmpl
) == OVERLOAD
)
1908 tmpl
= OVL_FIRST (tmpl
);
1909 args
= TREE_OPERAND (t
, 1);
1913 if (TREE_CODE (t
) == TYPE_DECL
)
1915 /* A constrained parameter. Build a constraint check
1916 based on the prototype parameter and then extract the
1917 arguments from that. */
1918 tree proto
= CONSTRAINED_PARM_PROTOTYPE (t
);
1919 tree check
= finish_shorthand_constraint (proto
, t
);
1920 placeholder_extract_concept_and_args (check
, tmpl
, args
);
1925 /* Returns true iff the placeholders C1 and C2 are equivalent. C1
1926 and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */
1929 equivalent_placeholder_constraints (tree c1
, tree c2
)
1931 if (c1
&& TREE_CODE (c1
) == TEMPLATE_TYPE_PARM
)
1932 /* A constrained auto. */
1933 c1
= PLACEHOLDER_TYPE_CONSTRAINTS (c1
);
1934 if (c2
&& TREE_CODE (c2
) == TEMPLATE_TYPE_PARM
)
1935 c2
= PLACEHOLDER_TYPE_CONSTRAINTS (c2
);
1941 if (c1
== error_mark_node
|| c2
== error_mark_node
)
1942 /* We get here during satisfaction; when a deduction constraint
1943 fails, substitution can produce an error_mark_node for the
1944 placeholder constraints. */
1947 tree t1
, t2
, a1
, a2
;
1948 placeholder_extract_concept_and_args (c1
, t1
, a1
);
1949 placeholder_extract_concept_and_args (c2
, t2
, a2
);
1954 int len1
= TREE_VEC_LENGTH (a1
);
1955 int len2
= TREE_VEC_LENGTH (a2
);
1959 /* Skip the first argument so we don't infinitely recurse.
1960 Also, they may differ in template parameter index. */
1961 for (int i
= 1; i
< len1
; ++i
)
1963 tree t1
= TREE_VEC_ELT (a1
, i
);
1964 tree t2
= TREE_VEC_ELT (a2
, i
);
1965 if (!template_args_equal (t1
, t2
))
1971 /* Return a hash value for the placeholder ATOMIC_CONSTR C. */
1974 hash_placeholder_constraint (tree c
)
1977 placeholder_extract_concept_and_args (c
, t
, a
);
1979 /* Like hash_tmpl_and_args, but skip the first argument. */
1980 hashval_t val
= iterative_hash_object (DECL_UID (t
), 0);
1982 for (int i
= TREE_VEC_LENGTH (a
)-1; i
> 0; --i
)
1983 val
= iterative_hash_template_arg (TREE_VEC_ELT (a
, i
), val
);
1988 /* Substitute through the expression of a simple requirement or
1989 compound requirement. */
1992 tsubst_valid_expression_requirement (tree t
, tree args
, sat_info info
)
1994 tree r
= tsubst_expr (t
, args
, tf_none
, info
.in_decl
);
1995 if (convert_to_void (r
, ICV_STATEMENT
, tf_none
) != error_mark_node
)
1998 if (info
.diagnose_unsatisfaction_p ())
2000 location_t loc
= cp_expr_loc_or_input_loc (t
);
2001 if (diagnosing_failed_constraint::replay_errors_p ())
2003 inform (loc
, "the required expression %qE is invalid, because", t
);
2004 if (r
== error_mark_node
)
2005 tsubst_expr (t
, args
, info
.complain
, info
.in_decl
);
2007 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
2010 inform (loc
, "the required expression %qE is invalid", t
);
2012 else if (info
.noisy ())
2014 r
= tsubst_expr (t
, args
, info
.complain
, info
.in_decl
);
2015 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
2018 return error_mark_node
;
2022 /* Substitute through the simple requirement. */
2025 tsubst_simple_requirement (tree t
, tree args
, sat_info info
)
2027 tree t0
= TREE_OPERAND (t
, 0);
2028 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
2029 if (expr
== error_mark_node
)
2030 return error_mark_node
;
2031 return boolean_true_node
;
2034 /* Subroutine of tsubst_type_requirement that performs the actual substitution
2035 and diagnosing. Also used by tsubst_compound_requirement. */
2038 tsubst_type_requirement_1 (tree t
, tree args
, sat_info info
, location_t loc
)
2040 tree r
= tsubst (t
, args
, tf_none
, info
.in_decl
);
2041 if (r
!= error_mark_node
)
2044 if (info
.diagnose_unsatisfaction_p ())
2046 if (diagnosing_failed_constraint::replay_errors_p ())
2048 /* Replay the substitution error. */
2049 inform (loc
, "the required type %qT is invalid, because", t
);
2050 tsubst (t
, args
, info
.complain
, info
.in_decl
);
2053 inform (loc
, "the required type %qT is invalid", t
);
2055 else if (info
.noisy ())
2056 tsubst (t
, args
, info
.complain
, info
.in_decl
);
2058 return error_mark_node
;
2062 /* Substitute through the type requirement. */
2065 tsubst_type_requirement (tree t
, tree args
, sat_info info
)
2067 tree t0
= TREE_OPERAND (t
, 0);
2068 tree type
= tsubst_type_requirement_1 (t0
, args
, info
, EXPR_LOCATION (t
));
2069 if (type
== error_mark_node
)
2070 return error_mark_node
;
2071 return boolean_true_node
;
2074 /* True if TYPE can be deduced from EXPR. */
2077 type_deducible_p (tree expr
, tree type
, tree placeholder
, tree args
,
2080 /* Make sure deduction is performed against ( EXPR ), so that
2081 references are preserved in the result. */
2082 expr
= force_paren_expr_uneval (expr
);
2084 tree deduced_type
= do_auto_deduction (type
, expr
, placeholder
,
2085 info
.complain
, adc_requirement
,
2086 /*outer_targs=*/args
);
2088 return deduced_type
!= error_mark_node
;
2091 /* True if EXPR can not be converted to TYPE. */
2094 expression_convertible_p (tree expr
, tree type
, subst_info info
)
2097 perform_direct_initialization_if_possible (type
, expr
, false,
2099 if (conv
== error_mark_node
)
2101 if (conv
== NULL_TREE
)
2103 if (info
.complain
& tf_error
)
2105 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
2106 error_at (loc
, "cannot convert %qE to %qT", expr
, type
);
2114 /* Substitute through the compound requirement. */
2117 tsubst_compound_requirement (tree t
, tree args
, sat_info info
)
2119 tree t0
= TREE_OPERAND (t
, 0);
2120 tree t1
= TREE_OPERAND (t
, 1);
2121 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
2122 if (expr
== error_mark_node
)
2123 return error_mark_node
;
2125 location_t loc
= cp_expr_loc_or_input_loc (expr
);
2127 /* Check the noexcept condition. */
2128 bool noexcept_p
= COMPOUND_REQ_NOEXCEPT_P (t
);
2129 if (noexcept_p
&& !expr_noexcept_p (expr
, tf_none
))
2131 if (info
.diagnose_unsatisfaction_p ())
2132 inform (loc
, "%qE is not %<noexcept%>", expr
);
2134 return error_mark_node
;
2137 /* Substitute through the type expression, if any. */
2138 tree type
= tsubst_type_requirement_1 (t1
, args
, info
, EXPR_LOCATION (t
));
2139 if (type
== error_mark_node
)
2140 return error_mark_node
;
2142 subst_info
quiet (tf_none
, info
.in_decl
);
2144 /* Check expression against the result type. */
2147 if (tree placeholder
= type_uses_auto (type
))
2149 if (!type_deducible_p (expr
, type
, placeholder
, args
, quiet
))
2151 if (info
.diagnose_unsatisfaction_p ())
2153 if (diagnosing_failed_constraint::replay_errors_p ())
2156 "%qE does not satisfy return-type-requirement, "
2158 /* Further explain the reason for the error. */
2159 type_deducible_p (expr
, type
, placeholder
, args
, info
);
2163 "%qE does not satisfy return-type-requirement", t0
);
2165 return error_mark_node
;
2168 else if (!expression_convertible_p (expr
, type
, quiet
))
2170 if (info
.diagnose_unsatisfaction_p ())
2172 if (diagnosing_failed_constraint::replay_errors_p ())
2174 inform (loc
, "cannot convert %qE to %qT because", t0
, type
);
2175 /* Further explain the reason for the error. */
2176 expression_convertible_p (expr
, type
, info
);
2179 inform (loc
, "cannot convert %qE to %qT", t0
, type
);
2181 return error_mark_node
;
2185 return boolean_true_node
;
2188 /* Substitute through the nested requirement. */
2191 tsubst_nested_requirement (tree t
, tree args
, sat_info info
)
2193 sat_info
quiet (tf_none
, info
.in_decl
);
2194 tree result
= constraint_satisfaction_value (t
, args
, quiet
);
2195 if (result
== boolean_true_node
)
2196 return boolean_true_node
;
2198 if (result
== boolean_false_node
2199 && info
.diagnose_unsatisfaction_p ())
2201 tree expr
= TREE_OPERAND (t
, 0);
2202 location_t loc
= cp_expr_location (t
);
2203 if (diagnosing_failed_constraint::replay_errors_p ())
2205 /* Replay the substitution error. */
2206 inform (loc
, "nested requirement %qE is not satisfied, because", expr
);
2207 constraint_satisfaction_value (t
, args
, info
);
2210 inform (loc
, "nested requirement %qE is not satisfied", expr
);
2213 return error_mark_node
;
2216 /* Substitute ARGS into the requirement T. */
2219 tsubst_requirement (tree t
, tree args
, sat_info info
)
2221 iloc_sentinel
loc_s (cp_expr_location (t
));
2222 switch (TREE_CODE (t
))
2225 return tsubst_simple_requirement (t
, args
, info
);
2227 return tsubst_type_requirement (t
, args
, info
);
2229 return tsubst_compound_requirement (t
, args
, info
);
2231 return tsubst_nested_requirement (t
, args
, info
);
2239 declare_constraint_vars (tree parms
, tree vars
)
2242 for (tree t
= parms
; t
; t
= DECL_CHAIN (t
))
2244 if (DECL_PACK_P (t
))
2246 tree pack
= extract_fnparm_pack (t
, &s
);
2247 register_local_specialization (pack
, t
);
2251 register_local_specialization (s
, t
);
2258 /* Substitute through as if checking function parameter types. This
2259 will diagnose common parameter type errors. Returns error_mark_node
2260 if an error occurred. */
2263 check_constraint_variables (tree t
, tree args
, subst_info info
)
2265 tree types
= NULL_TREE
;
2267 while (p
&& !VOID_TYPE_P (p
))
2269 types
= tree_cons (NULL_TREE
, TREE_TYPE (p
), types
);
2272 types
= chainon (nreverse (types
), void_list_node
);
2273 return tsubst_function_parms (types
, args
, info
.complain
, info
.in_decl
);
2276 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
2277 into the parameter list T, producing a sequence of constraint
2278 variables, declared in the current scope.
2280 Note that the caller must establish a local specialization stack
2281 prior to calling this function since this substitution will
2282 declare the substituted parameters. */
2285 tsubst_constraint_variables (tree t
, tree args
, subst_info info
)
2287 /* Perform a trial substitution to check for type errors. */
2288 tree parms
= check_constraint_variables (t
, args
, info
);
2289 if (parms
== error_mark_node
)
2290 return error_mark_node
;
2292 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
2294 int saved_unevaluated_operand
= cp_unevaluated_operand
;
2295 cp_unevaluated_operand
= 0;
2296 tree vars
= tsubst (t
, args
, info
.complain
, info
.in_decl
);
2297 cp_unevaluated_operand
= saved_unevaluated_operand
;
2298 if (vars
== error_mark_node
)
2299 return error_mark_node
;
2300 return declare_constraint_vars (t
, vars
);
2303 /* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
2304 substitution of template arguments into a requires-expression
2305 may result in the formation of invalid types or expressions
2306 in its requirements ... In such cases, the expression evaluates
2307 to false; it does not cause the program to be ill-formed.
2309 When substituting through a REQUIRES_EXPR as part of template
2310 instantiation, we call this routine with info.quiet() true.
2312 When evaluating a REQUIRES_EXPR that appears outside a template in
2313 cp_parser_requires_expression, we call this routine with
2316 Finally, when diagnosing unsatisfaction from diagnose_atomic_constraint
2317 and when diagnosing a false REQUIRES_EXPR via diagnose_constraints,
2318 we call this routine with info.diagnose_unsatisfaction_p() true. */
2321 tsubst_requires_expr (tree t
, tree args
, sat_info info
)
2323 local_specialization_stack
stack (lss_copy
);
2325 /* We need to check access during the substitution. */
2326 deferring_access_check_sentinel
acs (dk_no_deferred
);
2328 /* A requires-expression is an unevaluated context. */
2331 args
= add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t
), args
,
2332 info
.complain
, info
.in_decl
);
2333 if (processing_template_decl
)
2335 /* We're partially instantiating a generic lambda. Substituting into
2336 this requires-expression now may cause its requirements to get
2337 checked out of order, so instead just remember the template
2338 arguments and wait until we can substitute them all at once. */
2340 REQUIRES_EXPR_EXTRA_ARGS (t
) = build_extra_args (t
, args
, info
.complain
);
2344 if (tree parms
= REQUIRES_EXPR_PARMS (t
))
2346 parms
= tsubst_constraint_variables (parms
, args
, info
);
2347 if (parms
== error_mark_node
)
2348 return boolean_false_node
;
2351 tree result
= boolean_true_node
;
2352 for (tree reqs
= REQUIRES_EXPR_REQS (t
); reqs
; reqs
= TREE_CHAIN (reqs
))
2354 tree req
= TREE_VALUE (reqs
);
2355 if (tsubst_requirement (req
, args
, info
) == error_mark_node
)
2357 result
= boolean_false_node
;
2358 if (info
.diagnose_unsatisfaction_p ())
2359 /* Keep going so that we diagnose all failed requirements. */;
2367 /* Public wrapper for the above. */
2370 tsubst_requires_expr (tree t
, tree args
,
2371 tsubst_flags_t complain
, tree in_decl
)
2373 sat_info
info (complain
, in_decl
);
2374 return tsubst_requires_expr (t
, args
, info
);
2377 /* Substitute ARGS into the constraint information CI, producing a new
2378 constraint record. */
2381 tsubst_constraint_info (tree t
, tree args
,
2382 tsubst_flags_t complain
, tree in_decl
)
2384 if (!t
|| t
== error_mark_node
|| !check_constraint_info (t
))
2387 tree tr
= tsubst_constraint (CI_TEMPLATE_REQS (t
), args
, complain
, in_decl
);
2388 tree dr
= tsubst_constraint (CI_DECLARATOR_REQS (t
), args
, complain
, in_decl
);
2389 return build_constraints (tr
, dr
);
2392 /* Substitute through a parameter mapping, in order to get the actual
2393 arguments used to instantiate an atomic constraint. This may fail
2394 if the substitution into arguments produces something ill-formed. */
2397 tsubst_parameter_mapping (tree map
, tree args
, subst_info info
)
2402 tsubst_flags_t complain
= info
.complain
;
2403 tree in_decl
= info
.in_decl
;
2405 tree result
= NULL_TREE
;
2406 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2408 if (p
== error_mark_node
)
2409 return error_mark_node
;
2410 tree parm
= TREE_VALUE (p
);
2411 tree arg
= TREE_PURPOSE (p
);
2413 if (ARGUMENT_PACK_P (arg
))
2414 new_arg
= tsubst_argument_pack (arg
, args
, complain
, in_decl
);
2417 new_arg
= tsubst_template_arg (arg
, args
, complain
, in_decl
);
2418 if (TYPE_P (new_arg
))
2419 new_arg
= canonicalize_type_argument (new_arg
, complain
);
2421 if (TREE_CODE (new_arg
) == TYPE_ARGUMENT_PACK
)
2423 tree pack_args
= ARGUMENT_PACK_ARGS (new_arg
);
2424 for (tree
& pack_arg
: tree_vec_range (pack_args
))
2425 if (TYPE_P (pack_arg
))
2426 pack_arg
= canonicalize_type_argument (pack_arg
, complain
);
2428 if (new_arg
== error_mark_node
)
2429 return error_mark_node
;
2431 result
= tree_cons (new_arg
, parm
, result
);
2433 return nreverse (result
);
2437 tsubst_parameter_mapping (tree map
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2439 return tsubst_parameter_mapping (map
, args
, subst_info (complain
, in_decl
));
2442 /*---------------------------------------------------------------------------
2443 Constraint satisfaction
2444 ---------------------------------------------------------------------------*/
2446 /* True if we are currently satisfying a constraint. */
2448 static bool satisfying_constraint
;
2450 /* A vector of incomplete types (and of declarations with undeduced return type),
2451 appended to by note_failed_type_completion_for_satisfaction. The
2452 satisfaction caches use this in order to keep track of "potentially unstable"
2453 satisfaction results.
2455 Since references to entries in this vector are stored only in the
2456 GC-deletable sat_cache, it's safe to make this deletable as well. */
2458 static GTY((deletable
)) vec
<tree
, va_gc
> *failed_type_completions
;
2460 /* Called whenever a type completion (or return type deduction) failure occurs
2461 that definitely affects the meaning of the program, by e.g. inducing
2462 substitution failure. */
2465 note_failed_type_completion_for_satisfaction (tree t
)
2467 if (satisfying_constraint
)
2469 gcc_checking_assert ((TYPE_P (t
) && !COMPLETE_TYPE_P (t
))
2470 || (DECL_P (t
) && undeduced_auto_decl (t
)));
2471 vec_safe_push (failed_type_completions
, t
);
2475 /* Returns true if the range [BEGIN, END) of elements within the
2476 failed_type_completions vector contains a complete type (or a
2477 declaration with a non-placeholder return type). */
2480 some_type_complete_p (int begin
, int end
)
2482 for (int i
= begin
; i
< end
; i
++)
2484 tree t
= (*failed_type_completions
)[i
];
2485 if (TYPE_P (t
) && COMPLETE_TYPE_P (t
))
2487 if (DECL_P (t
) && !undeduced_auto_decl (t
))
2493 /* Hash functions and data types for satisfaction cache entries. */
2495 struct GTY((for_user
)) sat_entry
2497 /* The relevant ATOMIC_CONSTR. */
2500 /* The relevant template arguments. */
2503 /* The result of satisfaction of ATOM+ARGS.
2504 This is either boolean_true_node, boolean_false_node or error_mark_node,
2505 where error_mark_node indicates ill-formed satisfaction.
2506 It's set to NULL_TREE while computing satisfaction of ATOM+ARGS for
2510 /* The value of input_location when satisfaction of ATOM+ARGS was first
2512 location_t location
;
2514 /* The range of elements appended to the failed_type_completions vector
2515 during computation of this satisfaction result, encoded as a begin/end
2517 int ftc_begin
, ftc_end
;
2519 /* True if we want to diagnose the above instability when it's detected.
2520 We don't always want to do so, in order to avoid emitting duplicate
2521 diagnostics in some cases. */
2522 bool diagnose_instability
;
2524 /* True if we're in the middle of computing this satisfaction result.
2525 Used during both quiet and noisy satisfaction to detect self-recursive
2530 struct sat_hasher
: ggc_ptr_hash
<sat_entry
>
2532 static hashval_t
hash (sat_entry
*e
)
2534 auto cso
= make_temp_override (comparing_specializations
);
2535 ++comparing_specializations
;
2537 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e
->atom
))
2539 /* Atoms with instantiated mappings are built during satisfaction.
2540 They live only inside the sat_cache, and we build one to query
2541 the cache with each time we instantiate a mapping. */
2542 gcc_assert (!e
->args
);
2543 return hash_atomic_constraint (e
->atom
);
2546 /* Atoms with uninstantiated mappings are built during normalization.
2547 Since normalize_atom caches the atoms it returns, we can assume
2548 pointer-based identity for fast hashing and comparison. Even if this
2549 assumption is violated, that's okay, we'll just get a cache miss. */
2550 hashval_t value
= htab_hash_pointer (e
->atom
);
2552 if (tree map
= ATOMIC_CONSTR_MAP (e
->atom
))
2553 /* Only the parameters that are used in the targets of the mapping
2554 affect the satisfaction value of the atom. So we consider only
2555 the arguments for these parameters, and ignore the rest. */
2556 for (tree target_parms
= TREE_TYPE (map
);
2558 target_parms
= TREE_CHAIN (target_parms
))
2561 tree parm
= TREE_VALUE (target_parms
);
2562 template_parm_level_and_index (parm
, &level
, &index
);
2563 tree arg
= TMPL_ARG (e
->args
, level
, index
);
2564 value
= iterative_hash_template_arg (arg
, value
);
2569 static bool equal (sat_entry
*e1
, sat_entry
*e2
)
2571 auto cso
= make_temp_override (comparing_specializations
);
2572 ++comparing_specializations
;
2574 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
)
2575 != ATOMIC_CONSTR_MAP_INSTANTIATED_P (e2
->atom
))
2578 /* See sat_hasher::hash. */
2579 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
))
2581 gcc_assert (!e1
->args
&& !e2
->args
);
2582 return atomic_constraints_identical_p (e1
->atom
, e2
->atom
);
2585 if (e1
->atom
!= e2
->atom
)
2588 if (tree map
= ATOMIC_CONSTR_MAP (e1
->atom
))
2589 for (tree target_parms
= TREE_TYPE (map
);
2591 target_parms
= TREE_CHAIN (target_parms
))
2594 tree parm
= TREE_VALUE (target_parms
);
2595 template_parm_level_and_index (parm
, &level
, &index
);
2596 tree arg1
= TMPL_ARG (e1
->args
, level
, index
);
2597 tree arg2
= TMPL_ARG (e2
->args
, level
, index
);
2598 if (!template_args_equal (arg1
, arg2
))
2605 /* Cache the result of satisfy_atom. */
2606 static GTY((deletable
)) hash_table
<sat_hasher
> *sat_cache
;
2608 /* Cache the result of satisfy_declaration_constraints. */
2609 static GTY((deletable
)) hash_map
<tree
, tree
> *decl_satisfied_cache
;
2611 /* A tool used by satisfy_atom to help manage satisfaction caching and to
2612 diagnose "unstable" satisfaction values. We insert into the cache only
2613 when performing satisfaction quietly. */
2615 struct satisfaction_cache
2617 satisfaction_cache (tree
, tree
, sat_info
);
2626 /* Constructor for the satisfaction_cache class. We're performing satisfaction
2627 of ATOM+ARGS according to INFO. */
2630 ::satisfaction_cache (tree atom
, tree args
, sat_info info
)
2631 : entry(nullptr), info(info
), ftc_begin(-1)
2634 sat_cache
= hash_table
<sat_hasher
>::create_ggc (31);
2636 /* When noisy, we query the satisfaction cache in order to diagnose
2637 "unstable" satisfaction values. */
2640 /* When noisy, constraints have been re-normalized, and that breaks the
2641 pointer-based identity assumption of sat_cache (for atoms with
2642 uninstantiated mappings). So undo this re-normalization by looking in
2643 the atom_cache for the corresponding atom that was used during quiet
2645 if (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2647 if (tree found
= atom_cache
->find (atom
))
2650 /* The lookup should always succeed, but if it fails then let's
2651 just leave 'entry' empty, effectively disabling the cache. */
2656 /* Look up or create the corresponding satisfaction entry. */
2660 sat_entry
**slot
= sat_cache
->find_slot (&elt
, INSERT
);
2663 else if (info
.quiet ())
2665 entry
= ggc_alloc
<sat_entry
> ();
2668 entry
->result
= NULL_TREE
;
2669 entry
->location
= input_location
;
2670 entry
->ftc_begin
= entry
->ftc_end
= -1;
2671 entry
->diagnose_instability
= false;
2672 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2673 /* We always want to diagnose instability of an atom with an
2674 instantiated parameter mapping. For atoms with an uninstantiated
2675 mapping, we set this flag (in satisfy_atom) only if substitution
2676 into its mapping previously failed. */
2677 entry
->diagnose_instability
= true;
2678 entry
->evaluating
= false;
2683 /* We're evaluating this atom for the first time, and doing so noisily.
2684 This shouldn't happen outside of error recovery situations involving
2685 unstable satisfaction. Let's just leave 'entry' empty, effectively
2686 disabling the cache, and remove the empty slot. */
2687 gcc_checking_assert (seen_error ());
2688 /* Appease hash_table::check_complete_insertion. */
2689 *slot
= ggc_alloc
<sat_entry
> ();
2690 sat_cache
->clear_slot (slot
);
2694 /* Returns the cached satisfaction result if we have one and we're not
2695 recomputing the satisfaction result from scratch. Otherwise returns
2699 satisfaction_cache::get ()
2704 if (entry
->evaluating
)
2706 /* If we get here, it means satisfaction is self-recursive. */
2707 gcc_checking_assert (!entry
->result
|| seen_error ());
2709 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2710 "satisfaction of atomic constraint %qE depends on itself",
2712 return error_mark_node
;
2715 /* This satisfaction result is "potentially unstable" if a type for which
2716 type completion failed during its earlier computation is now complete. */
2717 bool maybe_unstable
= some_type_complete_p (entry
->ftc_begin
,
2720 if (info
.noisy () || maybe_unstable
|| !entry
->result
)
2722 /* We're computing the satisfaction result from scratch. */
2723 entry
->evaluating
= true;
2724 ftc_begin
= vec_safe_length (failed_type_completions
);
2728 return entry
->result
;
2731 /* RESULT is the computed satisfaction result. If RESULT differs from the
2732 previously cached result, this routine issues an appropriate error.
2733 Otherwise, when evaluating quietly, updates the cache appropriately. */
2736 satisfaction_cache::save (tree result
)
2741 gcc_checking_assert (entry
->evaluating
);
2742 entry
->evaluating
= false;
2744 if (entry
->result
&& result
!= entry
->result
)
2747 /* Return error_mark_node to force satisfaction to get replayed
2749 return error_mark_node
;
2752 if (entry
->diagnose_instability
)
2754 auto_diagnostic_group d
;
2755 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2756 "satisfaction value of atomic constraint %qE changed "
2757 "from %qE to %qE", entry
->atom
, entry
->result
, result
);
2758 inform (entry
->location
,
2759 "satisfaction value first evaluated to %qE from here",
2762 /* For sake of error recovery, allow this latest satisfaction result
2764 entry
->result
= result
;
2771 entry
->result
= result
;
2772 /* Store into this entry the list of relevant failed type completions
2773 that occurred during (re)computation of the satisfaction result. */
2774 gcc_checking_assert (ftc_begin
!= -1);
2775 entry
->ftc_begin
= ftc_begin
;
2776 entry
->ftc_end
= vec_safe_length (failed_type_completions
);
2782 /* Substitute ARGS into constraint-expression T during instantiation of
2783 a member of a class template. */
2786 tsubst_constraint (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2788 /* We also don't want to evaluate concept-checks when substituting the
2789 constraint-expressions of a declaration. */
2790 processing_constraint_expression_sentinel s
;
2792 tree expr
= tsubst_expr (t
, args
, complain
, in_decl
);
2796 static tree
satisfy_constraint_r (tree
, tree
, sat_info info
);
2798 /* Compute the satisfaction of a conjunction. */
2801 satisfy_conjunction (tree t
, tree args
, sat_info info
)
2803 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, info
);
2804 if (lhs
== error_mark_node
|| lhs
== boolean_false_node
)
2806 return satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, info
);
2809 /* The current depth at which we're replaying an error during recursive
2810 diagnosis of a constraint satisfaction failure. */
2812 static int current_constraint_diagnosis_depth
;
2814 /* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded
2815 CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint
2816 satisfaction error. */
2818 static bool concepts_diagnostics_max_depth_exceeded_p
;
2820 /* Recursive subroutine of collect_operands_of_disjunction. T is a normalized
2821 subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs)
2822 and E is the corresponding unnormalized subexpression (composed of
2823 TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */
2826 collect_operands_of_disjunction_r (tree t
, tree e
,
2827 auto_vec
<tree_pair
> *operands
)
2829 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
)
2831 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 0),
2832 TREE_OPERAND (e
, 0), operands
);
2833 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 1),
2834 TREE_OPERAND (e
, 1), operands
);
2838 tree_pair p
= std::make_pair (t
, e
);
2839 operands
->safe_push (p
);
2843 /* Recursively collect the normalized and unnormalized operands of the
2844 disjunction T and append them to OPERANDS in order. */
2847 collect_operands_of_disjunction (tree t
, auto_vec
<tree_pair
> *operands
)
2849 collect_operands_of_disjunction_r (t
, CONSTR_EXPR (t
), operands
);
2852 /* Compute the satisfaction of a disjunction. */
2855 satisfy_disjunction (tree t
, tree args
, sat_info info
)
2857 /* Evaluate each operand with unsatisfaction diagnostics disabled. */
2858 sat_info sub
= info
;
2859 sub
.diagnose_unsatisfaction
= false;
2861 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, sub
);
2862 if (lhs
== boolean_true_node
|| lhs
== error_mark_node
)
2865 tree rhs
= satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, sub
);
2866 if (rhs
== boolean_true_node
|| rhs
== error_mark_node
)
2869 /* Both branches evaluated to false. Explain the satisfaction failure in
2871 if (info
.diagnose_unsatisfaction_p ())
2873 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2874 cp_expr disj_expr
= CONSTR_EXPR (t
);
2875 inform (disj_expr
.get_location (),
2876 "no operand of the disjunction is satisfied");
2877 if (diagnosing_failed_constraint::replay_errors_p ())
2879 /* Replay the error in each branch of the disjunction. */
2880 auto_vec
<tree_pair
> operands
;
2881 collect_operands_of_disjunction (t
, &operands
);
2882 for (unsigned i
= 0; i
< operands
.length (); i
++)
2884 tree norm_op
= operands
[i
].first
;
2885 tree op
= operands
[i
].second
;
2886 location_t loc
= make_location (cp_expr_location (op
),
2887 disj_expr
.get_start (),
2888 disj_expr
.get_finish ());
2889 inform (loc
, "the operand %qE is unsatisfied because", op
);
2890 satisfy_constraint_r (norm_op
, args
, info
);
2895 return boolean_false_node
;
2898 /* Ensures that T is a truth value and not (accidentally, as sometimes
2899 happens) an integer value. */
2902 satisfaction_value (tree t
)
2904 if (t
== error_mark_node
|| t
== boolean_true_node
|| t
== boolean_false_node
)
2907 gcc_assert (TREE_CODE (t
) == INTEGER_CST
2908 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t
),
2909 boolean_type_node
));
2910 if (integer_zerop (t
))
2911 return boolean_false_node
;
2913 return boolean_true_node
;
2916 /* Build a new template argument vector corresponding to the parameter
2917 mapping of the atomic constraint T, using arguments from ARGS. */
2920 get_mapped_args (tree t
, tree args
)
2922 tree map
= ATOMIC_CONSTR_MAP (t
);
2924 /* No map, no arguments. */
2928 /* Determine the depth of the resulting argument vector. */
2930 if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t
))
2931 /* The expression of this atomic constraint comes from a concept definition,
2932 whose template depth is always one, so the resulting argument vector
2933 will also have depth one. */
2936 /* Otherwise, the expression of this atomic constraint comes from
2937 the context of the constrained entity, whose template depth is that
2939 depth
= TMPL_ARGS_DEPTH (args
);
2941 /* Place each argument at its corresponding position in the argument
2942 list. Note that the list will be sparse (not all arguments supplied),
2943 but instantiation is guaranteed to only use the parameters in the
2944 mapping, so null arguments would never be used. */
2945 auto_vec
< vec
<tree
> > lists (depth
);
2946 lists
.quick_grow_cleared (depth
);
2947 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2951 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
2953 /* Insert the argument into its corresponding position. */
2954 vec
<tree
> &list
= lists
[level
- 1];
2955 if (index
>= (int)list
.length ())
2956 list
.safe_grow_cleared (index
+ 1, /*exact=*/false);
2957 list
[index
] = TREE_PURPOSE (p
);
2960 /* Build the new argument list. */
2961 args
= make_tree_vec (lists
.length ());
2962 for (unsigned i
= 0; i
!= lists
.length (); ++i
)
2964 vec
<tree
> &list
= lists
[i
];
2965 tree level
= make_tree_vec (list
.length ());
2966 for (unsigned j
= 0; j
< list
.length(); ++j
)
2967 TREE_VEC_ELT (level
, j
) = list
[j
];
2968 SET_TMPL_ARGS_LEVEL (args
, i
+ 1, level
);
2971 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, 0);
2973 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
)
2974 && TMPL_ARGS_DEPTH (args
) == 1)
2976 /* Get rid of the redundant outer TREE_VEC. */
2977 tree level
= TMPL_ARGS_LEVEL (args
, 1);
2985 static void diagnose_atomic_constraint (tree
, tree
, tree
, sat_info
);
2987 /* Compute the satisfaction of an atomic constraint. */
2990 satisfy_atom (tree t
, tree args
, sat_info info
)
2992 /* In case there is a diagnostic, we want to establish the context
2993 prior to printing errors. If no errors occur, this context is
2994 removed before returning. */
2995 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2997 satisfaction_cache
cache (t
, args
, info
);
2998 if (tree r
= cache
.get ())
3001 /* Perform substitution quietly. */
3002 subst_info
quiet (tf_none
, NULL_TREE
);
3004 /* Instantiate the parameter mapping. */
3005 tree map
= tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, quiet
);
3006 if (map
== error_mark_node
)
3008 /* If instantiation of the parameter mapping fails, the constraint is
3009 not satisfied. Replay the substitution. */
3010 if (info
.diagnose_unsatisfaction_p ())
3011 tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, info
);
3013 /* Since instantiation of the parameter mapping failed, we
3014 want to diagnose potential instability of this satisfaction
3016 cache
.entry
->diagnose_instability
= true;
3017 return cache
.save (boolean_false_node
);
3020 /* Now build a new atom using the instantiated mapping. We use
3021 this atom as a second key to the satisfaction cache, and we
3022 also pass it to diagnose_atomic_constraint so that diagnostics
3023 which refer to the atom display the instantiated mapping. */
3025 ATOMIC_CONSTR_MAP (t
) = map
;
3026 gcc_assert (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
));
3027 ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
) = true;
3028 satisfaction_cache
inst_cache (t
, /*args=*/NULL_TREE
, info
);
3029 if (tree r
= inst_cache
.get ())
3031 cache
.entry
->location
= inst_cache
.entry
->location
;
3032 return cache
.save (r
);
3035 /* Rebuild the argument vector from the parameter mapping. */
3036 args
= get_mapped_args (t
, args
);
3038 /* Apply the parameter mapping (i.e., just substitute). */
3039 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3040 tree result
= tsubst_expr (expr
, args
, quiet
.complain
, quiet
.in_decl
);
3041 if (result
== error_mark_node
)
3043 /* If substitution results in an invalid type or expression, the constraint
3044 is not satisfied. Replay the substitution. */
3045 if (info
.diagnose_unsatisfaction_p ())
3046 tsubst_expr (expr
, args
, info
.complain
, info
.in_decl
);
3047 return cache
.save (inst_cache
.save (boolean_false_node
));
3050 /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary,
3051 and EXPR shall be a constant expression of type bool. */
3052 result
= force_rvalue (result
, info
.complain
);
3053 if (result
== error_mark_node
)
3054 return cache
.save (inst_cache
.save (error_mark_node
));
3055 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3058 diagnose_atomic_constraint (t
, args
, result
, info
);
3059 return cache
.save (inst_cache
.save (error_mark_node
));
3062 /* Compute the value of the constraint. */
3065 iloc_sentinel
ils (EXPR_LOCATION (result
));
3066 result
= cxx_constant_value (result
);
3070 result
= maybe_constant_value (result
, NULL_TREE
, mce_true
);
3071 if (!TREE_CONSTANT (result
))
3072 result
= error_mark_node
;
3074 result
= satisfaction_value (result
);
3075 if (result
== boolean_false_node
&& info
.diagnose_unsatisfaction_p ())
3076 diagnose_atomic_constraint (t
, args
, result
, info
);
3078 return cache
.save (inst_cache
.save (result
));
3081 /* Determine if the normalized constraint T is satisfied.
3082 Returns boolean_true_node if the expression/constraint is
3083 satisfied, boolean_false_node if not, and error_mark_node
3084 if the there was an error evaluating the constraint.
3086 The parameter mapping of atomic constraints is simply the
3087 set of template arguments that will be substituted into
3088 the expression, regardless of template parameters appearing
3089 withing. Whether a template argument is used in the atomic
3090 constraint only matters for subsumption. */
3093 satisfy_constraint_r (tree t
, tree args
, sat_info info
)
3095 if (t
== error_mark_node
)
3096 return error_mark_node
;
3098 switch (TREE_CODE (t
))
3101 return satisfy_conjunction (t
, args
, info
);
3103 return satisfy_disjunction (t
, args
, info
);
3105 return satisfy_atom (t
, args
, info
);
3111 /* Check that the normalized constraint T is satisfied for ARGS. */
3114 satisfy_normalized_constraints (tree t
, tree args
, sat_info info
)
3116 auto_timevar
time (TV_CONSTRAINT_SAT
);
3118 auto ovr
= make_temp_override (satisfying_constraint
, true);
3120 /* Turn off template processing. Constraint satisfaction only applies
3121 to non-dependent terms, so we want to ensure full checking here. */
3122 processing_template_decl_sentinel
proc (true);
3124 /* We need to check access during satisfaction. */
3125 deferring_access_check_sentinel
acs (dk_no_deferred
);
3127 /* Constraints are unevaluated operands. */
3130 return satisfy_constraint_r (t
, args
, info
);
3133 /* Return the normal form of the constraints on the placeholder 'auto'
3137 normalize_placeholder_type_constraints (tree t
, bool diag
)
3139 gcc_assert (is_auto (t
));
3140 tree ci
= PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t
);
3144 tree constr
= TREE_VALUE (ci
);
3145 /* The TREE_PURPOSE contains the set of template parameters that were in
3146 scope for this placeholder type; use them as the initial template
3147 parameters for normalization. */
3148 tree initial_parms
= TREE_PURPOSE (ci
);
3150 /* The 'auto' itself is used as the first argument in its own constraints,
3151 and its level is one greater than its template depth. So in order to
3152 capture all used template parameters, we need to add an extra level of
3153 template parameters to the context; a dummy level suffices. */
3155 = tree_cons (size_int (initial_parms
3156 ? TMPL_PARMS_DEPTH (initial_parms
) + 1 : 1),
3157 make_tree_vec (0), initial_parms
);
3159 norm_info
info (diag
? tf_norm
: tf_none
);
3160 info
.initial_parms
= initial_parms
;
3161 return normalize_constraint_expression (constr
, info
);
3164 /* Evaluate the constraints of T using ARGS, returning a satisfaction value.
3165 Here, T can be a concept-id, nested-requirement, placeholder 'auto', or
3166 requires-expression. */
3169 satisfy_nondeclaration_constraints (tree t
, tree args
, sat_info info
)
3171 if (t
== error_mark_node
)
3172 return error_mark_node
;
3174 /* Handle REQUIRES_EXPR directly, bypassing satisfaction. */
3175 if (TREE_CODE (t
) == REQUIRES_EXPR
)
3177 auto ovr
= make_temp_override (current_constraint_diagnosis_depth
);
3179 ++current_constraint_diagnosis_depth
;
3180 return tsubst_requires_expr (t
, args
, info
);
3183 /* Get the normalized constraints. */
3185 if (concept_check_p (t
))
3188 tree id
= unpack_concept_check (t
);
3189 args
= TREE_OPERAND (id
, 1);
3190 tree tmpl
= get_concept_check_template (id
);
3191 norm
= normalize_concept_definition (tmpl
, info
.noisy ());
3193 else if (TREE_CODE (t
) == NESTED_REQ
)
3195 norm_info
ninfo (info
.noisy () ? tf_norm
: tf_none
);
3196 /* The TREE_TYPE contains the set of template parameters that were in
3197 scope for this nested requirement; use them as the initial template
3198 parameters for normalization. */
3199 ninfo
.initial_parms
= TREE_TYPE (t
);
3200 norm
= normalize_constraint_expression (TREE_OPERAND (t
, 0), ninfo
);
3202 else if (is_auto (t
))
3204 norm
= normalize_placeholder_type_constraints (t
, info
.noisy ());
3206 return boolean_true_node
;
3211 /* Perform satisfaction. */
3212 return satisfy_normalized_constraints (norm
, args
, info
);
3215 /* Evaluate the associated constraints of the template specialization T
3216 according to INFO, returning a satisfaction value. */
3219 satisfy_declaration_constraints (tree t
, sat_info info
)
3221 gcc_assert (DECL_P (t
) && TREE_CODE (t
) != TEMPLATE_DECL
);
3222 const tree saved_t
= t
;
3224 /* For inherited constructors, consider the original declaration;
3225 it has the correct template information attached. */
3226 t
= strip_inheriting_ctors (t
);
3227 tree inh_ctor_targs
= NULL_TREE
;
3229 if (tree ti
= DECL_TEMPLATE_INFO (saved_t
))
3230 /* The inherited constructor points to an instantiation of a constructor
3231 template; remember its template arguments. */
3232 inh_ctor_targs
= TI_ARGS (ti
);
3234 /* Update the declaration for diagnostics. */
3238 if (tree
*result
= hash_map_safe_get (decl_satisfied_cache
, saved_t
))
3241 tree args
= NULL_TREE
;
3242 if (tree ti
= DECL_TEMPLATE_INFO (t
))
3244 /* The initial parameter mapping is the complete set of
3245 template arguments substituted into the declaration. */
3246 args
= TI_ARGS (ti
);
3248 args
= add_outermost_template_args (args
, inh_ctor_targs
);
3251 if (regenerated_lambda_fn_p (t
))
3253 /* The TI_ARGS of a regenerated lambda contains only the innermost
3254 set of template arguments. Augment this with the outer template
3255 arguments that were used to regenerate the lambda. */
3256 gcc_assert (!args
|| TMPL_ARGS_DEPTH (args
) == 1);
3257 tree regen_args
= lambda_regenerating_args (t
);
3259 args
= add_to_template_args (regen_args
, args
);
3264 /* If the innermost arguments are dependent, or if the outer arguments
3265 are dependent and are needed by the constraints, we can't check
3266 satisfaction yet so pretend they're satisfied for now. */
3267 if (uses_template_parms (args
)
3268 && ((DECL_TEMPLATE_INFO (t
)
3269 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))
3270 && (TMPL_ARGS_DEPTH (args
) == 1
3271 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))))
3272 || uses_outer_template_parms_in_constraints (t
)))
3273 return boolean_true_node
;
3275 /* Get the normalized constraints. */
3276 tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ());
3278 unsigned ftc_count
= vec_safe_length (failed_type_completions
);
3280 tree result
= boolean_true_node
;
3283 if (!push_tinst_level (t
))
3285 push_to_top_level ();
3286 push_access_scope (t
);
3287 result
= satisfy_normalized_constraints (norm
, args
, info
);
3288 pop_access_scope (t
);
3289 pop_from_top_level ();
3293 /* True if this satisfaction is (heuristically) potentially unstable, i.e.
3294 if its result may depend on where in the program it was performed. */
3295 bool maybe_unstable_satisfaction
= false;
3296 if (ftc_count
!= vec_safe_length (failed_type_completions
))
3297 /* Type completion failure occurred during satisfaction. The satisfaction
3298 result may (or may not) materially depend on the completeness of a type,
3299 so we consider it potentially unstable. */
3300 maybe_unstable_satisfaction
= true;
3302 if (maybe_unstable_satisfaction
)
3303 /* Don't cache potentially unstable satisfaction, to allow satisfy_atom
3304 to check the stability the next time around. */;
3305 else if (info
.quiet ())
3306 hash_map_safe_put
<hm_ggc
> (decl_satisfied_cache
, saved_t
, result
);
3311 /* Evaluate the associated constraints of the template T using ARGS as the
3312 innermost set of template arguments and according to INFO, returning a
3313 satisfaction value. */
3316 satisfy_declaration_constraints (tree t
, tree args
, sat_info info
)
3318 /* Update the declaration for diagnostics. */
3321 gcc_assert (TREE_CODE (t
) == TEMPLATE_DECL
);
3323 if (regenerated_lambda_fn_p (t
))
3325 /* As in the two-parameter version of this function. */
3326 gcc_assert (TMPL_ARGS_DEPTH (args
) == 1);
3327 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t
));
3328 tree outer_args
= TI_ARGS (LAMBDA_EXPR_REGEN_INFO (lambda
));
3329 args
= add_to_template_args (outer_args
, args
);
3332 args
= add_outermost_template_args (t
, args
);
3334 /* If the innermost arguments are dependent, or if the outer arguments
3335 are dependent and are needed by the constraints, we can't check
3336 satisfaction yet so pretend they're satisfied for now. */
3337 if (uses_template_parms (args
)
3338 && (TMPL_ARGS_DEPTH (args
) == 1
3339 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))
3340 || uses_outer_template_parms_in_constraints (t
)))
3341 return boolean_true_node
;
3343 tree result
= boolean_true_node
;
3344 if (tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ()))
3346 if (!push_tinst_level (t
, args
))
3348 tree pattern
= DECL_TEMPLATE_RESULT (t
);
3349 push_to_top_level ();
3350 push_access_scope (pattern
);
3351 result
= satisfy_normalized_constraints (norm
, args
, info
);
3352 pop_access_scope (pattern
);
3353 pop_from_top_level ();
3360 /* A wrapper around satisfy_declaration_constraints and
3361 satisfy_nondeclaration_constraints which additionally replays
3362 quiet ill-formed satisfaction noisily, so that ill-formed
3363 satisfaction always gets diagnosed. */
3366 constraint_satisfaction_value (tree t
, tree args
, sat_info info
)
3372 r
= satisfy_declaration_constraints (t
, args
, info
);
3374 r
= satisfy_declaration_constraints (t
, info
);
3377 r
= satisfy_nondeclaration_constraints (t
, args
, info
);
3378 if (r
== error_mark_node
&& info
.quiet ()
3379 && !(DECL_P (t
) && warning_suppressed_p (t
)))
3381 /* Replay the error noisily. */
3382 sat_info
noisy (tf_warning_or_error
, info
.in_decl
);
3383 constraint_satisfaction_value (t
, args
, noisy
);
3384 if (DECL_P (t
) && !args
)
3385 /* Avoid giving these errors again. */
3386 suppress_warning (t
);
3391 /* True iff the result of satisfying T using ARGS is BOOLEAN_TRUE_NODE
3392 and false otherwise, even in the case of errors.
3395 - a template declaration
3396 - a template specialization (in which case ARGS must be empty)
3397 - a concept-id (in which case ARGS must be empty)
3398 - a nested-requirement
3399 - a placeholder 'auto'
3400 - a requires-expression. */
3403 constraints_satisfied_p (tree t
, tree args
/*= NULL_TREE */)
3408 sat_info
quiet (tf_none
, NULL_TREE
);
3409 return constraint_satisfaction_value (t
, args
, quiet
) == boolean_true_node
;
3412 /* Evaluate a concept check of the form C<ARGS>. This is only used for the
3413 evaluation of template-ids as id-expressions. */
3416 evaluate_concept_check (tree check
)
3418 if (check
== error_mark_node
)
3419 return error_mark_node
;
3421 gcc_assert (concept_check_p (check
));
3423 /* Check for satisfaction without diagnostics. */
3424 sat_info
quiet (tf_none
, NULL_TREE
);
3425 return constraint_satisfaction_value (check
, /*args=*/NULL_TREE
, quiet
);
3428 /* Evaluate the requires-expression T, returning either boolean_true_node
3429 or boolean_false_node. This is used during folding and constexpr
3433 evaluate_requires_expr (tree t
)
3435 gcc_assert (TREE_CODE (t
) == REQUIRES_EXPR
);
3436 sat_info
quiet (tf_none
, NULL_TREE
);
3437 return constraint_satisfaction_value (t
, /*args=*/NULL_TREE
, quiet
);
3440 /*---------------------------------------------------------------------------
3441 Semantic analysis of requires-expressions
3442 ---------------------------------------------------------------------------*/
3444 /* Finish a requires expression for the given PARMS (possibly
3445 null) and the non-empty sequence of requirements. */
3448 finish_requires_expr (location_t loc
, tree parms
, tree reqs
)
3450 /* Build the node. */
3451 tree r
= build_min (REQUIRES_EXPR
, boolean_type_node
, parms
, reqs
, NULL_TREE
);
3452 TREE_SIDE_EFFECTS (r
) = false;
3453 TREE_CONSTANT (r
) = true;
3454 SET_EXPR_LOCATION (r
, loc
);
3458 /* Construct a requirement for the validity of EXPR. */
3461 finish_simple_requirement (location_t loc
, tree expr
)
3463 tree r
= build_nt (SIMPLE_REQ
, expr
);
3464 SET_EXPR_LOCATION (r
, loc
);
3468 /* Construct a requirement for the validity of TYPE. */
3471 finish_type_requirement (location_t loc
, tree type
)
3473 tree r
= build_nt (TYPE_REQ
, type
);
3474 SET_EXPR_LOCATION (r
, loc
);
3478 /* Construct a requirement for the validity of EXPR, along with
3479 its properties. if TYPE is non-null, then it specifies either
3480 an implicit conversion or argument deduction constraint,
3481 depending on whether any placeholders occur in the type name.
3482 NOEXCEPT_P is true iff the noexcept keyword was specified. */
3485 finish_compound_requirement (location_t loc
, tree expr
, tree type
, bool noexcept_p
)
3487 tree req
= build_nt (COMPOUND_REQ
, expr
, type
);
3488 SET_EXPR_LOCATION (req
, loc
);
3489 COMPOUND_REQ_NOEXCEPT_P (req
) = noexcept_p
;
3493 /* Finish a nested requirement. */
3496 finish_nested_requirement (location_t loc
, tree expr
)
3498 /* Build the requirement, saving the set of in-scope template
3499 parameters as its type. */
3500 tree r
= build1 (NESTED_REQ
, current_template_parms
, expr
);
3501 SET_EXPR_LOCATION (r
, loc
);
3505 /* Check that FN satisfies the structural requirements of a
3506 function concept definition. */
3508 check_function_concept (tree fn
)
3510 /* Check that the function is comprised of only a return statement. */
3511 tree body
= DECL_SAVED_TREE (fn
);
3512 if (TREE_CODE (body
) == BIND_EXPR
)
3513 body
= BIND_EXPR_BODY (body
);
3515 /* Sometimes a function call results in the creation of clean up
3516 points. Allow these to be preserved in the body of the
3517 constraint, as we might actually need them for some constexpr
3519 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
3520 body
= TREE_OPERAND (body
, 0);
3522 /* Check that the definition is written correctly. */
3523 if (TREE_CODE (body
) != RETURN_EXPR
)
3525 location_t loc
= DECL_SOURCE_LOCATION (fn
);
3526 if (TREE_CODE (body
) == STATEMENT_LIST
&& !STATEMENT_LIST_HEAD (body
))
3529 /* The definition was probably erroneous, not empty. */;
3531 error_at (loc
, "definition of concept %qD is empty", fn
);
3534 error_at (loc
, "definition of concept %qD has multiple statements", fn
);
3540 /*---------------------------------------------------------------------------
3541 Equivalence of constraints
3542 ---------------------------------------------------------------------------*/
3544 /* Returns true when A and B are equivalent constraints. */
3546 equivalent_constraints (tree a
, tree b
)
3548 gcc_assert (!a
|| TREE_CODE (a
) == CONSTRAINT_INFO
);
3549 gcc_assert (!b
|| TREE_CODE (b
) == CONSTRAINT_INFO
);
3550 return cp_tree_equal (a
, b
);
3553 /* Returns true if the template declarations A and B have equivalent
3554 constraints. This is the case when A's constraints subsume B's and
3555 when B's also constrain A's. */
3557 equivalently_constrained (tree d1
, tree d2
)
3559 gcc_assert (TREE_CODE (d1
) == TREE_CODE (d2
));
3560 return equivalent_constraints (get_constraints (d1
), get_constraints (d2
));
3563 /*---------------------------------------------------------------------------
3564 Partial ordering of constraints
3565 ---------------------------------------------------------------------------*/
3567 /* Returns true when the constraints in CI strictly subsume
3568 the associated constraints of TMPL. */
3571 strictly_subsumes (tree ci
, tree tmpl
)
3573 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3574 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3576 return subsumes (n1
, n2
) && !subsumes (n2
, n1
);
3579 /* Returns true when the constraints in CI subsume the
3580 associated constraints of TMPL. */
3583 weakly_subsumes (tree ci
, tree tmpl
)
3585 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3586 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3588 return subsumes (n1
, n2
);
3591 /* Determines which of the declarations, A or B, is more constrained.
3592 That is, which declaration's constraints subsume but are not subsumed
3595 Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
3596 than D1, and 0 otherwise. */
3599 more_constrained (tree d1
, tree d2
)
3601 tree n1
= get_normalized_constraints_from_decl (d1
);
3602 tree n2
= get_normalized_constraints_from_decl (d2
);
3605 if (subsumes (n1
, n2
))
3607 if (subsumes (n2
, n1
))
3612 /* Return whether D1 is at least as constrained as D2. */
3615 at_least_as_constrained (tree d1
, tree d2
)
3617 tree n1
= get_normalized_constraints_from_decl (d1
);
3618 tree n2
= get_normalized_constraints_from_decl (d2
);
3620 return subsumes (n1
, n2
);
3623 /*---------------------------------------------------------------------------
3624 Constraint diagnostics
3625 ---------------------------------------------------------------------------*/
3627 /* Returns the best location to diagnose a constraint error. */
3630 get_constraint_error_location (tree t
)
3632 if (location_t loc
= cp_expr_location (t
))
3635 /* If we have a specific location give it. */
3636 tree expr
= CONSTR_EXPR (t
);
3637 if (location_t loc
= cp_expr_location (expr
))
3640 /* If the constraint is normalized from a requires-clause, give
3641 the location as that of the constrained declaration. */
3642 tree cxt
= CONSTR_CONTEXT (t
);
3643 tree src
= cxt
? TREE_VALUE (cxt
) : NULL_TREE
;
3645 /* TODO: This only happens for constrained non-template declarations. */
3647 else if (DECL_P (src
))
3648 return DECL_SOURCE_LOCATION (src
);
3649 /* Otherwise, give the location as the defining concept. */
3650 else if (concept_check_p (src
))
3652 tree id
= unpack_concept_check (src
);
3653 tree tmpl
= TREE_OPERAND (id
, 0);
3655 tmpl
= OVL_FIRST (tmpl
);
3656 return DECL_SOURCE_LOCATION (tmpl
);
3659 return input_location
;
3662 /* Emit a diagnostic for a failed trait. */
3665 diagnose_trait_expr (tree expr
, tree args
)
3667 location_t loc
= cp_expr_location (expr
);
3669 /* Build a "fake" version of the instantiated trait, so we can
3670 get the instantiated types from result. */
3671 ++processing_template_decl
;
3672 expr
= tsubst_expr (expr
, args
, tf_none
, NULL_TREE
);
3673 --processing_template_decl
;
3675 tree t1
= TRAIT_EXPR_TYPE1 (expr
);
3676 tree t2
= TRAIT_EXPR_TYPE2 (expr
);
3677 if (t2
&& TREE_CODE (t2
) == TREE_VEC
)
3679 /* Convert the TREE_VEC of arguments into a TREE_LIST, since we can't
3680 directly print a TREE_VEC but we can a TREE_LIST via the E format
3682 tree list
= NULL_TREE
;
3683 for (tree t
: tree_vec_range (t2
))
3684 list
= tree_cons (NULL_TREE
, t
, list
);
3685 t2
= nreverse (list
);
3687 switch (TRAIT_EXPR_KIND (expr
))
3689 case CPTK_HAS_NOTHROW_ASSIGN
:
3690 inform (loc
, " %qT is not nothrow copy assignable", t1
);
3692 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
3693 inform (loc
, " %qT is not nothrow default constructible", t1
);
3695 case CPTK_HAS_NOTHROW_COPY
:
3696 inform (loc
, " %qT is not nothrow copy constructible", t1
);
3698 case CPTK_HAS_TRIVIAL_ASSIGN
:
3699 inform (loc
, " %qT is not trivially copy assignable", t1
);
3701 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
3702 inform (loc
, " %qT is not trivially default constructible", t1
);
3704 case CPTK_HAS_TRIVIAL_COPY
:
3705 inform (loc
, " %qT is not trivially copy constructible", t1
);
3707 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
3708 inform (loc
, " %qT is not trivially destructible", t1
);
3710 case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS
:
3711 inform (loc
, " %qT does not have unique object representations", t1
);
3713 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
3714 inform (loc
, " %qT does not have a virtual destructor", t1
);
3716 case CPTK_IS_ABSTRACT
:
3717 inform (loc
, " %qT is not an abstract class", t1
);
3719 case CPTK_IS_AGGREGATE
:
3720 inform (loc
, " %qT is not an aggregate", t1
);
3723 inform (loc
, " %qT is not an array", t1
);
3725 case CPTK_IS_ASSIGNABLE
:
3726 inform (loc
, " %qT is not assignable from %qT", t1
, t2
);
3728 case CPTK_IS_BASE_OF
:
3729 inform (loc
, " %qT is not a base of %qT", t1
, t2
);
3731 case CPTK_IS_BOUNDED_ARRAY
:
3732 inform (loc
, " %qT is not a bounded array", t1
);
3735 inform (loc
, " %qT is not a class", t1
);
3737 case CPTK_IS_CONSTRUCTIBLE
:
3739 inform (loc
, " %qT is not default constructible", t1
);
3741 inform (loc
, " %qT is not constructible from %qE", t1
, t2
);
3743 case CPTK_IS_CONVERTIBLE
:
3744 inform (loc
, " %qT is not convertible from %qE", t2
, t1
);
3747 inform (loc
, " %qT is not an empty class", t1
);
3750 inform (loc
, " %qT is not an enum", t1
);
3753 inform (loc
, " %qT is not a final class", t1
);
3755 case CPTK_IS_FUNCTION
:
3756 inform (loc
, " %qT is not a function", t1
);
3758 case CPTK_IS_LAYOUT_COMPATIBLE
:
3759 inform (loc
, " %qT is not layout compatible with %qT", t1
, t2
);
3761 case CPTK_IS_LITERAL_TYPE
:
3762 inform (loc
, " %qT is not a literal type", t1
);
3764 case CPTK_IS_MEMBER_FUNCTION_POINTER
:
3765 inform (loc
, " %qT is not a member function pointer", t1
);
3767 case CPTK_IS_MEMBER_OBJECT_POINTER
:
3768 inform (loc
, " %qT is not a member object pointer", t1
);
3770 case CPTK_IS_MEMBER_POINTER
:
3771 inform (loc
, " %qT is not a member pointer", t1
);
3773 case CPTK_IS_NOTHROW_ASSIGNABLE
:
3774 inform (loc
, " %qT is not nothrow assignable from %qT", t1
, t2
);
3776 case CPTK_IS_NOTHROW_CONSTRUCTIBLE
:
3778 inform (loc
, " %qT is not nothrow default constructible", t1
);
3780 inform (loc
, " %qT is not nothrow constructible from %qE", t1
, t2
);
3782 case CPTK_IS_NOTHROW_CONVERTIBLE
:
3783 inform (loc
, " %qT is not nothrow convertible from %qE", t2
, t1
);
3785 case CPTK_IS_OBJECT
:
3786 inform (loc
, " %qT is not an object type", t1
);
3788 case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF
:
3789 inform (loc
, " %qT is not pointer-interconvertible base of %qT",
3793 inform (loc
, " %qT is not a POD type", t1
);
3795 case CPTK_IS_POLYMORPHIC
:
3796 inform (loc
, " %qT is not a polymorphic type", t1
);
3798 case CPTK_IS_REFERENCE
:
3799 inform (loc
, " %qT is not a reference", t1
);
3802 inform (loc
, " %qT is not the same as %qT", t1
, t2
);
3804 case CPTK_IS_SCOPED_ENUM
:
3805 inform (loc
, " %qT is not a scoped enum", t1
);
3807 case CPTK_IS_STD_LAYOUT
:
3808 inform (loc
, " %qT is not an standard layout type", t1
);
3810 case CPTK_IS_TRIVIAL
:
3811 inform (loc
, " %qT is not a trivial type", t1
);
3813 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
3814 inform (loc
, " %qT is not trivially assignable from %qT", t1
, t2
);
3816 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
3818 inform (loc
, " %qT is not trivially default constructible", t1
);
3820 inform (loc
, " %qT is not trivially constructible from %qE", t1
, t2
);
3822 case CPTK_IS_TRIVIALLY_COPYABLE
:
3823 inform (loc
, " %qT is not trivially copyable", t1
);
3826 inform (loc
, " %qT is not a union", t1
);
3828 case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY
:
3829 inform (loc
, " %qT is not a reference that binds to a temporary "
3830 "object of type %qT (direct-initialization)", t1
, t2
);
3832 case CPTK_REF_CONVERTS_FROM_TEMPORARY
:
3833 inform (loc
, " %qT is not a reference that binds to a temporary "
3834 "object of type %qT (copy-initialization)", t1
, t2
);
3836 case CPTK_IS_DEDUCIBLE
:
3837 inform (loc
, " %qD is not deducible from %qT", t1
, t2
);
3839 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
3841 #include "cp-trait.def"
3842 #undef DEFTRAIT_TYPE
3843 /* Type-yielding traits aren't expressions. */
3845 /* We deliberately omit the default case so that when adding a new
3846 trait we'll get reminded (by way of a warning) to handle it here. */
3850 /* Diagnose a substitution failure in the atomic constraint T using ARGS. */
3853 diagnose_atomic_constraint (tree t
, tree args
, tree result
, sat_info info
)
3855 /* If the constraint is already ill-formed, we've previously diagnosed
3856 the reason. We should still say why the constraints aren't satisfied. */
3857 if (t
== error_mark_node
)
3861 loc
= DECL_SOURCE_LOCATION (info
.in_decl
);
3863 loc
= input_location
;
3864 inform (loc
, "invalid constraints");
3868 location_t loc
= get_constraint_error_location (t
);
3869 iloc_sentinel
loc_s (loc
);
3871 /* Generate better diagnostics for certain kinds of expressions. */
3872 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3873 STRIP_ANY_LOCATION_WRAPPER (expr
);
3874 switch (TREE_CODE (expr
))
3877 diagnose_trait_expr (expr
, args
);
3880 gcc_checking_assert (info
.diagnose_unsatisfaction_p ());
3881 /* Clear in_decl before replaying the substitution to avoid emitting
3882 seemingly unhelpful "in declaration ..." notes that follow some
3883 substitution failure error messages. */
3884 info
.in_decl
= NULL_TREE
;
3885 tsubst_requires_expr (expr
, args
, info
);
3888 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3889 error_at (loc
, "constraint %qE has type %qT, not %<bool%>",
3890 t
, TREE_TYPE (result
));
3892 inform (loc
, "the expression %qE evaluated to %<false%>", t
);
3896 GTY(()) tree current_failed_constraint
;
3898 diagnosing_failed_constraint::
3899 diagnosing_failed_constraint (tree t
, tree args
, bool diag
)
3900 : diagnosing_error (diag
)
3902 if (diagnosing_error
)
3904 current_failed_constraint
3905 = tree_cons (args
, t
, current_failed_constraint
);
3906 ++current_constraint_diagnosis_depth
;
3910 diagnosing_failed_constraint::
3911 ~diagnosing_failed_constraint ()
3913 if (diagnosing_error
)
3915 --current_constraint_diagnosis_depth
;
3916 if (current_failed_constraint
)
3917 current_failed_constraint
= TREE_CHAIN (current_failed_constraint
);
3922 /* Whether we are allowed to replay an error that underlies a constraint failure
3923 at the current diagnosis depth. */
3926 diagnosing_failed_constraint::replay_errors_p ()
3928 if (current_constraint_diagnosis_depth
>= concepts_diagnostics_max_depth
)
3930 concepts_diagnostics_max_depth_exceeded_p
= true;
3937 /* Emit diagnostics detailing the failure ARGS to satisfy the constraints
3938 of T. Here, T and ARGS are as in constraints_satisfied_p. */
3941 diagnose_constraints (location_t loc
, tree t
, tree args
)
3943 inform (loc
, "constraints not satisfied");
3945 if (concepts_diagnostics_max_depth
== 0)
3948 /* Replay satisfaction, but diagnose unsatisfaction. */
3949 sat_info
noisy (tf_warning_or_error
, NULL_TREE
, /*diag_unsat=*/true);
3950 constraint_satisfaction_value (t
, args
, noisy
);
3952 static bool suggested_p
;
3953 if (concepts_diagnostics_max_depth_exceeded_p
3954 && current_constraint_diagnosis_depth
== 0
3957 inform (UNKNOWN_LOCATION
,
3958 "set %qs to at least %d for more detail",
3959 "-fconcepts-diagnostics-depth=",
3960 concepts_diagnostics_max_depth
+ 1);
3965 #include "gt-cp-constraint.h"