1 /* Processing rules for constraints.
2 Copyright (C) 2013-2022 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 return finish_constraint_and_expr (input_location
, lhs
, rhs
);
246 /* Extract the template-id from a concept check. For standard and variable
247 checks, this is simply T. For function concept checks, this is the
251 unpack_concept_check (tree t
)
253 gcc_assert (concept_check_p (t
));
255 if (TREE_CODE (t
) == CALL_EXPR
)
256 t
= CALL_EXPR_FN (t
);
258 gcc_assert (TREE_CODE (t
) == TEMPLATE_ID_EXPR
);
262 /* Extract the TEMPLATE_DECL from a concept check. */
265 get_concept_check_template (tree t
)
267 tree id
= unpack_concept_check (t
);
268 tree tmpl
= TREE_OPERAND (id
, 0);
270 tmpl
= OVL_FIRST (tmpl
);
274 /*---------------------------------------------------------------------------
275 Resolution of qualified concept names
276 ---------------------------------------------------------------------------*/
278 /* This facility is used to resolve constraint checks from requirement
279 expressions. A constraint check is a call to a function template declared
280 with the keyword 'concept'.
282 The result of resolution is a pair (a TREE_LIST) whose value is the
283 matched declaration, and whose purpose contains the coerced template
284 arguments that can be substituted into the call. */
286 /* Given an overload set OVL, try to find a unique definition that can be
287 instantiated by the template arguments ARGS.
289 This function is not called for arbitrary call expressions. In particular,
290 the call expression must be written with explicit template arguments
291 and no function arguments. For example:
295 If a single match is found, this returns a TREE_LIST whose VALUE
296 is the constraint function (not the template), and its PURPOSE is
297 the complete set of arguments substituted into the parameter list. */
300 resolve_function_concept_overload (tree ovl
, tree args
)
303 tree cands
= NULL_TREE
;
304 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
307 if (TREE_CODE (tmpl
) != TEMPLATE_DECL
)
310 /* Don't try to deduce checks for non-concepts. We often end up trying
311 to resolve constraints in functional casts as part of a
312 postfix-expression. We can save time and headaches by not
313 instantiating those declarations.
315 NOTE: This masks a potential error, caused by instantiating
316 non-deduced contexts using placeholder arguments. */
317 tree fn
= DECL_TEMPLATE_RESULT (tmpl
);
318 if (DECL_ARGUMENTS (fn
))
320 if (!DECL_DECLARED_CONCEPT_P (fn
))
323 /* Remember the candidate if we can deduce a substitution. */
324 ++processing_template_decl
;
325 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
326 if (tree subst
= coerce_template_parms (parms
, args
, tmpl
, tf_none
))
328 if (subst
== error_mark_node
)
331 cands
= tree_cons (subst
, fn
, cands
);
333 --processing_template_decl
;
337 /* We either had no candidates or failed deductions. */
338 return nerrs
? error_mark_node
: NULL_TREE
;
339 else if (TREE_CHAIN (cands
))
340 /* There are multiple candidates. */
341 return error_mark_node
;
346 /* Determine if the call expression CALL is a constraint check, and
347 return the concept declaration and arguments being checked. If CALL
348 does not denote a constraint check, return NULL. */
351 resolve_function_concept_check (tree call
)
353 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
355 /* A constraint check must be only a template-id expression.
356 If it's a call to a base-link, its function(s) should be a
357 template-id expression. If this is not a template-id, then
358 it cannot be a concept-check. */
359 tree target
= CALL_EXPR_FN (call
);
360 if (BASELINK_P (target
))
361 target
= BASELINK_FUNCTIONS (target
);
362 if (TREE_CODE (target
) != TEMPLATE_ID_EXPR
)
365 /* Get the overload set and template arguments and try to
366 resolve the target. */
367 tree ovl
= TREE_OPERAND (target
, 0);
369 /* This is a function call of a variable concept... ill-formed. */
370 if (TREE_CODE (ovl
) == TEMPLATE_DECL
)
372 error_at (location_of (call
),
373 "function call of variable concept %qE", call
);
374 return error_mark_node
;
377 tree args
= TREE_OPERAND (target
, 1);
378 return resolve_function_concept_overload (ovl
, args
);
381 /* Returns a pair containing the checked concept and its associated
382 prototype parameter. The result is a TREE_LIST whose TREE_VALUE
383 is the concept (non-template) and whose TREE_PURPOSE contains
384 the converted template arguments, including the deduced prototype
385 parameter (in position 0). */
388 resolve_concept_check (tree check
)
390 gcc_assert (concept_check_p (check
));
391 tree id
= unpack_concept_check (check
);
392 tree tmpl
= TREE_OPERAND (id
, 0);
394 /* If this is an overloaded function concept, perform overload
395 resolution (this only happens when deducing prototype parameters
396 and template introductions). */
397 if (TREE_CODE (tmpl
) == OVERLOAD
)
399 if (OVL_CHAIN (tmpl
))
400 return resolve_function_concept_check (check
);
401 tmpl
= OVL_FIRST (tmpl
);
404 tree args
= TREE_OPERAND (id
, 1);
405 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
406 ++processing_template_decl
;
407 tree result
= coerce_template_parms (parms
, args
, tmpl
, tf_none
);
408 --processing_template_decl
;
409 if (result
== error_mark_node
)
410 return error_mark_node
;
411 return build_tree_list (result
, DECL_TEMPLATE_RESULT (tmpl
));
414 /* Given a call expression or template-id expression to a concept EXPR
415 possibly including a wildcard, deduce the concept being checked and
416 the prototype parameter. Returns true if the constraint and prototype
417 can be deduced and false otherwise. Note that the CHECK and PROTO
418 arguments are set to NULL_TREE if this returns false. */
421 deduce_constrained_parameter (tree expr
, tree
& check
, tree
& proto
)
423 tree info
= resolve_concept_check (expr
);
424 if (info
&& info
!= error_mark_node
)
426 check
= TREE_VALUE (info
);
427 tree arg
= TREE_VEC_ELT (TREE_PURPOSE (info
), 0);
428 if (ARGUMENT_PACK_P (arg
))
429 arg
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0);
430 proto
= TREE_TYPE (arg
);
434 check
= proto
= NULL_TREE
;
438 /* Given a call expression or template-id expression to a concept, EXPR,
439 deduce the concept being checked and return the template arguments.
440 Returns NULL_TREE if deduction fails. */
442 deduce_concept_introduction (tree check
)
444 tree info
= resolve_concept_check (check
);
445 if (info
&& info
!= error_mark_node
)
446 return TREE_PURPOSE (info
);
450 /* Build a constrained placeholder type where SPEC is a type-constraint.
451 SPEC can be anything were concept_definition_p is true.
453 Returns a pair whose FIRST is the concept being checked and whose
454 SECOND is the prototype parameter. */
457 finish_type_constraints (tree spec
, tree args
, tsubst_flags_t complain
)
459 gcc_assert (concept_definition_p (spec
));
461 /* Build an initial concept check. */
462 tree check
= build_type_constraint (spec
, args
, complain
);
463 if (check
== error_mark_node
)
464 return std::make_pair (error_mark_node
, NULL_TREE
);
466 /* Extract the concept and prototype parameter from the check. */
469 if (!deduce_constrained_parameter (check
, con
, proto
))
470 return std::make_pair (error_mark_node
, NULL_TREE
);
472 return std::make_pair (con
, proto
);
475 /*---------------------------------------------------------------------------
476 Expansion of concept definitions
477 ---------------------------------------------------------------------------*/
479 /* Returns the expression of a function concept. */
482 get_returned_expression (tree fn
)
484 /* Extract the body of the function minus the return expression. */
485 tree body
= DECL_SAVED_TREE (fn
);
487 return error_mark_node
;
488 if (TREE_CODE (body
) == BIND_EXPR
)
489 body
= BIND_EXPR_BODY (body
);
490 if (TREE_CODE (body
) != RETURN_EXPR
)
491 return error_mark_node
;
493 return TREE_OPERAND (body
, 0);
496 /* Returns the initializer of a variable concept. */
499 get_variable_initializer (tree var
)
501 tree init
= DECL_INITIAL (var
);
503 return error_mark_node
;
504 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
505 && CONSTRUCTOR_NELTS (init
) == 1)
506 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
510 /* Returns the definition of a variable or function concept. */
513 get_concept_definition (tree decl
)
515 if (TREE_CODE (decl
) == OVERLOAD
)
516 decl
= OVL_FIRST (decl
);
518 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
519 decl
= DECL_TEMPLATE_RESULT (decl
);
521 if (TREE_CODE (decl
) == CONCEPT_DECL
)
522 return DECL_INITIAL (decl
);
524 return get_variable_initializer (decl
);
525 if (TREE_CODE (decl
) == FUNCTION_DECL
)
526 return get_returned_expression (decl
);
530 /*---------------------------------------------------------------------------
531 Normalization of expressions
533 This set of functions will transform an expression into a constraint
534 in a sequence of steps.
535 ---------------------------------------------------------------------------*/
538 debug_parameter_mapping (tree map
)
540 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
542 tree parm
= TREE_VALUE (p
);
543 tree arg
= TREE_PURPOSE (p
);
545 verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm
), arg
);
547 verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm
), arg
);
548 // debug_tree (parm);
554 debug_argument_list (tree args
)
556 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
558 tree arg
= TREE_VEC_ELT (args
, i
);
560 verbatim ("argument %qT", arg
);
562 verbatim ("argument %qE", arg
);
566 /* Associate each parameter in PARMS with its corresponding template
570 map_arguments (tree parms
, tree args
)
572 for (tree p
= parms
; p
; p
= TREE_CHAIN (p
))
577 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
578 TREE_PURPOSE (p
) = TMPL_ARG (args
, level
, index
);
581 TREE_PURPOSE (p
) = template_parm_to_arg (p
);
586 /* Build the parameter mapping for EXPR using ARGS, where CTX_PARMS
587 are the template parameters in scope for EXPR. */
590 build_parameter_mapping (tree expr
, tree args
, tree ctx_parms
)
592 tree parms
= find_template_parameters (expr
, ctx_parms
);
593 tree map
= map_arguments (parms
, args
);
597 /* True if the parameter mappings of two atomic constraints formed
598 from the same expression are equivalent. */
601 parameter_mapping_equivalent_p (tree t1
, tree t2
)
603 tree map1
= ATOMIC_CONSTR_MAP (t1
);
604 tree map2
= ATOMIC_CONSTR_MAP (t2
);
607 gcc_checking_assert (TREE_VALUE (map1
) == TREE_VALUE (map2
));
608 tree arg1
= TREE_PURPOSE (map1
);
609 tree arg2
= TREE_PURPOSE (map2
);
610 if (!template_args_equal (arg1
, arg2
))
612 map1
= TREE_CHAIN (map1
);
613 map2
= TREE_CHAIN (map2
);
615 gcc_checking_assert (!map1
&& !map2
);
619 /* Provides additional context for normalization. */
621 struct norm_info
: subst_info
623 explicit norm_info (tsubst_flags_t cmp
)
624 : norm_info (NULL_TREE
, cmp
)
627 /* Construct a top-level context for DECL. */
629 norm_info (tree in_decl
, tsubst_flags_t complain
)
630 : subst_info (tf_warning_or_error
| complain
, in_decl
)
634 initial_parms
= DECL_TEMPLATE_PARMS (in_decl
);
635 if (generate_diagnostics ())
636 context
= build_tree_list (NULL_TREE
, in_decl
);
639 initial_parms
= current_template_parms
;
642 bool generate_diagnostics() const
644 return complain
& tf_norm
;
647 void update_context(tree expr
, tree args
)
649 if (generate_diagnostics ())
651 tree map
= build_parameter_mapping (expr
, args
, ctx_parms ());
652 context
= tree_cons (map
, expr
, context
);
654 in_decl
= get_concept_check_template (expr
);
657 /* Returns the template parameters that are in scope for the current
658 normalization context. */
663 return DECL_TEMPLATE_PARMS (in_decl
);
665 return initial_parms
;
668 /* Provides information about the source of a constraint. This is a
669 TREE_LIST whose VALUE is either a concept check or a constrained
670 declaration. The PURPOSE, for concept checks is a parameter mapping
673 tree context
= NULL_TREE
;
675 /* The declaration whose constraints we're normalizing. The targets
676 of the parameter mapping of each atom will be in terms of the
677 template parameters of ORIG_DECL. */
679 tree initial_parms
= NULL_TREE
;
682 static tree
normalize_expression (tree
, tree
, norm_info
);
684 /* Transform a logical-or or logical-and expression into either
685 a conjunction or disjunction. */
688 normalize_logical_operation (tree t
, tree args
, tree_code c
, norm_info info
)
690 tree t0
= normalize_expression (TREE_OPERAND (t
, 0), args
, info
);
691 tree t1
= normalize_expression (TREE_OPERAND (t
, 1), args
, info
);
693 /* Build a new info object for the constraint. */
694 tree ci
= info
.generate_diagnostics()
695 ? build_tree_list (t
, info
.context
)
698 return build2 (c
, ci
, t0
, t1
);
702 normalize_concept_check (tree check
, tree args
, norm_info info
)
704 tree id
= unpack_concept_check (check
);
705 tree tmpl
= TREE_OPERAND (id
, 0);
706 tree targs
= TREE_OPERAND (id
, 1);
708 /* A function concept is wrapped in an overload. */
709 if (TREE_CODE (tmpl
) == OVERLOAD
)
711 /* TODO: Can we diagnose this error during parsing? */
712 if (TREE_CODE (check
) == TEMPLATE_ID_EXPR
)
713 error_at (EXPR_LOC_OR_LOC (check
, input_location
),
714 "function concept must be called");
715 tmpl
= OVL_FIRST (tmpl
);
718 /* Substitute through the arguments of the concept check. */
720 targs
= tsubst_template_args (targs
, args
, info
.complain
, info
.in_decl
);
721 if (targs
== error_mark_node
)
722 return error_mark_node
;
724 /* Build the substitution for the concept definition. */
725 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
726 /* Turn on template processing; coercing non-type template arguments
727 will automatically assume they're non-dependent. */
728 ++processing_template_decl
;
729 tree subst
= coerce_template_parms (parms
, targs
, tmpl
, tf_none
);
730 --processing_template_decl
;
731 if (subst
== error_mark_node
)
732 return error_mark_node
;
734 /* The concept may have been ill-formed. */
735 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
736 if (def
== error_mark_node
)
737 return error_mark_node
;
739 info
.update_context (check
, args
);
740 return normalize_expression (def
, subst
, info
);
743 /* Used by normalize_atom to cache ATOMIC_CONSTRs. */
745 static GTY((deletable
)) hash_table
<atom_hasher
> *atom_cache
;
747 /* The normal form of an atom depends on the expression. The normal
748 form of a function call to a function concept is a check constraint
749 for that concept. The normal form of a reference to a variable
750 concept is a check constraint for that concept. Otherwise, the
751 constraint is a predicate constraint. */
754 normalize_atom (tree t
, tree args
, norm_info info
)
756 /* Concept checks are not atomic. */
757 if (concept_check_p (t
))
758 return normalize_concept_check (t
, args
, info
);
760 /* Build the parameter mapping for the atom. */
761 tree map
= build_parameter_mapping (t
, args
, info
.ctx_parms ());
763 /* Build a new info object for the atom. */
764 tree ci
= build_tree_list (t
, info
.context
);
766 tree atom
= build1 (ATOMIC_CONSTR
, ci
, map
);
768 /* Remember whether the expression of this atomic constraint belongs to
769 a concept definition by inspecting in_decl, which should always be set
770 in this case either by norm_info::update_context (when recursing into a
771 concept-id during normalization) or by normalize_concept_definition
772 (when starting out with a concept-id). */
773 if (info
.in_decl
&& concept_definition_p (info
.in_decl
))
774 ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom
) = true;
776 if (!info
.generate_diagnostics ())
778 /* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
779 later can cheaply compare two atoms using just pointer equality. */
781 atom_cache
= hash_table
<atom_hasher
>::create_ggc (31);
782 tree
*slot
= atom_cache
->find_slot (atom
, INSERT
);
786 /* Find all template parameters used in the targets of the parameter
787 mapping, and store a list of them in the TREE_TYPE of the mapping.
788 This list will be used by sat_hasher to determine the subset of
789 supplied template arguments that the satisfaction value of the atom
793 tree targets
= make_tree_vec (list_length (map
));
795 for (tree node
= map
; node
; node
= TREE_CHAIN (node
))
797 tree target
= TREE_PURPOSE (node
);
798 TREE_VEC_ELT (targets
, i
++) = target
;
800 tree target_parms
= find_template_parameters (targets
,
802 TREE_TYPE (map
) = target_parms
;
810 /* Returns the normal form of an expression. */
813 normalize_expression (tree t
, tree args
, norm_info info
)
818 if (t
== error_mark_node
)
819 return error_mark_node
;
821 switch (TREE_CODE (t
))
823 case TRUTH_ANDIF_EXPR
:
824 return normalize_logical_operation (t
, args
, CONJ_CONSTR
, info
);
825 case TRUTH_ORIF_EXPR
:
826 return normalize_logical_operation (t
, args
, DISJ_CONSTR
, info
);
828 return normalize_atom (t
, args
, info
);
832 /* Cache of the normalized form of constraints. Marked as deletable because it
833 can all be recalculated. */
834 static GTY((deletable
)) hash_map
<tree
,tree
> *normalized_map
;
837 get_normalized_constraints (tree t
, norm_info info
)
839 auto_timevar
time (TV_CONSTRAINT_NORM
);
840 return normalize_expression (t
, NULL_TREE
, info
);
843 /* Returns the normalized constraints from a constraint-info object
844 or NULL_TREE if the constraints are null. IN_DECL provides the
845 declaration to which the constraints belong. */
848 get_normalized_constraints_from_info (tree ci
, tree in_decl
, bool diag
= false)
853 /* Substitution errors during normalization are fatal. */
854 ++processing_template_decl
;
855 norm_info
info (in_decl
, diag
? tf_norm
: tf_none
);
856 tree t
= get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci
), info
);
857 --processing_template_decl
;
862 /* Returns the normalized constraints for the declaration D. */
865 get_normalized_constraints_from_decl (tree d
, bool diag
= false)
870 /* For inherited constructors, consider the original declaration;
871 it has the correct template information attached. */
872 d
= strip_inheriting_ctors (d
);
874 if (regenerated_lambda_fn_p (d
))
876 /* If this lambda was regenerated, DECL_TEMPLATE_PARMS doesn't contain
877 all in-scope template parameters, but the lambda from which it was
878 ultimately regenerated does, so use that instead. */
879 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (d
));
880 lambda
= most_general_lambda (lambda
);
881 d
= lambda_function (lambda
);
884 if (TREE_CODE (d
) == TEMPLATE_DECL
)
887 decl
= DECL_TEMPLATE_RESULT (tmpl
);
891 if (tree ti
= DECL_TEMPLATE_INFO (d
))
892 tmpl
= TI_TEMPLATE (ti
);
898 /* Get the most general template for the declaration, and compute
899 arguments from that. This ensures that the arguments used for
900 normalization are always template parameters and not arguments
901 used for outer specializations. For example:
905 template<typename U> requires C<T, U> void f(U);
910 When we normalize the requirements for S<int>::f, we want the
911 arguments to be {T, U}, not {int, U}. One reason for this is that
912 accepting the latter causes the template parameter level of U
913 to be reduced in a way that makes it overly difficult substitute
914 concrete arguments (i.e., eventually {int, int} during satisfaction. */
917 if (DECL_LANG_SPECIFIC(tmpl
) && !DECL_TEMPLATE_SPECIALIZATION (tmpl
))
918 tmpl
= most_general_template (tmpl
);
921 d
= tmpl
? tmpl
: decl
;
923 /* If we're not diagnosing errors, use cached constraints, if any. */
925 if (tree
*p
= hash_map_safe_get (normalized_map
, d
))
928 tree norm
= NULL_TREE
;
929 if (tree ci
= get_constraints (d
))
931 push_access_scope_guard
pas (decl
);
932 norm
= get_normalized_constraints_from_info (ci
, tmpl
, diag
);
936 hash_map_safe_put
<hm_ggc
> (normalized_map
, d
, norm
);
941 /* Returns the normal form of TMPL's definition. */
944 normalize_concept_definition (tree tmpl
, bool diag
= false)
947 if (tree
*p
= hash_map_safe_get (normalized_map
, tmpl
))
950 gcc_assert (concept_definition_p (tmpl
));
952 tmpl
= OVL_FIRST (tmpl
);
953 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
954 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
955 ++processing_template_decl
;
956 norm_info
info (tmpl
, diag
? tf_norm
: tf_none
);
957 tree norm
= get_normalized_constraints (def
, info
);
958 --processing_template_decl
;
961 hash_map_safe_put
<hm_ggc
> (normalized_map
, tmpl
, norm
);
966 /* Normalize an EXPR as a constraint. */
969 normalize_constraint_expression (tree expr
, norm_info info
)
971 if (!expr
|| expr
== error_mark_node
)
974 if (!info
.generate_diagnostics ())
975 if (tree
*p
= hash_map_safe_get (normalized_map
, expr
))
978 ++processing_template_decl
;
979 tree norm
= get_normalized_constraints (expr
, info
);
980 --processing_template_decl
;
982 if (!info
.generate_diagnostics ())
983 hash_map_safe_put
<hm_ggc
> (normalized_map
, expr
, norm
);
988 /* 17.4.1.2p2. Two constraints are identical if they are formed
989 from the same expression and the targets of the parameter mapping
993 atomic_constraints_identical_p (tree t1
, tree t2
)
995 gcc_assert (TREE_CODE (t1
) == ATOMIC_CONSTR
);
996 gcc_assert (TREE_CODE (t2
) == ATOMIC_CONSTR
);
998 if (ATOMIC_CONSTR_EXPR (t1
) != ATOMIC_CONSTR_EXPR (t2
))
1001 if (!parameter_mapping_equivalent_p (t1
, t2
))
1007 /* True if T1 and T2 are equivalent, meaning they have the same syntactic
1008 structure and all corresponding constraints are identical. */
1011 constraints_equivalent_p (tree t1
, tree t2
)
1013 gcc_assert (CONSTR_P (t1
));
1014 gcc_assert (CONSTR_P (t2
));
1016 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1019 switch (TREE_CODE (t1
))
1023 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1025 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
1029 if (!atomic_constraints_identical_p(t1
, t2
))
1038 /* Compute the hash value for T. */
1041 hash_atomic_constraint (tree t
)
1043 gcc_assert (TREE_CODE (t
) == ATOMIC_CONSTR
);
1045 /* Hash the identity of the expression. */
1046 hashval_t val
= htab_hash_pointer (ATOMIC_CONSTR_EXPR (t
));
1048 /* Hash the targets of the parameter map. */
1049 tree p
= ATOMIC_CONSTR_MAP (t
);
1052 val
= iterative_hash_template_arg (TREE_PURPOSE (p
), val
);
1063 add_constraint (tree t
, hash
& h
)
1065 h
.add_int(TREE_CODE (t
));
1066 switch (TREE_CODE (t
))
1070 add_constraint (TREE_OPERAND (t
, 0), h
);
1071 add_constraint (TREE_OPERAND (t
, 1), h
);
1074 h
.merge_hash (hash_atomic_constraint (t
));
1083 /* Computes a hash code for the constraint T. */
1086 iterative_hash_constraint (tree t
, hashval_t val
)
1088 gcc_assert (CONSTR_P (t
));
1089 inchash::hash
h (val
);
1090 inchash::add_constraint (t
, h
);
1094 // -------------------------------------------------------------------------- //
1095 // Constraint Semantic Processing
1097 // The following functions are called by the parser and substitution rules
1098 // to create and evaluate constraint-related nodes.
1100 // The constraints associated with the current template parameters.
1102 current_template_constraints (void)
1104 if (!current_template_parms
)
1106 tree tmpl_constr
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
1107 return build_constraints (tmpl_constr
, NULL_TREE
);
1110 /* If the recently parsed TYPE declares or defines a template or
1111 template specialization, get its corresponding constraints from the
1112 current template parameters and bind them to TYPE's declaration. */
1115 associate_classtype_constraints (tree type
)
1117 if (!type
|| type
== error_mark_node
|| !CLASS_TYPE_P (type
))
1120 /* An explicit class template specialization has no template parameters. */
1121 if (!current_template_parms
)
1124 if (CLASSTYPE_IS_TEMPLATE (type
) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1126 tree decl
= TYPE_STUB_DECL (type
);
1127 tree ci
= current_template_constraints ();
1129 /* An implicitly instantiated member template declaration already
1130 has associated constraints. If it is defined outside of its
1131 class, then we need match these constraints against those of
1132 original declaration. */
1133 if (tree orig_ci
= get_constraints (decl
))
1135 if (int extra_levels
= (TMPL_PARMS_DEPTH (current_template_parms
)
1136 - TMPL_ARGS_DEPTH (TYPE_TI_ARGS (type
))))
1138 /* If there is a discrepancy between the current template depth
1139 and the template depth of the original declaration, then we
1140 must be redeclaring a class template as part of a friend
1141 declaration within another class template. Before matching
1142 constraints, we need to reduce the template parameter level
1143 within the current constraints via substitution. */
1144 tree outer_gtargs
= template_parms_to_args (current_template_parms
);
1145 TREE_VEC_LENGTH (outer_gtargs
) = extra_levels
;
1146 ci
= tsubst_constraint_info (ci
, outer_gtargs
, tf_none
, NULL_TREE
);
1148 if (!equivalent_constraints (ci
, orig_ci
))
1150 error ("%qT does not match original declaration", type
);
1151 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1152 location_t loc
= DECL_SOURCE_LOCATION (tmpl
);
1153 inform (loc
, "original template declaration here");
1154 /* Fall through, so that we define the type anyway. */
1158 set_constraints (decl
, ci
);
1163 /* Create an empty constraint info block. */
1165 static inline tree_constraint_info
*
1166 build_constraint_info ()
1168 return (tree_constraint_info
*)make_node (CONSTRAINT_INFO
);
1171 /* Build a constraint-info object that contains the associated constraints
1172 of a declaration. This also includes the declaration's template
1173 requirements (TREQS) and any trailing requirements for a function
1174 declarator (DREQS). Note that both TREQS and DREQS must be constraints.
1176 If the declaration has neither template nor declaration requirements
1177 this returns NULL_TREE, indicating an unconstrained declaration. */
1180 build_constraints (tree tr
, tree dr
)
1185 tree_constraint_info
* ci
= build_constraint_info ();
1186 ci
->template_reqs
= tr
;
1187 ci
->declarator_reqs
= dr
;
1188 ci
->associated_constr
= combine_constraint_expressions (tr
, dr
);
1193 /* Add constraint RHS to the end of CONSTRAINT_INFO ci. */
1196 append_constraint (tree ci
, tree rhs
)
1198 tree tr
= ci
? CI_TEMPLATE_REQS (ci
) : NULL_TREE
;
1199 tree dr
= ci
? CI_DECLARATOR_REQS (ci
) : NULL_TREE
;
1200 dr
= combine_constraint_expressions (dr
, rhs
);
1203 CI_DECLARATOR_REQS (ci
) = dr
;
1204 tree ac
= combine_constraint_expressions (tr
, dr
);
1205 CI_ASSOCIATED_CONSTRAINTS (ci
) = ac
;
1208 ci
= build_constraints (tr
, dr
);
1212 /* A mapping from declarations to constraint information. */
1214 static GTY ((cache
)) decl_tree_cache_map
*decl_constraints
;
1216 /* Returns the template constraints of declaration T. If T is not
1217 constrained, return NULL_TREE. Note that T must be non-null. */
1220 get_constraints (const_tree t
)
1224 if (!decl_constraints
)
1227 gcc_assert (DECL_P (t
));
1228 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1229 t
= DECL_TEMPLATE_RESULT (t
);
1230 tree
* found
= decl_constraints
->get (CONST_CAST_TREE (t
));
1237 /* Associate the given constraint information CI with the declaration
1238 T. If T is a template, then the constraints are associated with
1239 its underlying declaration. Don't build associations if CI is
1243 set_constraints (tree t
, tree ci
)
1247 gcc_assert (t
&& flag_concepts
);
1248 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1249 t
= DECL_TEMPLATE_RESULT (t
);
1250 bool found
= hash_map_safe_put
<hm_ggc
> (decl_constraints
, t
, ci
);
1251 gcc_assert (!found
);
1254 /* Remove the associated constraints of the declaration T. */
1257 remove_constraints (tree t
)
1259 gcc_checking_assert (DECL_P (t
));
1260 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1261 t
= DECL_TEMPLATE_RESULT (t
);
1263 if (decl_constraints
)
1264 decl_constraints
->remove (t
);
1267 /* If DECL is a friend, substitute into REQS to produce requirements suitable
1268 for declaration matching. */
1271 maybe_substitute_reqs_for (tree reqs
, const_tree decl
)
1273 if (reqs
== NULL_TREE
)
1276 decl
= STRIP_TEMPLATE (decl
);
1277 if (DECL_UNIQUE_FRIEND_P (decl
) && DECL_TEMPLATE_INFO (decl
))
1279 tree tmpl
= DECL_TI_TEMPLATE (decl
);
1280 tree gargs
= generic_targs_for (tmpl
);
1281 processing_template_decl_sentinel s
;
1282 if (uses_template_parms (gargs
))
1283 ++processing_template_decl
;
1284 reqs
= tsubst_constraint (reqs
, gargs
,
1285 tf_warning_or_error
, NULL_TREE
);
1290 /* Returns the trailing requires clause of the declarator of
1291 a template declaration T or NULL_TREE if none. */
1294 get_trailing_function_requirements (tree t
)
1296 tree ci
= get_constraints (t
);
1299 return CI_DECLARATOR_REQS (ci
);
1302 /* Construct a sequence of template arguments by prepending
1303 ARG to REST. Either ARG or REST may be null. */
1305 build_concept_check_arguments (tree arg
, tree rest
)
1307 gcc_assert (rest
? TREE_CODE (rest
) == TREE_VEC
: true);
1311 int n
= rest
? TREE_VEC_LENGTH (rest
) : 0;
1312 args
= make_tree_vec (n
+ 1);
1313 TREE_VEC_ELT (args
, 0) = arg
;
1315 for (int i
= 0; i
< n
; ++i
)
1316 TREE_VEC_ELT (args
, i
+ 1) = TREE_VEC_ELT (rest
, i
);
1317 int def
= rest
? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest
) : 0;
1318 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, def
+ 1);
1327 /* Builds an id-expression of the form `C<Args...>()` where C is a function
1331 build_function_check (tree tmpl
, tree args
, tsubst_flags_t
/*complain*/)
1333 if (TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1335 /* If we just got a template, wrap it in an overload so it looks like any
1336 other template-id. */
1337 tmpl
= ovl_make (tmpl
);
1338 TREE_TYPE (tmpl
) = boolean_type_node
;
1341 /* Perform function concept resolution now so we always have a single
1342 function of the overload set (even if we started with only one; the
1343 resolution function converts template arguments). Note that we still
1344 wrap this in an overload set so we don't upset other parts of the
1345 compiler that expect template-ids referring to function concepts
1346 to have an overload set. */
1347 tree info
= resolve_function_concept_overload (tmpl
, args
);
1348 if (info
== error_mark_node
)
1349 return error_mark_node
;
1352 error ("no matching concepts for %qE", tmpl
);
1353 return error_mark_node
;
1355 args
= TREE_PURPOSE (info
);
1356 tmpl
= DECL_TI_TEMPLATE (TREE_VALUE (info
));
1358 /* Rebuild the singleton overload set; mark the type bool. */
1359 tmpl
= ovl_make (tmpl
, NULL_TREE
);
1360 TREE_TYPE (tmpl
) = boolean_type_node
;
1362 /* Build the id-expression around the overload set. */
1363 tree id
= build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1365 /* Finally, build the call expression around the overload. */
1366 ++processing_template_decl
;
1367 vec
<tree
, va_gc
> *fargs
= make_tree_vector ();
1368 tree call
= build_min_nt_call_vec (id
, fargs
);
1369 TREE_TYPE (call
) = boolean_type_node
;
1370 release_tree_vector (fargs
);
1371 --processing_template_decl
;
1376 /* Builds an id-expression of the form `C<Args...>` where C is a variable
1380 build_variable_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1382 gcc_assert (variable_concept_p (tmpl
));
1383 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1384 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1385 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1386 if (args
== error_mark_node
)
1387 return error_mark_node
;
1388 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1391 /* Builds an id-expression of the form `C<Args...>` where C is a standard
1395 build_standard_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1397 gcc_assert (standard_concept_p (tmpl
));
1398 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1399 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1400 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1401 if (args
== error_mark_node
)
1402 return error_mark_node
;
1403 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1406 /* Construct an expression that checks TARGET using ARGS. */
1409 build_concept_check (tree target
, tree args
, tsubst_flags_t complain
)
1411 return build_concept_check (target
, NULL_TREE
, args
, complain
);
1414 /* Construct an expression that checks the concept given by DECL. If
1415 concept_definition_p (DECL) is false, this returns null. */
1418 build_concept_check (tree decl
, tree arg
, tree rest
, tsubst_flags_t complain
)
1420 tree args
= build_concept_check_arguments (arg
, rest
);
1422 if (standard_concept_p (decl
))
1423 return build_standard_check (decl
, args
, complain
);
1424 if (variable_concept_p (decl
))
1425 return build_variable_check (decl
, args
, complain
);
1426 if (function_concept_p (decl
))
1427 return build_function_check (decl
, args
, complain
);
1429 return error_mark_node
;
1432 /* Build a template-id that can participate in a concept check. */
1435 build_concept_id (tree decl
, tree args
)
1437 tree check
= build_concept_check (decl
, args
, tf_warning_or_error
);
1438 if (check
== error_mark_node
)
1439 return error_mark_node
;
1440 return unpack_concept_check (check
);
1443 /* Build a template-id that can participate in a concept check, preserving
1444 the source location of the original template-id. */
1447 build_concept_id (tree expr
)
1449 gcc_assert (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
);
1450 tree id
= build_concept_id (TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
1451 protected_set_expr_location (id
, cp_expr_location (expr
));
1455 /* Build as template-id with a placeholder that can be used as a
1458 Note that this will diagnose errors if the initial concept check
1462 build_type_constraint (tree decl
, tree args
, tsubst_flags_t complain
)
1464 tree wildcard
= build_nt (WILDCARD_DECL
);
1465 ++processing_template_decl
;
1466 tree check
= build_concept_check (decl
, wildcard
, args
, complain
);
1467 --processing_template_decl
;
1468 if (check
== error_mark_node
)
1469 return error_mark_node
;
1470 return unpack_concept_check (check
);
1473 /* Returns a TYPE_DECL that contains sufficient information to
1474 build a template parameter of the same kind as PROTO and
1475 constrained by the concept declaration CNC. Note that PROTO
1476 is the first template parameter of CNC.
1478 If specified, ARGS provides additional arguments to the
1479 constraint check. */
1481 build_constrained_parameter (tree cnc
, tree proto
, tree args
)
1483 tree name
= DECL_NAME (cnc
);
1484 tree type
= TREE_TYPE (proto
);
1485 tree decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
1486 CONSTRAINED_PARM_PROTOTYPE (decl
) = proto
;
1487 CONSTRAINED_PARM_CONCEPT (decl
) = cnc
;
1488 CONSTRAINED_PARM_EXTRA_ARGS (decl
) = args
;
1492 /* Create a constraint expression for the given DECL that evaluates the
1493 requirements specified by CONSTR, a TYPE_DECL that contains all the
1494 information necessary to build the requirements (see finish_concept_name
1495 for the layout of that TYPE_DECL).
1497 Note that the constraints are neither reduced nor decomposed. That is
1498 done only after the requires clause has been parsed (or not). */
1501 finish_shorthand_constraint (tree decl
, tree constr
)
1503 /* No requirements means no constraints. */
1507 if (error_operand_p (constr
))
1510 tree proto
= CONSTRAINED_PARM_PROTOTYPE (constr
);
1511 tree con
= CONSTRAINED_PARM_CONCEPT (constr
);
1512 tree args
= CONSTRAINED_PARM_EXTRA_ARGS (constr
);
1514 /* The TS lets use shorthand to constrain a pack of arguments, but the
1517 For the TS, consider:
1519 template<C... Ts> struct s;
1521 If C is variadic (and because Ts is a pack), we associate the
1522 constraint C<Ts...>. In all other cases, we associate
1523 the constraint (C<Ts> && ...).
1525 The standard behavior cannot be overridden by -fconcepts-ts. */
1526 bool variadic_concept_p
= template_parameter_pack_p (proto
);
1527 bool declared_pack_p
= template_parameter_pack_p (decl
);
1528 bool apply_to_each_p
= (cxx_dialect
>= cxx20
) ? true : !variadic_concept_p
;
1530 /* Get the argument and overload used for the requirement
1531 and adjust it if we're going to expand later. */
1532 tree arg
= template_parm_to_arg (decl
);
1533 if (apply_to_each_p
&& declared_pack_p
)
1534 arg
= PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0));
1536 /* Build the concept constraint-expression. */
1537 tree tmpl
= DECL_TI_TEMPLATE (con
);
1539 if (TREE_CODE (con
) == FUNCTION_DECL
)
1540 check
= ovl_make (tmpl
);
1541 check
= build_concept_check (check
, arg
, args
, tf_warning_or_error
);
1543 /* Make the check a fold-expression if needed. */
1544 if (apply_to_each_p
&& declared_pack_p
)
1545 check
= finish_left_unary_fold_expr (check
, TRUTH_ANDIF_EXPR
);
1550 /* Returns a conjunction of shorthand requirements for the template
1551 parameter list PARMS. Note that the requirements are stored in
1552 the TYPE of each tree node. */
1555 get_shorthand_constraints (tree parms
)
1557 tree result
= NULL_TREE
;
1558 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1559 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
1561 tree parm
= TREE_VEC_ELT (parms
, i
);
1562 tree constr
= TEMPLATE_PARM_CONSTRAINTS (parm
);
1563 result
= combine_constraint_expressions (result
, constr
);
1568 /* Get the deduced wildcard from a DEDUCED placeholder. If the deduced
1569 wildcard is a pack, return the first argument of that pack. */
1572 get_deduced_wildcard (tree wildcard
)
1574 if (ARGUMENT_PACK_P (wildcard
))
1575 wildcard
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard
), 0);
1576 gcc_assert (TREE_CODE (wildcard
) == WILDCARD_DECL
);
1580 /* Returns the prototype parameter for the nth deduced wildcard. */
1583 get_introduction_prototype (tree wildcards
, int index
)
1585 return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards
, index
)));
1588 /* Introduce a type template parameter. */
1591 introduce_type_template_parameter (tree wildcard
, bool& non_type_p
)
1594 return finish_template_type_parm (class_type_node
, DECL_NAME (wildcard
));
1597 /* Introduce a template template parameter. */
1600 introduce_template_template_parameter (tree wildcard
, bool& non_type_p
)
1603 begin_template_parm_list ();
1604 current_template_parms
= DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard
));
1605 end_template_parm_list ();
1606 return finish_template_template_parm (class_type_node
, DECL_NAME (wildcard
));
1609 /* Introduce a template non-type parameter. */
1612 introduce_nontype_template_parameter (tree wildcard
, bool& non_type_p
)
1615 tree parm
= copy_decl (TREE_TYPE (wildcard
));
1616 DECL_NAME (parm
) = DECL_NAME (wildcard
);
1620 /* Introduce a single template parameter. */
1623 build_introduced_template_parameter (tree wildcard
, bool& non_type_p
)
1625 tree proto
= TREE_TYPE (wildcard
);
1628 if (TREE_CODE (proto
) == TYPE_DECL
)
1629 parm
= introduce_type_template_parameter (wildcard
, non_type_p
);
1630 else if (TREE_CODE (proto
) == TEMPLATE_DECL
)
1631 parm
= introduce_template_template_parameter (wildcard
, non_type_p
);
1633 parm
= introduce_nontype_template_parameter (wildcard
, non_type_p
);
1635 /* Wrap in a TREE_LIST for process_template_parm. Note that introduced
1636 parameters do not retain the defaults from the source parameter. */
1637 return build_tree_list (NULL_TREE
, parm
);
1640 /* Introduce a single template parameter. */
1643 introduce_template_parameter (tree parms
, tree wildcard
)
1645 gcc_assert (!ARGUMENT_PACK_P (wildcard
));
1646 tree proto
= TREE_TYPE (wildcard
);
1647 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1649 /* Diagnose the case where we have C{...Args}. */
1650 if (WILDCARD_PACK_P (wildcard
))
1652 tree id
= DECL_NAME (wildcard
);
1653 error_at (loc
, "%qE cannot be introduced with an ellipsis %<...%>", id
);
1654 inform (DECL_SOURCE_LOCATION (proto
), "prototype declared here");
1658 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1659 return process_template_parm (parms
, loc
, parm
, non_type_p
, false);
1662 /* Introduce a template parameter pack. */
1665 introduce_template_parameter_pack (tree parms
, tree wildcard
)
1668 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1669 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1670 return process_template_parm (parms
, loc
, parm
, non_type_p
, true);
1673 /* Introduce the nth template parameter. */
1676 introduce_template_parameter (tree parms
, tree wildcards
, int& index
)
1678 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1679 return introduce_template_parameter (parms
, deduced
);
1682 /* Introduce either a template parameter pack or a list of template
1686 introduce_template_parameters (tree parms
, tree wildcards
, int& index
)
1688 /* If the prototype was a parameter, we better have deduced an
1689 argument pack, and that argument must be the last deduced value
1690 in the wildcard vector. */
1691 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1692 gcc_assert (ARGUMENT_PACK_P (deduced
));
1693 gcc_assert (index
== TREE_VEC_LENGTH (wildcards
));
1695 /* Introduce each element in the pack. */
1696 tree args
= ARGUMENT_PACK_ARGS (deduced
);
1697 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1699 tree arg
= TREE_VEC_ELT (args
, i
);
1700 if (WILDCARD_PACK_P (arg
))
1701 parms
= introduce_template_parameter_pack (parms
, arg
);
1703 parms
= introduce_template_parameter (parms
, arg
);
1709 /* Builds the template parameter list PARMS by chaining introduced
1710 parameters from the WILDCARD vector. INDEX is the position of
1711 the current parameter. */
1714 process_introduction_parms (tree parms
, tree wildcards
, int& index
)
1716 tree proto
= get_introduction_prototype (wildcards
, index
);
1717 if (template_parameter_pack_p (proto
))
1718 return introduce_template_parameters (parms
, wildcards
, index
);
1720 return introduce_template_parameter (parms
, wildcards
, index
);
1723 /* Ensure that all template parameters have been introduced for the concept
1724 named in CHECK. If not, emit a diagnostic.
1726 Note that implicitly introducing a parameter with a default argument
1727 creates a case where a parameter is declared, but unnamed, making
1728 it unusable in the definition. */
1731 check_introduction_list (tree intros
, tree check
)
1733 check
= unpack_concept_check (check
);
1734 tree tmpl
= TREE_OPERAND (check
, 0);
1736 tmpl
= OVL_FIRST (tmpl
);
1738 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
1739 if (TREE_VEC_LENGTH (intros
) < TREE_VEC_LENGTH (parms
))
1741 error_at (input_location
, "all template parameters of %qD must "
1742 "be introduced", tmpl
);
1749 /* Associates a constraint check to the current template based on the
1750 introduction parameters. INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs
1751 containing a chained PARM_DECL which contains the identifier as well as
1752 the source location. TMPL_DECL is the decl for the concept being used.
1753 If we take a concept, C, this will form a check in the form of
1754 C<INTRO_LIST> filling in any extra arguments needed by the defaults
1757 Returns NULL_TREE if no concept could be matched and error_mark_node if
1758 an error occurred when matching. */
1761 finish_template_introduction (tree tmpl_decl
,
1763 location_t intro_loc
)
1765 /* Build a concept check to deduce the actual parameters. */
1766 tree expr
= build_concept_check (tmpl_decl
, intro_list
, tf_none
);
1767 if (expr
== error_mark_node
)
1769 error_at (intro_loc
, "cannot deduce template parameters from "
1770 "introduction list");
1771 return error_mark_node
;
1774 if (!check_introduction_list (intro_list
, expr
))
1775 return error_mark_node
;
1777 tree parms
= deduce_concept_introduction (expr
);
1781 /* Build template parameter scope for introduction. */
1782 tree parm_list
= NULL_TREE
;
1783 begin_template_parm_list ();
1784 int nargs
= MIN (TREE_VEC_LENGTH (parms
), TREE_VEC_LENGTH (intro_list
));
1785 for (int n
= 0; n
< nargs
; )
1786 parm_list
= process_introduction_parms (parm_list
, parms
, n
);
1787 parm_list
= end_template_parm_list (parm_list
);
1789 /* Update the number of arguments to reflect the number of deduced
1790 template parameter introductions. */
1791 nargs
= TREE_VEC_LENGTH (parm_list
);
1793 /* Determine if any errors occurred during matching. */
1794 for (int i
= 0; i
< TREE_VEC_LENGTH (parm_list
); ++i
)
1795 if (TREE_VALUE (TREE_VEC_ELT (parm_list
, i
)) == error_mark_node
)
1797 end_template_decl ();
1798 return error_mark_node
;
1801 /* Build a concept check for our constraint. */
1802 tree check_args
= make_tree_vec (nargs
);
1804 for (; n
< TREE_VEC_LENGTH (parm_list
); ++n
)
1806 tree parm
= TREE_VEC_ELT (parm_list
, n
);
1807 TREE_VEC_ELT (check_args
, n
) = template_parm_to_arg (parm
);
1809 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args
, n
);
1811 /* If the template expects more parameters we should be able
1812 to use the defaults from our deduced concept. */
1813 for (; n
< TREE_VEC_LENGTH (parms
); ++n
)
1814 TREE_VEC_ELT (check_args
, n
) = TREE_VEC_ELT (parms
, n
);
1816 /* Associate the constraint. */
1817 tree check
= build_concept_check (tmpl_decl
,
1819 tf_warning_or_error
);
1820 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
) = check
;
1826 /* Given the concept check T from a constrained-type-specifier, extract
1827 its TMPL and ARGS. FIXME why do we need two different forms of
1828 constrained-type-specifier? */
1831 placeholder_extract_concept_and_args (tree t
, tree
&tmpl
, tree
&args
)
1833 if (concept_check_p (t
))
1835 t
= unpack_concept_check (t
);
1836 tmpl
= TREE_OPERAND (t
, 0);
1837 if (TREE_CODE (tmpl
) == OVERLOAD
)
1838 tmpl
= OVL_FIRST (tmpl
);
1839 args
= TREE_OPERAND (t
, 1);
1843 if (TREE_CODE (t
) == TYPE_DECL
)
1845 /* A constrained parameter. Build a constraint check
1846 based on the prototype parameter and then extract the
1847 arguments from that. */
1848 tree proto
= CONSTRAINED_PARM_PROTOTYPE (t
);
1849 tree check
= finish_shorthand_constraint (proto
, t
);
1850 placeholder_extract_concept_and_args (check
, tmpl
, args
);
1855 /* Returns true iff the placeholders C1 and C2 are equivalent. C1
1856 and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */
1859 equivalent_placeholder_constraints (tree c1
, tree c2
)
1861 if (c1
&& TREE_CODE (c1
) == TEMPLATE_TYPE_PARM
)
1862 /* A constrained auto. */
1863 c1
= PLACEHOLDER_TYPE_CONSTRAINTS (c1
);
1864 if (c2
&& TREE_CODE (c2
) == TEMPLATE_TYPE_PARM
)
1865 c2
= PLACEHOLDER_TYPE_CONSTRAINTS (c2
);
1871 if (c1
== error_mark_node
|| c2
== error_mark_node
)
1872 /* We get here during satisfaction; when a deduction constraint
1873 fails, substitution can produce an error_mark_node for the
1874 placeholder constraints. */
1877 tree t1
, t2
, a1
, a2
;
1878 placeholder_extract_concept_and_args (c1
, t1
, a1
);
1879 placeholder_extract_concept_and_args (c2
, t2
, a2
);
1884 int len1
= TREE_VEC_LENGTH (a1
);
1885 int len2
= TREE_VEC_LENGTH (a2
);
1889 /* Skip the first argument so we don't infinitely recurse.
1890 Also, they may differ in template parameter index. */
1891 for (int i
= 1; i
< len1
; ++i
)
1893 tree t1
= TREE_VEC_ELT (a1
, i
);
1894 tree t2
= TREE_VEC_ELT (a2
, i
);
1895 if (!template_args_equal (t1
, t2
))
1901 /* Return a hash value for the placeholder ATOMIC_CONSTR C. */
1904 hash_placeholder_constraint (tree c
)
1907 placeholder_extract_concept_and_args (c
, t
, a
);
1909 /* Like hash_tmpl_and_args, but skip the first argument. */
1910 hashval_t val
= iterative_hash_object (DECL_UID (t
), 0);
1912 for (int i
= TREE_VEC_LENGTH (a
)-1; i
> 0; --i
)
1913 val
= iterative_hash_template_arg (TREE_VEC_ELT (a
, i
), val
);
1918 /* Substitute through the expression of a simple requirement or
1919 compound requirement. */
1922 tsubst_valid_expression_requirement (tree t
, tree args
, sat_info info
)
1924 tree r
= tsubst_expr (t
, args
, tf_none
, info
.in_decl
, false);
1925 if (convert_to_void (r
, ICV_STATEMENT
, tf_none
) != error_mark_node
)
1928 if (info
.diagnose_unsatisfaction_p ())
1930 location_t loc
= cp_expr_loc_or_input_loc (t
);
1931 if (diagnosing_failed_constraint::replay_errors_p ())
1933 inform (loc
, "the required expression %qE is invalid, because", t
);
1934 if (r
== error_mark_node
)
1935 tsubst_expr (t
, args
, info
.complain
, info
.in_decl
, false);
1937 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
1940 inform (loc
, "the required expression %qE is invalid", t
);
1942 else if (info
.noisy ())
1944 r
= tsubst_expr (t
, args
, info
.complain
, info
.in_decl
, false);
1945 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
1948 return error_mark_node
;
1952 /* Substitute through the simple requirement. */
1955 tsubst_simple_requirement (tree t
, tree args
, sat_info info
)
1957 tree t0
= TREE_OPERAND (t
, 0);
1958 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
1959 if (expr
== error_mark_node
)
1960 return error_mark_node
;
1961 return boolean_true_node
;
1964 /* Subroutine of tsubst_type_requirement that performs the actual substitution
1965 and diagnosing. Also used by tsubst_compound_requirement. */
1968 tsubst_type_requirement_1 (tree t
, tree args
, sat_info info
, location_t loc
)
1970 tree r
= tsubst (t
, args
, tf_none
, info
.in_decl
);
1971 if (r
!= error_mark_node
)
1974 if (info
.diagnose_unsatisfaction_p ())
1976 if (diagnosing_failed_constraint::replay_errors_p ())
1978 /* Replay the substitution error. */
1979 inform (loc
, "the required type %qT is invalid, because", t
);
1980 tsubst (t
, args
, info
.complain
, info
.in_decl
);
1983 inform (loc
, "the required type %qT is invalid", t
);
1985 else if (info
.noisy ())
1986 tsubst (t
, args
, info
.complain
, info
.in_decl
);
1988 return error_mark_node
;
1992 /* Substitute through the type requirement. */
1995 tsubst_type_requirement (tree t
, tree args
, sat_info info
)
1997 tree t0
= TREE_OPERAND (t
, 0);
1998 tree type
= tsubst_type_requirement_1 (t0
, args
, info
, EXPR_LOCATION (t
));
1999 if (type
== error_mark_node
)
2000 return error_mark_node
;
2001 return boolean_true_node
;
2004 /* True if TYPE can be deduced from EXPR. */
2007 type_deducible_p (tree expr
, tree type
, tree placeholder
, tree args
,
2010 /* Make sure deduction is performed against ( EXPR ), so that
2011 references are preserved in the result. */
2012 expr
= force_paren_expr_uneval (expr
);
2014 tree deduced_type
= do_auto_deduction (type
, expr
, placeholder
,
2015 info
.complain
, adc_requirement
,
2016 /*outer_targs=*/args
);
2018 return deduced_type
!= error_mark_node
;
2021 /* True if EXPR can not be converted to TYPE. */
2024 expression_convertible_p (tree expr
, tree type
, subst_info info
)
2027 perform_direct_initialization_if_possible (type
, expr
, false,
2029 if (conv
== error_mark_node
)
2031 if (conv
== NULL_TREE
)
2033 if (info
.complain
& tf_error
)
2035 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
2036 error_at (loc
, "cannot convert %qE to %qT", expr
, type
);
2044 /* Substitute through the compound requirement. */
2047 tsubst_compound_requirement (tree t
, tree args
, sat_info info
)
2049 tree t0
= TREE_OPERAND (t
, 0);
2050 tree t1
= TREE_OPERAND (t
, 1);
2051 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
2052 if (expr
== error_mark_node
)
2053 return error_mark_node
;
2055 location_t loc
= cp_expr_loc_or_input_loc (expr
);
2057 /* Check the noexcept condition. */
2058 bool noexcept_p
= COMPOUND_REQ_NOEXCEPT_P (t
);
2059 if (noexcept_p
&& !expr_noexcept_p (expr
, tf_none
))
2061 if (info
.diagnose_unsatisfaction_p ())
2062 inform (loc
, "%qE is not %<noexcept%>", expr
);
2064 return error_mark_node
;
2067 /* Substitute through the type expression, if any. */
2068 tree type
= tsubst_type_requirement_1 (t1
, args
, info
, EXPR_LOCATION (t
));
2069 if (type
== error_mark_node
)
2070 return error_mark_node
;
2072 subst_info
quiet (tf_none
, info
.in_decl
);
2074 /* Check expression against the result type. */
2077 if (tree placeholder
= type_uses_auto (type
))
2079 if (!type_deducible_p (expr
, type
, placeholder
, args
, quiet
))
2081 if (info
.diagnose_unsatisfaction_p ())
2083 if (diagnosing_failed_constraint::replay_errors_p ())
2086 "%qE does not satisfy return-type-requirement, "
2088 /* Further explain the reason for the error. */
2089 type_deducible_p (expr
, type
, placeholder
, args
, info
);
2093 "%qE does not satisfy return-type-requirement", t0
);
2095 return error_mark_node
;
2098 else if (!expression_convertible_p (expr
, type
, quiet
))
2100 if (info
.diagnose_unsatisfaction_p ())
2102 if (diagnosing_failed_constraint::replay_errors_p ())
2104 inform (loc
, "cannot convert %qE to %qT because", t0
, type
);
2105 /* Further explain the reason for the error. */
2106 expression_convertible_p (expr
, type
, info
);
2109 inform (loc
, "cannot convert %qE to %qT", t0
, type
);
2111 return error_mark_node
;
2115 return boolean_true_node
;
2118 /* Substitute through the nested requirement. */
2121 tsubst_nested_requirement (tree t
, tree args
, sat_info info
)
2123 sat_info
quiet (tf_none
, info
.in_decl
);
2124 tree result
= constraint_satisfaction_value (t
, args
, quiet
);
2125 if (result
== boolean_true_node
)
2126 return boolean_true_node
;
2128 if (result
== boolean_false_node
2129 && info
.diagnose_unsatisfaction_p ())
2131 tree expr
= TREE_OPERAND (t
, 0);
2132 location_t loc
= cp_expr_location (t
);
2133 if (diagnosing_failed_constraint::replay_errors_p ())
2135 /* Replay the substitution error. */
2136 inform (loc
, "nested requirement %qE is not satisfied, because", expr
);
2137 constraint_satisfaction_value (t
, args
, info
);
2140 inform (loc
, "nested requirement %qE is not satisfied", expr
);
2143 return error_mark_node
;
2146 /* Substitute ARGS into the requirement T. */
2149 tsubst_requirement (tree t
, tree args
, sat_info info
)
2151 iloc_sentinel
loc_s (cp_expr_location (t
));
2152 switch (TREE_CODE (t
))
2155 return tsubst_simple_requirement (t
, args
, info
);
2157 return tsubst_type_requirement (t
, args
, info
);
2159 return tsubst_compound_requirement (t
, args
, info
);
2161 return tsubst_nested_requirement (t
, args
, info
);
2169 declare_constraint_vars (tree parms
, tree vars
)
2172 for (tree t
= parms
; t
; t
= DECL_CHAIN (t
))
2174 if (DECL_PACK_P (t
))
2176 tree pack
= extract_fnparm_pack (t
, &s
);
2177 register_local_specialization (pack
, t
);
2181 register_local_specialization (s
, t
);
2188 /* Substitute through as if checking function parameter types. This
2189 will diagnose common parameter type errors. Returns error_mark_node
2190 if an error occurred. */
2193 check_constraint_variables (tree t
, tree args
, subst_info info
)
2195 tree types
= NULL_TREE
;
2197 while (p
&& !VOID_TYPE_P (p
))
2199 types
= tree_cons (NULL_TREE
, TREE_TYPE (p
), types
);
2202 types
= chainon (nreverse (types
), void_list_node
);
2203 return tsubst_function_parms (types
, args
, info
.complain
, info
.in_decl
);
2206 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
2207 into the parameter list T, producing a sequence of constraint
2208 variables, declared in the current scope.
2210 Note that the caller must establish a local specialization stack
2211 prior to calling this function since this substitution will
2212 declare the substituted parameters. */
2215 tsubst_constraint_variables (tree t
, tree args
, subst_info info
)
2217 /* Perform a trial substitution to check for type errors. */
2218 tree parms
= check_constraint_variables (t
, args
, info
);
2219 if (parms
== error_mark_node
)
2220 return error_mark_node
;
2222 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
2224 int saved_unevaluated_operand
= cp_unevaluated_operand
;
2225 cp_unevaluated_operand
= 0;
2226 tree vars
= tsubst (t
, args
, info
.complain
, info
.in_decl
);
2227 cp_unevaluated_operand
= saved_unevaluated_operand
;
2228 if (vars
== error_mark_node
)
2229 return error_mark_node
;
2230 return declare_constraint_vars (t
, vars
);
2233 /* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
2234 substitution of template arguments into a requires-expression
2235 may result in the formation of invalid types or expressions
2236 in its requirements ... In such cases, the expression evaluates
2237 to false; it does not cause the program to be ill-formed.
2239 When substituting through a REQUIRES_EXPR as part of template
2240 instantiation, we call this routine with info.quiet() true.
2242 When evaluating a REQUIRES_EXPR that appears outside a template in
2243 cp_parser_requires_expression, we call this routine with
2246 Finally, when diagnosing unsatisfaction from diagnose_atomic_constraint
2247 and when diagnosing a false REQUIRES_EXPR via diagnose_constraints,
2248 we call this routine with info.diagnose_unsatisfaction_p() true. */
2251 tsubst_requires_expr (tree t
, tree args
, sat_info info
)
2253 local_specialization_stack
stack (lss_copy
);
2255 /* We need to check access during the substitution. */
2256 deferring_access_check_sentinel
acs (dk_no_deferred
);
2258 /* A requires-expression is an unevaluated context. */
2261 args
= add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t
), args
,
2262 info
.complain
, info
.in_decl
);
2263 if (processing_template_decl
)
2265 /* We're partially instantiating a generic lambda. Substituting into
2266 this requires-expression now may cause its requirements to get
2267 checked out of order, so instead just remember the template
2268 arguments and wait until we can substitute them all at once. */
2270 REQUIRES_EXPR_EXTRA_ARGS (t
) = build_extra_args (t
, args
, info
.complain
);
2274 if (tree parms
= REQUIRES_EXPR_PARMS (t
))
2276 parms
= tsubst_constraint_variables (parms
, args
, info
);
2277 if (parms
== error_mark_node
)
2278 return boolean_false_node
;
2281 tree result
= boolean_true_node
;
2282 for (tree reqs
= REQUIRES_EXPR_REQS (t
); reqs
; reqs
= TREE_CHAIN (reqs
))
2284 tree req
= TREE_VALUE (reqs
);
2285 if (tsubst_requirement (req
, args
, info
) == error_mark_node
)
2287 result
= boolean_false_node
;
2288 if (info
.diagnose_unsatisfaction_p ())
2289 /* Keep going so that we diagnose all failed requirements. */;
2297 /* Public wrapper for the above. */
2300 tsubst_requires_expr (tree t
, tree args
,
2301 tsubst_flags_t complain
, tree in_decl
)
2303 sat_info
info (complain
, in_decl
);
2304 return tsubst_requires_expr (t
, args
, info
);
2307 /* Substitute ARGS into the constraint information CI, producing a new
2308 constraint record. */
2311 tsubst_constraint_info (tree t
, tree args
,
2312 tsubst_flags_t complain
, tree in_decl
)
2314 if (!t
|| t
== error_mark_node
|| !check_constraint_info (t
))
2317 tree tr
= tsubst_constraint (CI_TEMPLATE_REQS (t
), args
, complain
, in_decl
);
2318 tree dr
= tsubst_constraint (CI_DECLARATOR_REQS (t
), args
, complain
, in_decl
);
2319 return build_constraints (tr
, dr
);
2322 /* Substitute through a parameter mapping, in order to get the actual
2323 arguments used to instantiate an atomic constraint. This may fail
2324 if the substitution into arguments produces something ill-formed. */
2327 tsubst_parameter_mapping (tree map
, tree args
, subst_info info
)
2332 tsubst_flags_t complain
= info
.complain
;
2333 tree in_decl
= info
.in_decl
;
2335 tree result
= NULL_TREE
;
2336 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2338 if (p
== error_mark_node
)
2339 return error_mark_node
;
2340 tree parm
= TREE_VALUE (p
);
2341 tree arg
= TREE_PURPOSE (p
);
2343 if (ARGUMENT_PACK_P (arg
))
2344 new_arg
= tsubst_argument_pack (arg
, args
, complain
, in_decl
);
2347 new_arg
= tsubst_template_arg (arg
, args
, complain
, in_decl
);
2348 if (TYPE_P (new_arg
))
2349 new_arg
= canonicalize_type_argument (new_arg
, complain
);
2351 if (TREE_CODE (new_arg
) == TYPE_ARGUMENT_PACK
)
2353 tree pack_args
= ARGUMENT_PACK_ARGS (new_arg
);
2354 for (tree
& pack_arg
: tree_vec_range (pack_args
))
2355 if (TYPE_P (pack_arg
))
2356 pack_arg
= canonicalize_type_argument (pack_arg
, complain
);
2358 if (new_arg
== error_mark_node
)
2359 return error_mark_node
;
2361 result
= tree_cons (new_arg
, parm
, result
);
2363 return nreverse (result
);
2367 tsubst_parameter_mapping (tree map
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2369 return tsubst_parameter_mapping (map
, args
, subst_info (complain
, in_decl
));
2372 /*---------------------------------------------------------------------------
2373 Constraint satisfaction
2374 ---------------------------------------------------------------------------*/
2376 /* True if we are currently satisfying a constraint. */
2378 static bool satisfying_constraint
;
2380 /* A vector of incomplete types (and of declarations with undeduced return type),
2381 appended to by note_failed_type_completion_for_satisfaction. The
2382 satisfaction caches use this in order to keep track of "potentially unstable"
2383 satisfaction results.
2385 Since references to entries in this vector are stored only in the
2386 GC-deletable sat_cache, it's safe to make this deletable as well. */
2388 static GTY((deletable
)) vec
<tree
, va_gc
> *failed_type_completions
;
2390 /* Called whenever a type completion (or return type deduction) failure occurs
2391 that definitely affects the meaning of the program, by e.g. inducing
2392 substitution failure. */
2395 note_failed_type_completion_for_satisfaction (tree t
)
2397 if (satisfying_constraint
)
2399 gcc_checking_assert ((TYPE_P (t
) && !COMPLETE_TYPE_P (t
))
2400 || (DECL_P (t
) && undeduced_auto_decl (t
)));
2401 vec_safe_push (failed_type_completions
, t
);
2405 /* Returns true if the range [BEGIN, END) of elements within the
2406 failed_type_completions vector contains a complete type (or a
2407 declaration with a non-placeholder return type). */
2410 some_type_complete_p (int begin
, int end
)
2412 for (int i
= begin
; i
< end
; i
++)
2414 tree t
= (*failed_type_completions
)[i
];
2415 if (TYPE_P (t
) && COMPLETE_TYPE_P (t
))
2417 if (DECL_P (t
) && !undeduced_auto_decl (t
))
2423 /* Hash functions and data types for satisfaction cache entries. */
2425 struct GTY((for_user
)) sat_entry
2427 /* The relevant ATOMIC_CONSTR. */
2430 /* The relevant template arguments. */
2433 /* The result of satisfaction of ATOM+ARGS.
2434 This is either boolean_true_node, boolean_false_node or error_mark_node,
2435 where error_mark_node indicates ill-formed satisfaction.
2436 It's set to NULL_TREE while computing satisfaction of ATOM+ARGS for
2440 /* The value of input_location when satisfaction of ATOM+ARGS was first
2442 location_t location
;
2444 /* The range of elements appended to the failed_type_completions vector
2445 during computation of this satisfaction result, encoded as a begin/end
2447 int ftc_begin
, ftc_end
;
2449 /* True if we want to diagnose the above instability when it's detected.
2450 We don't always want to do so, in order to avoid emitting duplicate
2451 diagnostics in some cases. */
2452 bool diagnose_instability
;
2454 /* True if we're in the middle of computing this satisfaction result.
2455 Used during both quiet and noisy satisfaction to detect self-recursive
2460 struct sat_hasher
: ggc_ptr_hash
<sat_entry
>
2462 static hashval_t
hash (sat_entry
*e
)
2464 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e
->atom
))
2466 /* Atoms with instantiated mappings are built during satisfaction.
2467 They live only inside the sat_cache, and we build one to query
2468 the cache with each time we instantiate a mapping. */
2469 gcc_assert (!e
->args
);
2470 return hash_atomic_constraint (e
->atom
);
2473 /* Atoms with uninstantiated mappings are built during normalization.
2474 Since normalize_atom caches the atoms it returns, we can assume
2475 pointer-based identity for fast hashing and comparison. Even if this
2476 assumption is violated, that's okay, we'll just get a cache miss. */
2477 hashval_t value
= htab_hash_pointer (e
->atom
);
2479 if (tree map
= ATOMIC_CONSTR_MAP (e
->atom
))
2480 /* Only the parameters that are used in the targets of the mapping
2481 affect the satisfaction value of the atom. So we consider only
2482 the arguments for these parameters, and ignore the rest. */
2483 for (tree target_parms
= TREE_TYPE (map
);
2485 target_parms
= TREE_CHAIN (target_parms
))
2488 tree parm
= TREE_VALUE (target_parms
);
2489 template_parm_level_and_index (parm
, &level
, &index
);
2490 tree arg
= TMPL_ARG (e
->args
, level
, index
);
2491 value
= iterative_hash_template_arg (arg
, value
);
2496 static bool equal (sat_entry
*e1
, sat_entry
*e2
)
2498 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
)
2499 != ATOMIC_CONSTR_MAP_INSTANTIATED_P (e2
->atom
))
2502 /* See sat_hasher::hash. */
2503 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
))
2505 gcc_assert (!e1
->args
&& !e2
->args
);
2506 return atomic_constraints_identical_p (e1
->atom
, e2
->atom
);
2509 if (e1
->atom
!= e2
->atom
)
2512 if (tree map
= ATOMIC_CONSTR_MAP (e1
->atom
))
2513 for (tree target_parms
= TREE_TYPE (map
);
2515 target_parms
= TREE_CHAIN (target_parms
))
2518 tree parm
= TREE_VALUE (target_parms
);
2519 template_parm_level_and_index (parm
, &level
, &index
);
2520 tree arg1
= TMPL_ARG (e1
->args
, level
, index
);
2521 tree arg2
= TMPL_ARG (e2
->args
, level
, index
);
2522 if (!template_args_equal (arg1
, arg2
))
2529 /* Cache the result of satisfy_atom. */
2530 static GTY((deletable
)) hash_table
<sat_hasher
> *sat_cache
;
2532 /* Cache the result of satisfy_declaration_constraints. */
2533 static GTY((deletable
)) hash_map
<tree
, tree
> *decl_satisfied_cache
;
2535 /* A tool used by satisfy_atom to help manage satisfaction caching and to
2536 diagnose "unstable" satisfaction values. We insert into the cache only
2537 when performing satisfaction quietly. */
2539 struct satisfaction_cache
2541 satisfaction_cache (tree
, tree
, sat_info
);
2550 /* Constructor for the satisfaction_cache class. We're performing satisfaction
2551 of ATOM+ARGS according to INFO. */
2554 ::satisfaction_cache (tree atom
, tree args
, sat_info info
)
2555 : entry(nullptr), info(info
), ftc_begin(-1)
2558 sat_cache
= hash_table
<sat_hasher
>::create_ggc (31);
2560 /* When noisy, we query the satisfaction cache in order to diagnose
2561 "unstable" satisfaction values. */
2564 /* When noisy, constraints have been re-normalized, and that breaks the
2565 pointer-based identity assumption of sat_cache (for atoms with
2566 uninstantiated mappings). So undo this re-normalization by looking in
2567 the atom_cache for the corresponding atom that was used during quiet
2569 if (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2571 if (tree found
= atom_cache
->find (atom
))
2574 /* The lookup should always succeed, but if it fails then let's
2575 just leave 'entry' empty, effectively disabling the cache. */
2580 /* Look up or create the corresponding satisfaction entry. */
2584 sat_entry
**slot
= sat_cache
->find_slot (&elt
, INSERT
);
2587 else if (info
.quiet ())
2589 entry
= ggc_alloc
<sat_entry
> ();
2592 entry
->result
= NULL_TREE
;
2593 entry
->location
= input_location
;
2594 entry
->ftc_begin
= entry
->ftc_end
= -1;
2595 entry
->diagnose_instability
= false;
2596 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2597 /* We always want to diagnose instability of an atom with an
2598 instantiated parameter mapping. For atoms with an uninstantiated
2599 mapping, we set this flag (in satisfy_atom) only if substitution
2600 into its mapping previously failed. */
2601 entry
->diagnose_instability
= true;
2602 entry
->evaluating
= false;
2606 /* We shouldn't get here, but if we do, let's just leave 'entry'
2607 empty, effectively disabling the cache. */
2611 /* Returns the cached satisfaction result if we have one and we're not
2612 recomputing the satisfaction result from scratch. Otherwise returns
2616 satisfaction_cache::get ()
2621 if (entry
->evaluating
)
2623 /* If we get here, it means satisfaction is self-recursive. */
2624 gcc_checking_assert (!entry
->result
);
2626 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2627 "satisfaction of atomic constraint %qE depends on itself",
2629 return error_mark_node
;
2632 /* This satisfaction result is "potentially unstable" if a type for which
2633 type completion failed during its earlier computation is now complete. */
2634 bool maybe_unstable
= some_type_complete_p (entry
->ftc_begin
,
2637 if (info
.noisy () || maybe_unstable
|| !entry
->result
)
2639 /* We're computing the satisfaction result from scratch. */
2640 entry
->evaluating
= true;
2641 ftc_begin
= vec_safe_length (failed_type_completions
);
2645 return entry
->result
;
2648 /* RESULT is the computed satisfaction result. If RESULT differs from the
2649 previously cached result, this routine issues an appropriate error.
2650 Otherwise, when evaluating quietly, updates the cache appropriately. */
2653 satisfaction_cache::save (tree result
)
2658 gcc_checking_assert (entry
->evaluating
);
2659 entry
->evaluating
= false;
2661 if (entry
->result
&& result
!= entry
->result
)
2664 /* Return error_mark_node to force satisfaction to get replayed
2666 return error_mark_node
;
2669 if (entry
->diagnose_instability
)
2671 auto_diagnostic_group d
;
2672 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2673 "satisfaction value of atomic constraint %qE changed "
2674 "from %qE to %qE", entry
->atom
, entry
->result
, result
);
2675 inform (entry
->location
,
2676 "satisfaction value first evaluated to %qE from here",
2679 /* For sake of error recovery, allow this latest satisfaction result
2681 entry
->result
= result
;
2688 entry
->result
= result
;
2689 /* Store into this entry the list of relevant failed type completions
2690 that occurred during (re)computation of the satisfaction result. */
2691 gcc_checking_assert (ftc_begin
!= -1);
2692 entry
->ftc_begin
= ftc_begin
;
2693 entry
->ftc_end
= vec_safe_length (failed_type_completions
);
2699 /* Substitute ARGS into constraint-expression T during instantiation of
2700 a member of a class template. */
2703 tsubst_constraint (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2705 /* We also don't want to evaluate concept-checks when substituting the
2706 constraint-expressions of a declaration. */
2707 processing_constraint_expression_sentinel s
;
2709 tree expr
= tsubst_expr (t
, args
, complain
, in_decl
, false);
2713 static tree
satisfy_constraint_r (tree
, tree
, sat_info info
);
2715 /* Compute the satisfaction of a conjunction. */
2718 satisfy_conjunction (tree t
, tree args
, sat_info info
)
2720 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, info
);
2721 if (lhs
== error_mark_node
|| lhs
== boolean_false_node
)
2723 return satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, info
);
2726 /* The current depth at which we're replaying an error during recursive
2727 diagnosis of a constraint satisfaction failure. */
2729 static int current_constraint_diagnosis_depth
;
2731 /* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded
2732 CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint
2733 satisfaction error. */
2735 static bool concepts_diagnostics_max_depth_exceeded_p
;
2737 /* Recursive subroutine of collect_operands_of_disjunction. T is a normalized
2738 subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs)
2739 and E is the corresponding unnormalized subexpression (composed of
2740 TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */
2743 collect_operands_of_disjunction_r (tree t
, tree e
,
2744 auto_vec
<tree_pair
> *operands
)
2746 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
)
2748 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 0),
2749 TREE_OPERAND (e
, 0), operands
);
2750 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 1),
2751 TREE_OPERAND (e
, 1), operands
);
2755 tree_pair p
= std::make_pair (t
, e
);
2756 operands
->safe_push (p
);
2760 /* Recursively collect the normalized and unnormalized operands of the
2761 disjunction T and append them to OPERANDS in order. */
2764 collect_operands_of_disjunction (tree t
, auto_vec
<tree_pair
> *operands
)
2766 collect_operands_of_disjunction_r (t
, CONSTR_EXPR (t
), operands
);
2769 /* Compute the satisfaction of a disjunction. */
2772 satisfy_disjunction (tree t
, tree args
, sat_info info
)
2774 /* Evaluate each operand with unsatisfaction diagnostics disabled. */
2775 sat_info sub
= info
;
2776 sub
.diagnose_unsatisfaction
= false;
2778 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, sub
);
2779 if (lhs
== boolean_true_node
|| lhs
== error_mark_node
)
2782 tree rhs
= satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, sub
);
2783 if (rhs
== boolean_true_node
|| rhs
== error_mark_node
)
2786 /* Both branches evaluated to false. Explain the satisfaction failure in
2788 if (info
.diagnose_unsatisfaction_p ())
2790 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2791 cp_expr disj_expr
= CONSTR_EXPR (t
);
2792 inform (disj_expr
.get_location (),
2793 "no operand of the disjunction is satisfied");
2794 if (diagnosing_failed_constraint::replay_errors_p ())
2796 /* Replay the error in each branch of the disjunction. */
2797 auto_vec
<tree_pair
> operands
;
2798 collect_operands_of_disjunction (t
, &operands
);
2799 for (unsigned i
= 0; i
< operands
.length (); i
++)
2801 tree norm_op
= operands
[i
].first
;
2802 tree op
= operands
[i
].second
;
2803 location_t loc
= make_location (cp_expr_location (op
),
2804 disj_expr
.get_start (),
2805 disj_expr
.get_finish ());
2806 inform (loc
, "the operand %qE is unsatisfied because", op
);
2807 satisfy_constraint_r (norm_op
, args
, info
);
2812 return boolean_false_node
;
2815 /* Ensures that T is a truth value and not (accidentally, as sometimes
2816 happens) an integer value. */
2819 satisfaction_value (tree t
)
2821 if (t
== error_mark_node
|| t
== boolean_true_node
|| t
== boolean_false_node
)
2824 gcc_assert (TREE_CODE (t
) == INTEGER_CST
2825 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t
),
2826 boolean_type_node
));
2827 if (integer_zerop (t
))
2828 return boolean_false_node
;
2830 return boolean_true_node
;
2833 /* Build a new template argument vector corresponding to the parameter
2834 mapping of the atomic constraint T, using arguments from ARGS. */
2837 get_mapped_args (tree t
, tree args
)
2839 tree map
= ATOMIC_CONSTR_MAP (t
);
2841 /* No map, no arguments. */
2845 /* Determine the depth of the resulting argument vector. */
2847 if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t
))
2848 /* The expression of this atomic constraint comes from a concept definition,
2849 whose template depth is always one, so the resulting argument vector
2850 will also have depth one. */
2853 /* Otherwise, the expression of this atomic constraint comes from
2854 the context of the constrained entity, whose template depth is that
2856 depth
= TMPL_ARGS_DEPTH (args
);
2858 /* Place each argument at its corresponding position in the argument
2859 list. Note that the list will be sparse (not all arguments supplied),
2860 but instantiation is guaranteed to only use the parameters in the
2861 mapping, so null arguments would never be used. */
2862 auto_vec
< vec
<tree
> > lists (depth
);
2863 lists
.quick_grow_cleared (depth
);
2864 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2868 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
2870 /* Insert the argument into its corresponding position. */
2871 vec
<tree
> &list
= lists
[level
- 1];
2872 if (index
>= (int)list
.length ())
2873 list
.safe_grow_cleared (index
+ 1, /*exact=*/false);
2874 list
[index
] = TREE_PURPOSE (p
);
2877 /* Build the new argument list. */
2878 args
= make_tree_vec (lists
.length ());
2879 for (unsigned i
= 0; i
!= lists
.length (); ++i
)
2881 vec
<tree
> &list
= lists
[i
];
2882 tree level
= make_tree_vec (list
.length ());
2883 for (unsigned j
= 0; j
< list
.length(); ++j
)
2884 TREE_VEC_ELT (level
, j
) = list
[j
];
2885 SET_TMPL_ARGS_LEVEL (args
, i
+ 1, level
);
2888 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, 0);
2890 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
)
2891 && TMPL_ARGS_DEPTH (args
) == 1)
2893 /* Get rid of the redundant outer TREE_VEC. */
2894 tree level
= TMPL_ARGS_LEVEL (args
, 1);
2902 static void diagnose_atomic_constraint (tree
, tree
, tree
, sat_info
);
2904 /* Compute the satisfaction of an atomic constraint. */
2907 satisfy_atom (tree t
, tree args
, sat_info info
)
2909 /* In case there is a diagnostic, we want to establish the context
2910 prior to printing errors. If no errors occur, this context is
2911 removed before returning. */
2912 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2914 satisfaction_cache
cache (t
, args
, info
);
2915 if (tree r
= cache
.get ())
2918 /* Perform substitution quietly. */
2919 subst_info
quiet (tf_none
, NULL_TREE
);
2921 /* Instantiate the parameter mapping. */
2922 tree map
= tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, quiet
);
2923 if (map
== error_mark_node
)
2925 /* If instantiation of the parameter mapping fails, the constraint is
2926 not satisfied. Replay the substitution. */
2927 if (info
.diagnose_unsatisfaction_p ())
2928 tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, info
);
2930 /* Since instantiation of the parameter mapping failed, we
2931 want to diagnose potential instability of this satisfaction
2933 cache
.entry
->diagnose_instability
= true;
2934 return cache
.save (boolean_false_node
);
2937 /* Now build a new atom using the instantiated mapping. We use
2938 this atom as a second key to the satisfaction cache, and we
2939 also pass it to diagnose_atomic_constraint so that diagnostics
2940 which refer to the atom display the instantiated mapping. */
2942 ATOMIC_CONSTR_MAP (t
) = map
;
2943 gcc_assert (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
));
2944 ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
) = true;
2945 satisfaction_cache
inst_cache (t
, /*args=*/NULL_TREE
, info
);
2946 if (tree r
= inst_cache
.get ())
2948 cache
.entry
->location
= inst_cache
.entry
->location
;
2949 return cache
.save (r
);
2952 /* Rebuild the argument vector from the parameter mapping. */
2953 args
= get_mapped_args (t
, args
);
2955 /* Apply the parameter mapping (i.e., just substitute). */
2956 tree expr
= ATOMIC_CONSTR_EXPR (t
);
2957 tree result
= tsubst_expr (expr
, args
, quiet
.complain
, quiet
.in_decl
, false);
2958 if (result
== error_mark_node
)
2960 /* If substitution results in an invalid type or expression, the constraint
2961 is not satisfied. Replay the substitution. */
2962 if (info
.diagnose_unsatisfaction_p ())
2963 tsubst_expr (expr
, args
, info
.complain
, info
.in_decl
, false);
2964 return cache
.save (inst_cache
.save (boolean_false_node
));
2967 /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary,
2968 and EXPR shall be a constant expression of type bool. */
2969 result
= force_rvalue (result
, info
.complain
);
2970 if (result
== error_mark_node
)
2971 return cache
.save (inst_cache
.save (error_mark_node
));
2972 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
2975 diagnose_atomic_constraint (t
, args
, result
, info
);
2976 return cache
.save (inst_cache
.save (error_mark_node
));
2979 /* Compute the value of the constraint. */
2982 iloc_sentinel
ils (EXPR_LOCATION (result
));
2983 result
= cxx_constant_value (result
);
2987 result
= maybe_constant_value (result
, NULL_TREE
,
2988 /*manifestly_const_eval=*/true);
2989 if (!TREE_CONSTANT (result
))
2990 result
= error_mark_node
;
2992 result
= satisfaction_value (result
);
2993 if (result
== boolean_false_node
&& info
.diagnose_unsatisfaction_p ())
2994 diagnose_atomic_constraint (t
, args
, result
, info
);
2996 return cache
.save (inst_cache
.save (result
));
2999 /* Determine if the normalized constraint T is satisfied.
3000 Returns boolean_true_node if the expression/constraint is
3001 satisfied, boolean_false_node if not, and error_mark_node
3002 if the there was an error evaluating the constraint.
3004 The parameter mapping of atomic constraints is simply the
3005 set of template arguments that will be substituted into
3006 the expression, regardless of template parameters appearing
3007 withing. Whether a template argument is used in the atomic
3008 constraint only matters for subsumption. */
3011 satisfy_constraint_r (tree t
, tree args
, sat_info info
)
3013 if (t
== error_mark_node
)
3014 return error_mark_node
;
3016 switch (TREE_CODE (t
))
3019 return satisfy_conjunction (t
, args
, info
);
3021 return satisfy_disjunction (t
, args
, info
);
3023 return satisfy_atom (t
, args
, info
);
3029 /* Check that the normalized constraint T is satisfied for ARGS. */
3032 satisfy_normalized_constraints (tree t
, tree args
, sat_info info
)
3034 auto_timevar
time (TV_CONSTRAINT_SAT
);
3036 auto ovr
= make_temp_override (satisfying_constraint
, true);
3038 /* Turn off template processing. Constraint satisfaction only applies
3039 to non-dependent terms, so we want to ensure full checking here. */
3040 processing_template_decl_sentinel
proc (true);
3042 /* We need to check access during satisfaction. */
3043 deferring_access_check_sentinel
acs (dk_no_deferred
);
3045 /* Constraints are unevaluated operands. */
3048 return satisfy_constraint_r (t
, args
, info
);
3051 /* Return the normal form of the constraints on the placeholder 'auto'
3055 normalize_placeholder_type_constraints (tree t
, bool diag
)
3057 gcc_assert (is_auto (t
));
3058 tree ci
= PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t
);
3062 tree constr
= TREE_VALUE (ci
);
3063 /* The TREE_PURPOSE contains the set of template parameters that were in
3064 scope for this placeholder type; use them as the initial template
3065 parameters for normalization. */
3066 tree initial_parms
= TREE_PURPOSE (ci
);
3068 /* The 'auto' itself is used as the first argument in its own constraints,
3069 and its level is one greater than its template depth. So in order to
3070 capture all used template parameters, we need to add an extra level of
3071 template parameters to the context; a dummy level suffices. */
3073 = tree_cons (size_int (initial_parms
3074 ? TMPL_PARMS_DEPTH (initial_parms
) + 1 : 1),
3075 make_tree_vec (0), initial_parms
);
3077 norm_info
info (diag
? tf_norm
: tf_none
);
3078 info
.initial_parms
= initial_parms
;
3079 return normalize_constraint_expression (constr
, info
);
3082 /* Evaluate the constraints of T using ARGS, returning a satisfaction value.
3083 Here, T can be a concept-id, nested-requirement, placeholder 'auto', or
3084 requires-expression. */
3087 satisfy_nondeclaration_constraints (tree t
, tree args
, sat_info info
)
3089 if (t
== error_mark_node
)
3090 return error_mark_node
;
3092 /* Handle REQUIRES_EXPR directly, bypassing satisfaction. */
3093 if (TREE_CODE (t
) == REQUIRES_EXPR
)
3095 auto ovr
= make_temp_override (current_constraint_diagnosis_depth
);
3097 ++current_constraint_diagnosis_depth
;
3098 return tsubst_requires_expr (t
, args
, info
);
3101 /* Get the normalized constraints. */
3103 if (concept_check_p (t
))
3106 tree id
= unpack_concept_check (t
);
3107 args
= TREE_OPERAND (id
, 1);
3108 tree tmpl
= get_concept_check_template (id
);
3109 norm
= normalize_concept_definition (tmpl
, info
.noisy ());
3111 else if (TREE_CODE (t
) == NESTED_REQ
)
3113 norm_info
ninfo (info
.noisy () ? tf_norm
: tf_none
);
3114 /* The TREE_TYPE contains the set of template parameters that were in
3115 scope for this nested requirement; use them as the initial template
3116 parameters for normalization. */
3117 ninfo
.initial_parms
= TREE_TYPE (t
);
3118 norm
= normalize_constraint_expression (TREE_OPERAND (t
, 0), ninfo
);
3120 else if (is_auto (t
))
3122 norm
= normalize_placeholder_type_constraints (t
, info
.noisy ());
3124 return boolean_true_node
;
3129 /* Perform satisfaction. */
3130 return satisfy_normalized_constraints (norm
, args
, info
);
3133 /* Evaluate the associated constraints of the template specialization T
3134 according to INFO, returning a satisfaction value. */
3137 satisfy_declaration_constraints (tree t
, sat_info info
)
3139 gcc_assert (DECL_P (t
) && TREE_CODE (t
) != TEMPLATE_DECL
);
3140 const tree saved_t
= t
;
3142 /* For inherited constructors, consider the original declaration;
3143 it has the correct template information attached. */
3144 t
= strip_inheriting_ctors (t
);
3145 tree inh_ctor_targs
= NULL_TREE
;
3147 if (tree ti
= DECL_TEMPLATE_INFO (saved_t
))
3148 /* The inherited constructor points to an instantiation of a constructor
3149 template; remember its template arguments. */
3150 inh_ctor_targs
= TI_ARGS (ti
);
3152 /* Update the declaration for diagnostics. */
3156 if (tree
*result
= hash_map_safe_get (decl_satisfied_cache
, saved_t
))
3159 tree args
= NULL_TREE
;
3160 if (tree ti
= DECL_TEMPLATE_INFO (t
))
3162 /* The initial parameter mapping is the complete set of
3163 template arguments substituted into the declaration. */
3164 args
= TI_ARGS (ti
);
3166 args
= add_outermost_template_args (args
, inh_ctor_targs
);
3169 if (regenerated_lambda_fn_p (t
))
3171 /* The TI_ARGS of a regenerated lambda contains only the innermost
3172 set of template arguments. Augment this with the outer template
3173 arguments that were used to regenerate the lambda. */
3174 gcc_assert (!args
|| TMPL_ARGS_DEPTH (args
) == 1);
3175 tree regen_args
= lambda_regenerating_args (t
);
3177 args
= add_to_template_args (regen_args
, args
);
3182 /* If the innermost arguments are dependent, or if the outer arguments
3183 are dependent and are needed by the constraints, we can't check
3184 satisfaction yet so pretend they're satisfied for now. */
3185 if (uses_template_parms (args
)
3186 && ((DECL_TEMPLATE_INFO (t
)
3187 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))
3188 && (TMPL_ARGS_DEPTH (args
) == 1
3189 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))))
3190 || uses_outer_template_parms_in_constraints (t
)))
3191 return boolean_true_node
;
3193 /* Get the normalized constraints. */
3194 tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ());
3196 unsigned ftc_count
= vec_safe_length (failed_type_completions
);
3198 tree result
= boolean_true_node
;
3201 if (!push_tinst_level (t
))
3203 push_to_top_level ();
3204 push_access_scope (t
);
3205 result
= satisfy_normalized_constraints (norm
, args
, info
);
3206 pop_access_scope (t
);
3207 pop_from_top_level ();
3211 /* True if this satisfaction is (heuristically) potentially unstable, i.e.
3212 if its result may depend on where in the program it was performed. */
3213 bool maybe_unstable_satisfaction
= false;
3214 if (ftc_count
!= vec_safe_length (failed_type_completions
))
3215 /* Type completion failure occurred during satisfaction. The satisfaction
3216 result may (or may not) materially depend on the completeness of a type,
3217 so we consider it potentially unstable. */
3218 maybe_unstable_satisfaction
= true;
3220 if (maybe_unstable_satisfaction
)
3221 /* Don't cache potentially unstable satisfaction, to allow satisfy_atom
3222 to check the stability the next time around. */;
3223 else if (info
.quiet ())
3224 hash_map_safe_put
<hm_ggc
> (decl_satisfied_cache
, saved_t
, result
);
3229 /* Evaluate the associated constraints of the template T using ARGS as the
3230 innermost set of template arguments and according to INFO, returning a
3231 satisfaction value. */
3234 satisfy_declaration_constraints (tree t
, tree args
, sat_info info
)
3236 /* Update the declaration for diagnostics. */
3239 gcc_assert (TREE_CODE (t
) == TEMPLATE_DECL
);
3241 if (regenerated_lambda_fn_p (t
))
3243 /* As in the two-parameter version of this function. */
3244 gcc_assert (TMPL_ARGS_DEPTH (args
) == 1);
3245 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t
));
3246 tree outer_args
= TI_ARGS (LAMBDA_EXPR_REGEN_INFO (lambda
));
3247 args
= add_to_template_args (outer_args
, args
);
3250 args
= add_outermost_template_args (t
, args
);
3252 /* If the innermost arguments are dependent, or if the outer arguments
3253 are dependent and are needed by the constraints, we can't check
3254 satisfaction yet so pretend they're satisfied for now. */
3255 if (uses_template_parms (args
)
3256 && (TMPL_ARGS_DEPTH (args
) == 1
3257 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))
3258 || uses_outer_template_parms_in_constraints (t
)))
3259 return boolean_true_node
;
3261 tree result
= boolean_true_node
;
3262 if (tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ()))
3264 if (!push_tinst_level (t
, args
))
3266 tree pattern
= DECL_TEMPLATE_RESULT (t
);
3267 push_to_top_level ();
3268 push_access_scope (pattern
);
3269 result
= satisfy_normalized_constraints (norm
, args
, info
);
3270 pop_access_scope (pattern
);
3271 pop_from_top_level ();
3278 /* A wrapper around satisfy_declaration_constraints and
3279 satisfy_nondeclaration_constraints which additionally replays
3280 quiet ill-formed satisfaction noisily, so that ill-formed
3281 satisfaction always gets diagnosed. */
3284 constraint_satisfaction_value (tree t
, tree args
, sat_info info
)
3290 r
= satisfy_declaration_constraints (t
, args
, info
);
3292 r
= satisfy_declaration_constraints (t
, info
);
3295 r
= satisfy_nondeclaration_constraints (t
, args
, info
);
3296 if (r
== error_mark_node
&& info
.quiet ()
3297 && !(DECL_P (t
) && warning_suppressed_p (t
)))
3299 /* Replay the error noisily. */
3300 sat_info
noisy (tf_warning_or_error
, info
.in_decl
);
3301 constraint_satisfaction_value (t
, args
, noisy
);
3302 if (DECL_P (t
) && !args
)
3303 /* Avoid giving these errors again. */
3304 suppress_warning (t
);
3309 /* True iff the result of satisfying T using ARGS is BOOLEAN_TRUE_NODE
3310 and false otherwise, even in the case of errors.
3313 - a template declaration
3314 - a template specialization (in which case ARGS must be empty)
3315 - a concept-id (in which case ARGS must be empty)
3316 - a nested-requirement
3317 - a placeholder 'auto'
3318 - a requires-expression. */
3321 constraints_satisfied_p (tree t
, tree args
/*= NULL_TREE */)
3326 sat_info
quiet (tf_none
, NULL_TREE
);
3327 return constraint_satisfaction_value (t
, args
, quiet
) == boolean_true_node
;
3330 /* Evaluate a concept check of the form C<ARGS>. This is only used for the
3331 evaluation of template-ids as id-expressions. */
3334 evaluate_concept_check (tree check
)
3336 if (check
== error_mark_node
)
3337 return error_mark_node
;
3339 gcc_assert (concept_check_p (check
));
3341 /* Check for satisfaction without diagnostics. */
3342 sat_info
quiet (tf_none
, NULL_TREE
);
3343 return constraint_satisfaction_value (check
, /*args=*/NULL_TREE
, quiet
);
3346 /* Evaluate the requires-expression T, returning either boolean_true_node
3347 or boolean_false_node. This is used during folding and constexpr
3351 evaluate_requires_expr (tree t
)
3353 gcc_assert (TREE_CODE (t
) == REQUIRES_EXPR
);
3354 sat_info
quiet (tf_none
, NULL_TREE
);
3355 return constraint_satisfaction_value (t
, /*args=*/NULL_TREE
, quiet
);
3358 /*---------------------------------------------------------------------------
3359 Semantic analysis of requires-expressions
3360 ---------------------------------------------------------------------------*/
3362 /* Finish a requires expression for the given PARMS (possibly
3363 null) and the non-empty sequence of requirements. */
3366 finish_requires_expr (location_t loc
, tree parms
, tree reqs
)
3368 /* Build the node. */
3369 tree r
= build_min (REQUIRES_EXPR
, boolean_type_node
, parms
, reqs
, NULL_TREE
);
3370 TREE_SIDE_EFFECTS (r
) = false;
3371 TREE_CONSTANT (r
) = true;
3372 SET_EXPR_LOCATION (r
, loc
);
3376 /* Construct a requirement for the validity of EXPR. */
3379 finish_simple_requirement (location_t loc
, tree expr
)
3381 tree r
= build_nt (SIMPLE_REQ
, expr
);
3382 SET_EXPR_LOCATION (r
, loc
);
3386 /* Construct a requirement for the validity of TYPE. */
3389 finish_type_requirement (location_t loc
, tree type
)
3391 tree r
= build_nt (TYPE_REQ
, type
);
3392 SET_EXPR_LOCATION (r
, loc
);
3396 /* Construct a requirement for the validity of EXPR, along with
3397 its properties. if TYPE is non-null, then it specifies either
3398 an implicit conversion or argument deduction constraint,
3399 depending on whether any placeholders occur in the type name.
3400 NOEXCEPT_P is true iff the noexcept keyword was specified. */
3403 finish_compound_requirement (location_t loc
, tree expr
, tree type
, bool noexcept_p
)
3405 tree req
= build_nt (COMPOUND_REQ
, expr
, type
);
3406 SET_EXPR_LOCATION (req
, loc
);
3407 COMPOUND_REQ_NOEXCEPT_P (req
) = noexcept_p
;
3411 /* Finish a nested requirement. */
3414 finish_nested_requirement (location_t loc
, tree expr
)
3416 /* Build the requirement, saving the set of in-scope template
3417 parameters as its type. */
3418 tree r
= build1 (NESTED_REQ
, current_template_parms
, expr
);
3419 SET_EXPR_LOCATION (r
, loc
);
3423 /* Check that FN satisfies the structural requirements of a
3424 function concept definition. */
3426 check_function_concept (tree fn
)
3428 /* Check that the function is comprised of only a return statement. */
3429 tree body
= DECL_SAVED_TREE (fn
);
3430 if (TREE_CODE (body
) == BIND_EXPR
)
3431 body
= BIND_EXPR_BODY (body
);
3433 /* Sometimes a function call results in the creation of clean up
3434 points. Allow these to be preserved in the body of the
3435 constraint, as we might actually need them for some constexpr
3437 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
3438 body
= TREE_OPERAND (body
, 0);
3440 /* Check that the definition is written correctly. */
3441 if (TREE_CODE (body
) != RETURN_EXPR
)
3443 location_t loc
= DECL_SOURCE_LOCATION (fn
);
3444 if (TREE_CODE (body
) == STATEMENT_LIST
&& !STATEMENT_LIST_HEAD (body
))
3447 /* The definition was probably erroneous, not empty. */;
3449 error_at (loc
, "definition of concept %qD is empty", fn
);
3452 error_at (loc
, "definition of concept %qD has multiple statements", fn
);
3458 /*---------------------------------------------------------------------------
3459 Equivalence of constraints
3460 ---------------------------------------------------------------------------*/
3462 /* Returns true when A and B are equivalent constraints. */
3464 equivalent_constraints (tree a
, tree b
)
3466 gcc_assert (!a
|| TREE_CODE (a
) == CONSTRAINT_INFO
);
3467 gcc_assert (!b
|| TREE_CODE (b
) == CONSTRAINT_INFO
);
3468 return cp_tree_equal (a
, b
);
3471 /* Returns true if the template declarations A and B have equivalent
3472 constraints. This is the case when A's constraints subsume B's and
3473 when B's also constrain A's. */
3475 equivalently_constrained (tree d1
, tree d2
)
3477 gcc_assert (TREE_CODE (d1
) == TREE_CODE (d2
));
3478 return equivalent_constraints (get_constraints (d1
), get_constraints (d2
));
3481 /*---------------------------------------------------------------------------
3482 Partial ordering of constraints
3483 ---------------------------------------------------------------------------*/
3485 /* Returns true when the constraints in CI strictly subsume
3486 the associated constraints of TMPL. */
3489 strictly_subsumes (tree ci
, tree tmpl
)
3491 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3492 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3494 return subsumes (n1
, n2
) && !subsumes (n2
, n1
);
3497 /* Returns true when the constraints in CI subsume the
3498 associated constraints of TMPL. */
3501 weakly_subsumes (tree ci
, tree tmpl
)
3503 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3504 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3506 return subsumes (n1
, n2
);
3509 /* Determines which of the declarations, A or B, is more constrained.
3510 That is, which declaration's constraints subsume but are not subsumed
3513 Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
3514 than D1, and 0 otherwise. */
3517 more_constrained (tree d1
, tree d2
)
3519 tree n1
= get_normalized_constraints_from_decl (d1
);
3520 tree n2
= get_normalized_constraints_from_decl (d2
);
3523 if (subsumes (n1
, n2
))
3525 if (subsumes (n2
, n1
))
3530 /* Return whether D1 is at least as constrained as D2. */
3533 at_least_as_constrained (tree d1
, tree d2
)
3535 tree n1
= get_normalized_constraints_from_decl (d1
);
3536 tree n2
= get_normalized_constraints_from_decl (d2
);
3538 return subsumes (n1
, n2
);
3541 /*---------------------------------------------------------------------------
3542 Constraint diagnostics
3543 ---------------------------------------------------------------------------*/
3545 /* Returns the best location to diagnose a constraint error. */
3548 get_constraint_error_location (tree t
)
3550 if (location_t loc
= cp_expr_location (t
))
3553 /* If we have a specific location give it. */
3554 tree expr
= CONSTR_EXPR (t
);
3555 if (location_t loc
= cp_expr_location (expr
))
3558 /* If the constraint is normalized from a requires-clause, give
3559 the location as that of the constrained declaration. */
3560 tree cxt
= CONSTR_CONTEXT (t
);
3561 tree src
= cxt
? TREE_VALUE (cxt
) : NULL_TREE
;
3563 /* TODO: This only happens for constrained non-template declarations. */
3565 else if (DECL_P (src
))
3566 return DECL_SOURCE_LOCATION (src
);
3567 /* Otherwise, give the location as the defining concept. */
3568 else if (concept_check_p (src
))
3570 tree id
= unpack_concept_check (src
);
3571 tree tmpl
= TREE_OPERAND (id
, 0);
3573 tmpl
= OVL_FIRST (tmpl
);
3574 return DECL_SOURCE_LOCATION (tmpl
);
3577 return input_location
;
3580 /* Emit a diagnostic for a failed trait. */
3583 diagnose_trait_expr (tree expr
, tree args
)
3585 location_t loc
= cp_expr_location (expr
);
3587 /* Build a "fake" version of the instantiated trait, so we can
3588 get the instantiated types from result. */
3589 ++processing_template_decl
;
3590 expr
= tsubst_expr (expr
, args
, tf_none
, NULL_TREE
, false);
3591 --processing_template_decl
;
3593 tree t1
= TRAIT_EXPR_TYPE1 (expr
);
3594 tree t2
= TRAIT_EXPR_TYPE2 (expr
);
3595 switch (TRAIT_EXPR_KIND (expr
))
3597 case CPTK_HAS_NOTHROW_ASSIGN
:
3598 inform (loc
, " %qT is not nothrow copy assignable", t1
);
3600 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
3601 inform (loc
, " %qT is not nothrow default constructible", t1
);
3603 case CPTK_HAS_NOTHROW_COPY
:
3604 inform (loc
, " %qT is not nothrow copy constructible", t1
);
3606 case CPTK_HAS_TRIVIAL_ASSIGN
:
3607 inform (loc
, " %qT is not trivially copy assignable", t1
);
3609 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
3610 inform (loc
, " %qT is not trivially default constructible", t1
);
3612 case CPTK_HAS_TRIVIAL_COPY
:
3613 inform (loc
, " %qT is not trivially copy constructible", t1
);
3615 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
3616 inform (loc
, " %qT is not trivially destructible", t1
);
3618 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
3619 inform (loc
, " %qT does not have a virtual destructor", t1
);
3621 case CPTK_IS_ABSTRACT
:
3622 inform (loc
, " %qT is not an abstract class", t1
);
3624 case CPTK_IS_BASE_OF
:
3625 inform (loc
, " %qT is not a base of %qT", t1
, t2
);
3628 inform (loc
, " %qT is not a class", t1
);
3631 inform (loc
, " %qT is not an empty class", t1
);
3634 inform (loc
, " %qT is not an enum", t1
);
3637 inform (loc
, " %qT is not a final class", t1
);
3639 case CPTK_IS_LAYOUT_COMPATIBLE
:
3640 inform (loc
, " %qT is not layout compatible with %qT", t1
, t2
);
3642 case CPTK_IS_LITERAL_TYPE
:
3643 inform (loc
, " %qT is not a literal type", t1
);
3645 case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF
:
3646 inform (loc
, " %qT is not pointer-interconvertible base of %qT",
3650 inform (loc
, " %qT is not a POD type", t1
);
3652 case CPTK_IS_POLYMORPHIC
:
3653 inform (loc
, " %qT is not a polymorphic type", t1
);
3656 inform (loc
, " %qT is not the same as %qT", t1
, t2
);
3658 case CPTK_IS_STD_LAYOUT
:
3659 inform (loc
, " %qT is not an standard layout type", t1
);
3661 case CPTK_IS_TRIVIAL
:
3662 inform (loc
, " %qT is not a trivial type", t1
);
3665 inform (loc
, " %qT is not a union", t1
);
3667 case CPTK_IS_AGGREGATE
:
3668 inform (loc
, " %qT is not an aggregate", t1
);
3670 case CPTK_IS_TRIVIALLY_COPYABLE
:
3671 inform (loc
, " %qT is not trivially copyable", t1
);
3673 case CPTK_IS_ASSIGNABLE
:
3674 inform (loc
, " %qT is not assignable from %qT", t1
, t2
);
3676 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
3677 inform (loc
, " %qT is not trivially assignable from %qT", t1
, t2
);
3679 case CPTK_IS_NOTHROW_ASSIGNABLE
:
3680 inform (loc
, " %qT is not nothrow assignable from %qT", t1
, t2
);
3682 case CPTK_IS_CONSTRUCTIBLE
:
3684 inform (loc
, " %qT is not default constructible", t1
);
3686 inform (loc
, " %qT is not constructible from %qE", t1
, t2
);
3688 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
3690 inform (loc
, " %qT is not trivially default constructible", t1
);
3692 inform (loc
, " %qT is not trivially constructible from %qE", t1
, t2
);
3694 case CPTK_IS_NOTHROW_CONSTRUCTIBLE
:
3696 inform (loc
, " %qT is not nothrow default constructible", t1
);
3698 inform (loc
, " %qT is not nothrow constructible from %qE", t1
, t2
);
3700 case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS
:
3701 inform (loc
, " %qT does not have unique object representations", t1
);
3703 case CPTK_IS_CONVERTIBLE
:
3704 inform (loc
, " %qT is not convertible from %qE", t2
, t1
);
3706 case CPTK_IS_NOTHROW_CONVERTIBLE
:
3707 inform (loc
, " %qT is not nothrow convertible from %qE", t2
, t1
);
3709 case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY
:
3710 inform (loc
, " %qT is not a reference that binds to a temporary "
3711 "object of type %qT (direct-initialization)", t1
, t2
);
3713 case CPTK_REF_CONVERTS_FROM_TEMPORARY
:
3714 inform (loc
, " %qT is not a reference that binds to a temporary "
3715 "object of type %qT (copy-initialization)", t1
, t2
);
3717 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
3719 #include "cp-trait.def"
3720 #undef DEFTRAIT_TYPE
3721 /* Type-yielding traits aren't expressions. */
3723 /* We deliberately omit the default case so that when adding a new
3724 trait we'll get reminded (by way of a warning) to handle it here. */
3728 /* Diagnose a substitution failure in the atomic constraint T using ARGS. */
3731 diagnose_atomic_constraint (tree t
, tree args
, tree result
, sat_info info
)
3733 /* If the constraint is already ill-formed, we've previously diagnosed
3734 the reason. We should still say why the constraints aren't satisfied. */
3735 if (t
== error_mark_node
)
3739 loc
= DECL_SOURCE_LOCATION (info
.in_decl
);
3741 loc
= input_location
;
3742 inform (loc
, "invalid constraints");
3746 location_t loc
= get_constraint_error_location (t
);
3747 iloc_sentinel
loc_s (loc
);
3749 /* Generate better diagnostics for certain kinds of expressions. */
3750 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3751 STRIP_ANY_LOCATION_WRAPPER (expr
);
3752 switch (TREE_CODE (expr
))
3755 diagnose_trait_expr (expr
, args
);
3758 gcc_checking_assert (info
.diagnose_unsatisfaction_p ());
3759 /* Clear in_decl before replaying the substitution to avoid emitting
3760 seemingly unhelpful "in declaration ..." notes that follow some
3761 substitution failure error messages. */
3762 info
.in_decl
= NULL_TREE
;
3763 tsubst_requires_expr (expr
, args
, info
);
3766 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3767 error_at (loc
, "constraint %qE has type %qT, not %<bool%>",
3768 t
, TREE_TYPE (result
));
3770 inform (loc
, "the expression %qE evaluated to %<false%>", t
);
3774 GTY(()) tree current_failed_constraint
;
3776 diagnosing_failed_constraint::
3777 diagnosing_failed_constraint (tree t
, tree args
, bool diag
)
3778 : diagnosing_error (diag
)
3780 if (diagnosing_error
)
3782 current_failed_constraint
3783 = tree_cons (args
, t
, current_failed_constraint
);
3784 ++current_constraint_diagnosis_depth
;
3788 diagnosing_failed_constraint::
3789 ~diagnosing_failed_constraint ()
3791 if (diagnosing_error
)
3793 --current_constraint_diagnosis_depth
;
3794 if (current_failed_constraint
)
3795 current_failed_constraint
= TREE_CHAIN (current_failed_constraint
);
3800 /* Whether we are allowed to replay an error that underlies a constraint failure
3801 at the current diagnosis depth. */
3804 diagnosing_failed_constraint::replay_errors_p ()
3806 if (current_constraint_diagnosis_depth
>= concepts_diagnostics_max_depth
)
3808 concepts_diagnostics_max_depth_exceeded_p
= true;
3815 /* Emit diagnostics detailing the failure ARGS to satisfy the constraints
3816 of T. Here, T and ARGS are as in constraints_satisfied_p. */
3819 diagnose_constraints (location_t loc
, tree t
, tree args
)
3821 inform (loc
, "constraints not satisfied");
3823 if (concepts_diagnostics_max_depth
== 0)
3826 /* Replay satisfaction, but diagnose unsatisfaction. */
3827 sat_info
noisy (tf_warning_or_error
, NULL_TREE
, /*diag_unsat=*/true);
3828 constraint_satisfaction_value (t
, args
, noisy
);
3830 static bool suggested_p
;
3831 if (concepts_diagnostics_max_depth_exceeded_p
3832 && current_constraint_diagnosis_depth
== 0
3835 inform (UNKNOWN_LOCATION
,
3836 "set %qs to at least %d for more detail",
3837 "-fconcepts-diagnostics-depth=",
3838 concepts_diagnostics_max_depth
+ 1);
3843 #include "gt-cp-constraint.h"