1 /* Processing rules for constraints.
2 Copyright (C) 2013-2024 Free Software Foundation, Inc.
3 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "double-int.h"
36 #include "stringpool.h"
41 #include "c-family/c-common.h"
42 #include "c-family/c-objc.h"
43 #include "cp-objcp-common.h"
44 #include "tree-inline.h"
47 #include "type-utils.h"
49 static tree
satisfaction_value (tree t
);
51 /* When we're parsing or substuting a constraint expression, we have slightly
52 different expression semantics. In particular, we don't want to reduce a
53 concept-id to a satisfaction value. */
55 processing_constraint_expression_sentinel::
56 processing_constraint_expression_sentinel ()
58 ++scope_chain
->x_processing_constraint
;
61 processing_constraint_expression_sentinel::
62 ~processing_constraint_expression_sentinel ()
64 --scope_chain
->x_processing_constraint
;
68 processing_constraint_expression_p ()
70 return scope_chain
->x_processing_constraint
!= 0;
73 /*---------------------------------------------------------------------------
74 Constraint expressions
75 ---------------------------------------------------------------------------*/
77 /* Information provided to substitution. */
81 subst_info (tsubst_flags_t cmp
, tree in
)
82 : complain (cmp
), in_decl (in
)
85 /* True if we should not diagnose errors. */
88 return !(complain
& tf_warning_or_error
);
91 /* True if we should diagnose errors. */
97 tsubst_flags_t complain
;
101 /* Provides additional context for satisfaction.
104 - The flag noisy() controls whether to diagnose ill-formed satisfaction,
105 such as the satisfaction value of an atom being non-bool or non-constant.
106 - The flag diagnose_unsatisfaction_p() controls whether to additionally
107 explain why a constraint is not satisfied.
108 - We enter satisfaction with noisy+unsat from diagnose_constraints.
109 - We enter satisfaction with noisy-unsat from the replay inside
110 constraint_satisfaction_value.
111 - We enter satisfaction quietly (both flags cleared) from
112 constraints_satisfied_p.
114 During evaluation of a requires-expression:
115 - The flag noisy() controls whether to diagnose ill-formed types and
116 expressions inside its requirements.
117 - The flag diagnose_unsatisfaction_p() controls whether to additionally
118 explain why the requires-expression evaluates to false.
119 - We enter tsubst_requires_expr with noisy+unsat from
120 diagnose_atomic_constraint and potentially from
121 satisfy_nondeclaration_constraints.
122 - We enter tsubst_requires_expr with noisy-unsat from
123 cp_parser_requires_expression when processing a requires-expression that
124 appears outside a template.
125 - We enter tsubst_requires_expr quietly (both flags cleared) when
126 substituting through a requires-expression as part of template
129 struct sat_info
: subst_info
131 sat_info (tsubst_flags_t cmp
, tree in
, bool diag_unsat
= false)
132 : subst_info (cmp
, in
), diagnose_unsatisfaction (diag_unsat
)
134 if (diagnose_unsatisfaction_p ())
135 gcc_checking_assert (noisy ());
138 /* True if we should diagnose the cause of satisfaction failure.
141 diagnose_unsatisfaction_p () const
143 return diagnose_unsatisfaction
;
146 bool diagnose_unsatisfaction
;
149 static tree
constraint_satisfaction_value (tree
, tree
, sat_info
);
151 /* True if T is known to be some type other than bool. Note that this
152 is false for dependent types and errors. */
155 known_non_bool_p (tree t
)
157 return (t
&& !WILDCARD_TYPE_P (t
) && TREE_CODE (t
) != BOOLEAN_TYPE
);
161 check_constraint_atom (cp_expr expr
)
163 if (known_non_bool_p (TREE_TYPE (expr
)))
165 error_at (expr
.get_location (),
166 "constraint expression does not have type %<bool%>");
170 /* Check that we're using function concepts correctly. */
171 if (concept_check_p (expr
))
173 tree id
= unpack_concept_check (expr
);
174 tree tmpl
= TREE_OPERAND (id
, 0);
175 if (OVL_P (tmpl
) && TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
177 error_at (EXPR_LOC_OR_LOC (expr
, input_location
),
178 "function concept must be called");
187 check_constraint_operands (location_t
, cp_expr lhs
, cp_expr rhs
)
189 return check_constraint_atom (lhs
) && check_constraint_atom (rhs
);
192 /* Validate the semantic properties of the constraint expression. */
195 finish_constraint_binary_op (location_t loc
,
200 gcc_assert (processing_constraint_expression_p ());
201 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
202 return error_mark_node
;
203 if (!check_constraint_operands (loc
, lhs
, rhs
))
204 return error_mark_node
;
206 = build_min_nt_loc (loc
, code
, lhs
.get_value (), rhs
.get_value ());
207 expr
.set_range (lhs
.get_start (), rhs
.get_finish ());
212 finish_constraint_or_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
214 return finish_constraint_binary_op (loc
, TRUTH_ORIF_EXPR
, lhs
, rhs
);
218 finish_constraint_and_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
220 return finish_constraint_binary_op (loc
, TRUTH_ANDIF_EXPR
, lhs
, rhs
);
224 finish_constraint_primary_expr (cp_expr expr
)
226 if (expr
== error_mark_node
)
227 return error_mark_node
;
228 if (!check_constraint_atom (expr
))
229 return cp_expr (error_mark_node
, expr
.get_location ());
233 /* Combine two constraint-expressions with a logical-and. */
236 combine_constraint_expressions (tree lhs
, tree rhs
)
238 processing_constraint_expression_sentinel pce
;
243 /* Use UNKNOWN_LOCATION so write_template_args can tell the difference
244 between this and a && the user wrote. */
245 return finish_constraint_and_expr (UNKNOWN_LOCATION
, lhs
, rhs
);
248 /* Extract the template-id from a concept check. For standard and variable
249 checks, this is simply T. For function concept checks, this is the
253 unpack_concept_check (tree t
)
255 gcc_assert (concept_check_p (t
));
257 if (TREE_CODE (t
) == CALL_EXPR
)
258 t
= CALL_EXPR_FN (t
);
260 gcc_assert (TREE_CODE (t
) == TEMPLATE_ID_EXPR
);
264 /* Extract the TEMPLATE_DECL from a concept check. */
267 get_concept_check_template (tree t
)
269 tree id
= unpack_concept_check (t
);
270 tree tmpl
= TREE_OPERAND (id
, 0);
272 tmpl
= OVL_FIRST (tmpl
);
276 /*---------------------------------------------------------------------------
277 Resolution of qualified concept names
278 ---------------------------------------------------------------------------*/
280 /* This facility is used to resolve constraint checks from requirement
281 expressions. A constraint check is a call to a function template declared
282 with the keyword 'concept'.
284 The result of resolution is a pair (a TREE_LIST) whose value is the
285 matched declaration, and whose purpose contains the coerced template
286 arguments that can be substituted into the call. */
288 /* Given an overload set OVL, try to find a unique definition that can be
289 instantiated by the template arguments ARGS.
291 This function is not called for arbitrary call expressions. In particular,
292 the call expression must be written with explicit template arguments
293 and no function arguments. For example:
297 If a single match is found, this returns a TREE_LIST whose VALUE
298 is the constraint function (not the template), and its PURPOSE is
299 the complete set of arguments substituted into the parameter list. */
302 resolve_function_concept_overload (tree ovl
, tree args
)
305 tree cands
= NULL_TREE
;
306 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
309 if (TREE_CODE (tmpl
) != TEMPLATE_DECL
)
312 /* Don't try to deduce checks for non-concepts. We often end up trying
313 to resolve constraints in functional casts as part of a
314 postfix-expression. We can save time and headaches by not
315 instantiating those declarations.
317 NOTE: This masks a potential error, caused by instantiating
318 non-deduced contexts using placeholder arguments. */
319 tree fn
= DECL_TEMPLATE_RESULT (tmpl
);
320 if (DECL_ARGUMENTS (fn
))
322 if (!DECL_DECLARED_CONCEPT_P (fn
))
325 /* Remember the candidate if we can deduce a substitution. */
326 ++processing_template_decl
;
327 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
328 if (tree subst
= coerce_template_parms (parms
, args
, tmpl
, tf_none
))
330 if (subst
== error_mark_node
)
333 cands
= tree_cons (subst
, fn
, cands
);
335 --processing_template_decl
;
339 /* We either had no candidates or failed deductions. */
340 return nerrs
? error_mark_node
: NULL_TREE
;
341 else if (TREE_CHAIN (cands
))
342 /* There are multiple candidates. */
343 return error_mark_node
;
348 /* Determine if the call expression CALL is a constraint check, and
349 return the concept declaration and arguments being checked. If CALL
350 does not denote a constraint check, return NULL. */
353 resolve_function_concept_check (tree call
)
355 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
357 /* A constraint check must be only a template-id expression.
358 If it's a call to a base-link, its function(s) should be a
359 template-id expression. If this is not a template-id, then
360 it cannot be a concept-check. */
361 tree target
= CALL_EXPR_FN (call
);
362 if (BASELINK_P (target
))
363 target
= BASELINK_FUNCTIONS (target
);
364 if (TREE_CODE (target
) != TEMPLATE_ID_EXPR
)
367 /* Get the overload set and template arguments and try to
368 resolve the target. */
369 tree ovl
= TREE_OPERAND (target
, 0);
371 /* This is a function call of a variable concept... ill-formed. */
372 if (TREE_CODE (ovl
) == TEMPLATE_DECL
)
374 error_at (location_of (call
),
375 "function call of variable concept %qE", call
);
376 return error_mark_node
;
379 tree args
= TREE_OPERAND (target
, 1);
380 return resolve_function_concept_overload (ovl
, args
);
383 /* Returns a pair containing the checked concept and its associated
384 prototype parameter. The result is a TREE_LIST whose TREE_VALUE
385 is the concept (non-template) and whose TREE_PURPOSE contains
386 the converted template arguments, including the deduced prototype
387 parameter (in position 0). */
390 resolve_concept_check (tree check
)
392 gcc_assert (concept_check_p (check
));
393 tree id
= unpack_concept_check (check
);
394 tree tmpl
= TREE_OPERAND (id
, 0);
396 /* If this is an overloaded function concept, perform overload
397 resolution (this only happens when deducing prototype parameters
398 and template introductions). */
399 if (TREE_CODE (tmpl
) == OVERLOAD
)
401 if (OVL_CHAIN (tmpl
))
402 return resolve_function_concept_check (check
);
403 tmpl
= OVL_FIRST (tmpl
);
406 tree args
= TREE_OPERAND (id
, 1);
407 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
408 ++processing_template_decl
;
409 tree result
= coerce_template_parms (parms
, args
, tmpl
, tf_none
);
410 --processing_template_decl
;
411 if (result
== error_mark_node
)
412 return error_mark_node
;
413 return build_tree_list (result
, DECL_TEMPLATE_RESULT (tmpl
));
416 /* Given a call expression or template-id expression to a concept EXPR
417 possibly including a wildcard, deduce the concept being checked and
418 the prototype parameter. Returns true if the constraint and prototype
419 can be deduced and false otherwise. Note that the CHECK and PROTO
420 arguments are set to NULL_TREE if this returns false. */
423 deduce_constrained_parameter (tree expr
, tree
& check
, tree
& proto
)
425 tree info
= resolve_concept_check (expr
);
426 if (info
&& info
!= error_mark_node
)
428 check
= TREE_VALUE (info
);
429 tree arg
= TREE_VEC_ELT (TREE_PURPOSE (info
), 0);
430 if (ARGUMENT_PACK_P (arg
))
431 arg
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0);
432 proto
= TREE_TYPE (arg
);
436 check
= proto
= NULL_TREE
;
440 /* Given a call expression or template-id expression to a concept, EXPR,
441 deduce the concept being checked and return the template arguments.
442 Returns NULL_TREE if deduction fails. */
444 deduce_concept_introduction (tree check
)
446 tree info
= resolve_concept_check (check
);
447 if (info
&& info
!= error_mark_node
)
448 return TREE_PURPOSE (info
);
452 /* Build a constrained placeholder type where SPEC is a type-constraint.
453 SPEC can be anything were concept_definition_p is true.
455 Returns a pair whose FIRST is the concept being checked and whose
456 SECOND is the prototype parameter. */
459 finish_type_constraints (tree spec
, tree args
, tsubst_flags_t complain
)
461 gcc_assert (concept_definition_p (spec
));
463 /* Build an initial concept check. */
464 tree check
= build_type_constraint (spec
, args
, complain
);
465 if (check
== error_mark_node
)
466 return std::make_pair (error_mark_node
, NULL_TREE
);
468 /* Extract the concept and prototype parameter from the check. */
471 if (!deduce_constrained_parameter (check
, con
, proto
))
472 return std::make_pair (error_mark_node
, NULL_TREE
);
474 return std::make_pair (con
, proto
);
477 /*---------------------------------------------------------------------------
478 Expansion of concept definitions
479 ---------------------------------------------------------------------------*/
481 /* Returns the expression of a function concept. */
484 get_returned_expression (tree fn
)
486 /* Extract the body of the function minus the return expression. */
487 tree body
= DECL_SAVED_TREE (fn
);
489 return error_mark_node
;
490 if (TREE_CODE (body
) == BIND_EXPR
)
491 body
= BIND_EXPR_BODY (body
);
492 if (TREE_CODE (body
) != RETURN_EXPR
)
493 return error_mark_node
;
495 return TREE_OPERAND (body
, 0);
498 /* Returns the initializer of a variable concept. */
501 get_variable_initializer (tree var
)
503 tree init
= DECL_INITIAL (var
);
505 return error_mark_node
;
506 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
507 && CONSTRUCTOR_NELTS (init
) == 1)
508 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
512 /* Returns the definition of a variable or function concept. */
515 get_concept_definition (tree decl
)
517 if (TREE_CODE (decl
) == OVERLOAD
)
518 decl
= OVL_FIRST (decl
);
520 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
521 decl
= DECL_TEMPLATE_RESULT (decl
);
523 if (TREE_CODE (decl
) == CONCEPT_DECL
)
524 return DECL_INITIAL (decl
);
526 return get_variable_initializer (decl
);
527 if (TREE_CODE (decl
) == FUNCTION_DECL
)
528 return get_returned_expression (decl
);
532 /*---------------------------------------------------------------------------
533 Normalization of expressions
535 This set of functions will transform an expression into a constraint
536 in a sequence of steps.
537 ---------------------------------------------------------------------------*/
540 debug_parameter_mapping (tree map
)
542 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
544 tree parm
= TREE_VALUE (p
);
545 tree arg
= TREE_PURPOSE (p
);
547 verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm
), arg
);
549 verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm
), arg
);
550 // debug_tree (parm);
556 debug_argument_list (tree args
)
558 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
560 tree arg
= TREE_VEC_ELT (args
, i
);
562 verbatim ("argument %qT", arg
);
564 verbatim ("argument %qE", arg
);
568 /* Associate each parameter in PARMS with its corresponding template
572 map_arguments (tree parms
, tree args
)
574 for (tree p
= parms
; p
; p
= TREE_CHAIN (p
))
579 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
580 TREE_PURPOSE (p
) = TMPL_ARG (args
, level
, index
);
583 TREE_PURPOSE (p
) = template_parm_to_arg (p
);
588 /* Build the parameter mapping for EXPR using ARGS, where CTX_PARMS
589 are the template parameters in scope for EXPR. */
592 build_parameter_mapping (tree expr
, tree args
, tree ctx_parms
)
594 tree parms
= find_template_parameters (expr
, ctx_parms
);
595 tree map
= map_arguments (parms
, args
);
599 /* True if the parameter mappings of two atomic constraints formed
600 from the same expression are equivalent. */
603 parameter_mapping_equivalent_p (tree t1
, tree t2
)
605 tree map1
= ATOMIC_CONSTR_MAP (t1
);
606 tree map2
= ATOMIC_CONSTR_MAP (t2
);
609 gcc_checking_assert (TREE_VALUE (map1
) == TREE_VALUE (map2
));
610 tree arg1
= TREE_PURPOSE (map1
);
611 tree arg2
= TREE_PURPOSE (map2
);
612 if (!template_args_equal (arg1
, arg2
))
614 map1
= TREE_CHAIN (map1
);
615 map2
= TREE_CHAIN (map2
);
617 gcc_checking_assert (!map1
&& !map2
);
621 /* Provides additional context for normalization. */
623 struct norm_info
: subst_info
625 explicit norm_info (bool diag
)
626 : norm_info (NULL_TREE
, diag
)
629 /* Construct a top-level context for DECL. */
631 norm_info (tree in_decl
, bool diag
)
632 : subst_info (tf_warning_or_error
, in_decl
),
633 generate_diagnostics (diag
)
637 initial_parms
= DECL_TEMPLATE_PARMS (in_decl
);
638 if (generate_diagnostics
)
639 context
= build_tree_list (NULL_TREE
, in_decl
);
642 initial_parms
= current_template_parms
;
645 void update_context(tree expr
, tree args
)
647 if (generate_diagnostics
)
649 tree map
= build_parameter_mapping (expr
, args
, ctx_parms ());
650 context
= tree_cons (map
, expr
, context
);
652 in_decl
= get_concept_check_template (expr
);
655 /* Returns the template parameters that are in scope for the current
656 normalization context. */
661 return DECL_TEMPLATE_PARMS (in_decl
);
663 return initial_parms
;
666 /* Provides information about the source of a constraint. This is a
667 TREE_LIST whose VALUE is either a concept check or a constrained
668 declaration. The PURPOSE, for concept checks is a parameter mapping
671 tree context
= NULL_TREE
;
673 /* The declaration whose constraints we're normalizing. The targets
674 of the parameter mapping of each atom will be in terms of the
675 template parameters of ORIG_DECL. */
677 tree initial_parms
= NULL_TREE
;
679 /* Whether to build diagnostic information during normalization. */
681 bool generate_diagnostics
;
684 static tree
normalize_expression (tree
, tree
, norm_info
);
686 /* Transform a logical-or or logical-and expression into either
687 a conjunction or disjunction. */
690 normalize_logical_operation (tree t
, tree args
, tree_code c
, norm_info info
)
692 tree t0
= normalize_expression (TREE_OPERAND (t
, 0), args
, info
);
693 tree t1
= normalize_expression (TREE_OPERAND (t
, 1), args
, info
);
695 /* Build a new info object for the constraint. */
696 tree ci
= info
.generate_diagnostics
697 ? build_tree_list (t
, info
.context
)
700 return build2 (c
, ci
, t0
, t1
);
703 /* Data types and hash functions for caching the normal form of a concept-id.
704 This essentially memoizes calls to normalize_concept_check. */
706 struct GTY((for_user
)) norm_entry
708 /* The CONCEPT_DECL of the concept-id. */
710 /* The arguments of the concept-id. */
712 /* The normal form of the concept-id. */
716 struct norm_hasher
: ggc_ptr_hash
<norm_entry
>
718 static hashval_t
hash (norm_entry
*e
)
720 ++comparing_specializations
;
721 hashval_t val
= iterative_hash_template_arg (e
->tmpl
, 0);
722 val
= iterative_hash_template_arg (e
->args
, val
);
723 --comparing_specializations
;
727 static bool equal (norm_entry
*e1
, norm_entry
*e2
)
729 ++comparing_specializations
;
730 bool eq
= e1
->tmpl
== e2
->tmpl
731 && template_args_equal (e1
->args
, e2
->args
);
732 --comparing_specializations
;
737 static GTY((deletable
)) hash_table
<norm_hasher
> *norm_cache
;
739 /* Normalize the concept check CHECK where ARGS are the
740 arguments to be substituted into CHECK's arguments. */
743 normalize_concept_check (tree check
, tree args
, norm_info info
)
745 tree id
= unpack_concept_check (check
);
746 tree tmpl
= TREE_OPERAND (id
, 0);
747 tree targs
= TREE_OPERAND (id
, 1);
749 /* A function concept is wrapped in an overload. */
750 if (TREE_CODE (tmpl
) == OVERLOAD
)
752 /* TODO: Can we diagnose this error during parsing? */
753 if (TREE_CODE (check
) == TEMPLATE_ID_EXPR
)
754 error_at (EXPR_LOC_OR_LOC (check
, input_location
),
755 "function concept must be called");
756 tmpl
= OVL_FIRST (tmpl
);
759 /* Substitute through the arguments of the concept check. */
761 targs
= tsubst_template_args (targs
, args
, info
.complain
, info
.in_decl
);
762 if (targs
== error_mark_node
)
763 return error_mark_node
;
764 if (template_args_equal (targs
, generic_targs_for (tmpl
)))
765 /* Canonicalize generic arguments as NULL_TREE, as an optimization. */
768 /* Build the substitution for the concept definition. */
769 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
771 /* As an optimization, coerce the arguments only if necessary
772 (i.e. if they were substituted). */
773 targs
= coerce_template_parms (parms
, targs
, tmpl
, tf_none
);
774 if (targs
== error_mark_node
)
775 return error_mark_node
;
778 norm_cache
= hash_table
<norm_hasher
>::create_ggc (31);
779 norm_entry
*entry
= nullptr;
780 if (!info
.generate_diagnostics
)
782 /* Cache the normal form of the substituted concept-id (when not
784 norm_entry elt
= {tmpl
, targs
, NULL_TREE
};
785 norm_entry
**slot
= norm_cache
->find_slot (&elt
, INSERT
);
787 return (*slot
)->norm
;
788 entry
= ggc_alloc
<norm_entry
> ();
793 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
794 info
.update_context (check
, args
);
795 tree norm
= normalize_expression (def
, targs
, info
);
801 /* Used by normalize_atom to cache ATOMIC_CONSTRs. */
803 static GTY((deletable
)) hash_table
<atom_hasher
> *atom_cache
;
805 /* The normal form of an atom depends on the expression. The normal
806 form of a function call to a function concept is a check constraint
807 for that concept. The normal form of a reference to a variable
808 concept is a check constraint for that concept. Otherwise, the
809 constraint is a predicate constraint. */
812 normalize_atom (tree t
, tree args
, norm_info info
)
814 /* Concept checks are not atomic. */
815 if (concept_check_p (t
))
816 return normalize_concept_check (t
, args
, info
);
818 /* Build the parameter mapping for the atom. */
819 tree map
= build_parameter_mapping (t
, args
, info
.ctx_parms ());
821 /* Build a new info object for the atom. */
822 tree ci
= build_tree_list (t
, info
.context
);
824 tree atom
= build1 (ATOMIC_CONSTR
, ci
, map
);
826 /* Remember whether the expression of this atomic constraint belongs to
827 a concept definition by inspecting in_decl, which should always be set
828 in this case either by norm_info::update_context (when recursing into a
829 concept-id during normalization) or by normalize_concept_definition
830 (when starting out with a concept-id). */
831 if (info
.in_decl
&& concept_definition_p (info
.in_decl
))
832 ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom
) = true;
834 if (!info
.generate_diagnostics
)
836 /* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
837 later can cheaply compare two atoms using just pointer equality. */
839 atom_cache
= hash_table
<atom_hasher
>::create_ggc (31);
840 tree
*slot
= atom_cache
->find_slot (atom
, INSERT
);
844 /* Find all template parameters used in the targets of the parameter
845 mapping, and store a list of them in the TREE_TYPE of the mapping.
846 This list will be used by sat_hasher to determine the subset of
847 supplied template arguments that the satisfaction value of the atom
851 tree targets
= make_tree_vec (list_length (map
));
853 for (tree node
= map
; node
; node
= TREE_CHAIN (node
))
855 tree target
= TREE_PURPOSE (node
);
856 TREE_VEC_ELT (targets
, i
++) = target
;
858 tree target_parms
= find_template_parameters (targets
,
860 TREE_TYPE (map
) = target_parms
;
868 /* Returns the normal form of an expression. */
871 normalize_expression (tree t
, tree args
, norm_info info
)
876 if (t
== error_mark_node
)
877 return error_mark_node
;
879 switch (TREE_CODE (t
))
881 case TRUTH_ANDIF_EXPR
:
882 return normalize_logical_operation (t
, args
, CONJ_CONSTR
, info
);
883 case TRUTH_ORIF_EXPR
:
884 return normalize_logical_operation (t
, args
, DISJ_CONSTR
, info
);
886 return normalize_atom (t
, args
, info
);
890 /* Cache of the normalized form of constraints. Marked as deletable because it
891 can all be recalculated. */
892 static GTY((deletable
)) hash_map
<tree
,tree
> *normalized_map
;
895 get_normalized_constraints (tree t
, norm_info info
)
897 auto_timevar
time (TV_CONSTRAINT_NORM
);
898 return normalize_expression (t
, NULL_TREE
, info
);
901 /* Returns the normalized constraints from a constraint-info object
902 or NULL_TREE if the constraints are null. IN_DECL provides the
903 declaration to which the constraints belong. */
906 get_normalized_constraints_from_info (tree ci
, tree in_decl
, bool diag
= false)
911 /* Substitution errors during normalization are fatal. */
912 ++processing_template_decl
;
913 norm_info
info (in_decl
, diag
);
914 tree t
= get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci
), info
);
915 --processing_template_decl
;
920 /* Returns the normalized constraints for the declaration D. */
923 get_normalized_constraints_from_decl (tree d
, bool diag
= false)
928 /* For inherited constructors, consider the original declaration;
929 it has the correct template information attached. */
930 d
= strip_inheriting_ctors (d
);
932 if (regenerated_lambda_fn_p (d
))
934 /* If this lambda was regenerated, DECL_TEMPLATE_PARMS doesn't contain
935 all in-scope template parameters, but the lambda from which it was
936 ultimately regenerated does, so use that instead. */
937 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (d
));
938 lambda
= most_general_lambda (lambda
);
939 d
= lambda_function (lambda
);
942 if (TREE_CODE (d
) == TEMPLATE_DECL
)
945 decl
= DECL_TEMPLATE_RESULT (tmpl
);
949 if (tree ti
= DECL_TEMPLATE_INFO (d
))
950 tmpl
= TI_TEMPLATE (ti
);
956 /* Get the most general template for the declaration, and compute
957 arguments from that. This ensures that the arguments used for
958 normalization are always template parameters and not arguments
959 used for outer specializations. For example:
963 template<typename U> requires C<T, U> void f(U);
968 When we normalize the requirements for S<int>::f, we want the
969 arguments to be {T, U}, not {int, U}. One reason for this is that
970 accepting the latter causes the template parameter level of U
971 to be reduced in a way that makes it overly difficult substitute
972 concrete arguments (i.e., eventually {int, int} during satisfaction. */
975 if (DECL_LANG_SPECIFIC(tmpl
) && !DECL_TEMPLATE_SPECIALIZATION (tmpl
))
976 tmpl
= most_general_template (tmpl
);
979 d
= tmpl
? tmpl
: decl
;
981 /* If we're not diagnosing errors, use cached constraints, if any. */
983 if (tree
*p
= hash_map_safe_get (normalized_map
, d
))
986 tree norm
= NULL_TREE
;
987 if (tree ci
= get_constraints (d
))
989 push_access_scope_guard
pas (decl
);
990 norm
= get_normalized_constraints_from_info (ci
, tmpl
, diag
);
994 hash_map_safe_put
<hm_ggc
> (normalized_map
, d
, norm
);
999 /* Returns the normal form of TMPL's definition. */
1002 normalize_concept_definition (tree tmpl
, bool diag
)
1005 norm_cache
= hash_table
<norm_hasher
>::create_ggc (31);
1006 norm_entry entry
= {tmpl
, NULL_TREE
, NULL_TREE
};
1009 if (norm_entry
*found
= norm_cache
->find (&entry
))
1012 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1013 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
1014 ++processing_template_decl
;
1015 norm_info
info (tmpl
, diag
);
1016 tree norm
= get_normalized_constraints (def
, info
);
1017 --processing_template_decl
;
1021 norm_entry
**slot
= norm_cache
->find_slot (&entry
, INSERT
);
1023 *slot
= ggc_alloc
<norm_entry
> ();
1030 /* Normalize an EXPR as a constraint. */
1033 normalize_constraint_expression (tree expr
, norm_info info
)
1035 if (!expr
|| expr
== error_mark_node
)
1038 if (!info
.generate_diagnostics
)
1039 if (tree
*p
= hash_map_safe_get (normalized_map
, expr
))
1042 ++processing_template_decl
;
1043 tree norm
= get_normalized_constraints (expr
, info
);
1044 --processing_template_decl
;
1046 if (!info
.generate_diagnostics
)
1047 hash_map_safe_put
<hm_ggc
> (normalized_map
, expr
, norm
);
1052 /* 17.4.1.2p2. Two constraints are identical if they are formed
1053 from the same expression and the targets of the parameter mapping
1057 atomic_constraints_identical_p (tree t1
, tree t2
)
1059 gcc_assert (TREE_CODE (t1
) == ATOMIC_CONSTR
);
1060 gcc_assert (TREE_CODE (t2
) == ATOMIC_CONSTR
);
1062 if (ATOMIC_CONSTR_EXPR (t1
) != ATOMIC_CONSTR_EXPR (t2
))
1065 if (!parameter_mapping_equivalent_p (t1
, t2
))
1071 /* True if T1 and T2 are equivalent, meaning they have the same syntactic
1072 structure and all corresponding constraints are identical. */
1075 constraints_equivalent_p (tree t1
, tree t2
)
1077 gcc_assert (CONSTR_P (t1
));
1078 gcc_assert (CONSTR_P (t2
));
1080 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1083 switch (TREE_CODE (t1
))
1087 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
1089 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
1093 if (!atomic_constraints_identical_p(t1
, t2
))
1102 /* Compute the hash value for T. */
1105 hash_atomic_constraint (tree t
)
1107 gcc_assert (TREE_CODE (t
) == ATOMIC_CONSTR
);
1109 /* Hash the identity of the expression. */
1110 hashval_t val
= htab_hash_pointer (ATOMIC_CONSTR_EXPR (t
));
1112 /* Hash the targets of the parameter map. */
1113 tree p
= ATOMIC_CONSTR_MAP (t
);
1116 val
= iterative_hash_template_arg (TREE_PURPOSE (p
), val
);
1127 add_constraint (tree t
, hash
& h
)
1129 h
.add_int(TREE_CODE (t
));
1130 switch (TREE_CODE (t
))
1134 add_constraint (TREE_OPERAND (t
, 0), h
);
1135 add_constraint (TREE_OPERAND (t
, 1), h
);
1138 h
.merge_hash (hash_atomic_constraint (t
));
1147 /* Computes a hash code for the constraint T. */
1150 iterative_hash_constraint (tree t
, hashval_t val
)
1152 gcc_assert (CONSTR_P (t
));
1153 inchash::hash
h (val
);
1154 inchash::add_constraint (t
, h
);
1158 // -------------------------------------------------------------------------- //
1159 // Constraint Semantic Processing
1161 // The following functions are called by the parser and substitution rules
1162 // to create and evaluate constraint-related nodes.
1164 // The constraints associated with the current template parameters.
1166 current_template_constraints (void)
1168 if (!current_template_parms
)
1170 tree tmpl_constr
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
1171 return build_constraints (tmpl_constr
, NULL_TREE
);
1174 /* If the recently parsed TYPE declares or defines a template or
1175 template specialization, get its corresponding constraints from the
1176 current template parameters and bind them to TYPE's declaration. */
1179 associate_classtype_constraints (tree type
)
1181 if (!type
|| type
== error_mark_node
|| !CLASS_TYPE_P (type
))
1184 /* An explicit class template specialization has no template parameters. */
1185 if (!current_template_parms
)
1188 if (CLASSTYPE_IS_TEMPLATE (type
) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1190 tree decl
= TYPE_STUB_DECL (type
);
1191 tree ci
= current_template_constraints ();
1193 /* An implicitly instantiated member template declaration already
1194 has associated constraints. If it is defined outside of its
1195 class, then we need match these constraints against those of
1196 original declaration. */
1197 if (tree orig_ci
= get_constraints (decl
))
1199 if (int extra_levels
= (TMPL_PARMS_DEPTH (current_template_parms
)
1200 - TMPL_ARGS_DEPTH (TYPE_TI_ARGS (type
))))
1202 /* If there is a discrepancy between the current template depth
1203 and the template depth of the original declaration, then we
1204 must be redeclaring a class template as part of a friend
1205 declaration within another class template. Before matching
1206 constraints, we need to reduce the template parameter level
1207 within the current constraints via substitution. */
1208 tree outer_gtargs
= template_parms_to_args (current_template_parms
);
1209 TREE_VEC_LENGTH (outer_gtargs
) = extra_levels
;
1210 ci
= tsubst_constraint_info (ci
, outer_gtargs
, tf_none
, NULL_TREE
);
1212 if (!equivalent_constraints (ci
, orig_ci
))
1214 error ("%qT does not match original declaration", type
);
1215 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1216 location_t loc
= DECL_SOURCE_LOCATION (tmpl
);
1217 inform (loc
, "original template declaration here");
1218 /* Fall through, so that we define the type anyway. */
1222 set_constraints (decl
, ci
);
1227 /* Create an empty constraint info block. */
1229 static inline tree_constraint_info
*
1230 build_constraint_info ()
1232 return (tree_constraint_info
*)make_node (CONSTRAINT_INFO
);
1235 /* Build a constraint-info object that contains the associated constraints
1236 of a declaration. This also includes the declaration's template
1237 requirements (TREQS) and any trailing requirements for a function
1238 declarator (DREQS). Note that both TREQS and DREQS must be constraints.
1240 If the declaration has neither template nor declaration requirements
1241 this returns NULL_TREE, indicating an unconstrained declaration. */
1244 build_constraints (tree tr
, tree dr
)
1249 tree_constraint_info
* ci
= build_constraint_info ();
1250 ci
->template_reqs
= tr
;
1251 ci
->declarator_reqs
= dr
;
1252 ci
->associated_constr
= combine_constraint_expressions (tr
, dr
);
1257 /* Add constraint RHS to the end of CONSTRAINT_INFO ci. */
1260 append_constraint (tree ci
, tree rhs
)
1262 tree tr
= ci
? CI_TEMPLATE_REQS (ci
) : NULL_TREE
;
1263 tree dr
= ci
? CI_DECLARATOR_REQS (ci
) : NULL_TREE
;
1264 dr
= combine_constraint_expressions (dr
, rhs
);
1267 CI_DECLARATOR_REQS (ci
) = dr
;
1268 tree ac
= combine_constraint_expressions (tr
, dr
);
1269 CI_ASSOCIATED_CONSTRAINTS (ci
) = ac
;
1272 ci
= build_constraints (tr
, dr
);
1276 /* A mapping from declarations to constraint information. */
1278 static GTY ((cache
)) decl_tree_cache_map
*decl_constraints
;
1280 /* Returns the template constraints of declaration T. If T is not
1281 constrained, return NULL_TREE. Note that T must be non-null. */
1284 get_constraints (const_tree t
)
1288 if (!decl_constraints
)
1291 gcc_assert (DECL_P (t
));
1292 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1293 t
= DECL_TEMPLATE_RESULT (t
);
1294 tree
* found
= decl_constraints
->get (CONST_CAST_TREE (t
));
1301 /* Associate the given constraint information CI with the declaration
1302 T. If T is a template, then the constraints are associated with
1303 its underlying declaration. Don't build associations if CI is
1307 set_constraints (tree t
, tree ci
)
1311 gcc_assert (t
&& flag_concepts
);
1312 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1313 t
= DECL_TEMPLATE_RESULT (t
);
1314 bool found
= hash_map_safe_put
<hm_ggc
> (decl_constraints
, t
, ci
);
1315 gcc_assert (!found
);
1318 /* Remove the associated constraints of the declaration T. */
1321 remove_constraints (tree t
)
1323 gcc_checking_assert (DECL_P (t
));
1324 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1325 t
= DECL_TEMPLATE_RESULT (t
);
1327 if (decl_constraints
)
1328 decl_constraints
->remove (t
);
1331 /* If DECL is a friend, substitute into REQS to produce requirements suitable
1332 for declaration matching. */
1335 maybe_substitute_reqs_for (tree reqs
, const_tree decl
)
1337 if (reqs
== NULL_TREE
)
1340 decl
= STRIP_TEMPLATE (decl
);
1341 if (DECL_UNIQUE_FRIEND_P (decl
) && DECL_TEMPLATE_INFO (decl
))
1343 tree tmpl
= DECL_TI_TEMPLATE (decl
);
1344 tree outer_args
= outer_template_args (decl
);
1345 processing_template_decl_sentinel s
;
1346 if (PRIMARY_TEMPLATE_P (tmpl
)
1347 || uses_template_parms (outer_args
))
1348 ++processing_template_decl
;
1349 reqs
= tsubst_constraint (reqs
, outer_args
,
1350 tf_warning_or_error
, NULL_TREE
);
1355 /* Returns the trailing requires clause of the declarator of
1356 a template declaration T or NULL_TREE if none. */
1359 get_trailing_function_requirements (tree t
)
1361 tree ci
= get_constraints (t
);
1364 return CI_DECLARATOR_REQS (ci
);
1367 /* Construct a sequence of template arguments by prepending
1368 ARG to REST. Either ARG or REST may be null. */
1370 build_concept_check_arguments (tree arg
, tree rest
)
1372 gcc_assert (rest
? TREE_CODE (rest
) == TREE_VEC
: true);
1376 int n
= rest
? TREE_VEC_LENGTH (rest
) : 0;
1377 args
= make_tree_vec (n
+ 1);
1378 TREE_VEC_ELT (args
, 0) = arg
;
1380 for (int i
= 0; i
< n
; ++i
)
1381 TREE_VEC_ELT (args
, i
+ 1) = TREE_VEC_ELT (rest
, i
);
1382 int def
= rest
? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest
) : 0;
1383 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, def
+ 1);
1392 /* Builds an id-expression of the form `C<Args...>()` where C is a function
1396 build_function_check (tree tmpl
, tree args
, tsubst_flags_t
/*complain*/)
1398 if (TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1400 /* If we just got a template, wrap it in an overload so it looks like any
1401 other template-id. */
1402 tmpl
= ovl_make (tmpl
);
1403 TREE_TYPE (tmpl
) = boolean_type_node
;
1406 /* Perform function concept resolution now so we always have a single
1407 function of the overload set (even if we started with only one; the
1408 resolution function converts template arguments). Note that we still
1409 wrap this in an overload set so we don't upset other parts of the
1410 compiler that expect template-ids referring to function concepts
1411 to have an overload set. */
1412 tree info
= resolve_function_concept_overload (tmpl
, args
);
1413 if (info
== error_mark_node
)
1414 return error_mark_node
;
1417 error ("no matching concepts for %qE", tmpl
);
1418 return error_mark_node
;
1420 args
= TREE_PURPOSE (info
);
1421 tmpl
= DECL_TI_TEMPLATE (TREE_VALUE (info
));
1423 /* Rebuild the singleton overload set; mark the type bool. */
1424 tmpl
= ovl_make (tmpl
, NULL_TREE
);
1425 TREE_TYPE (tmpl
) = boolean_type_node
;
1427 /* Build the id-expression around the overload set. */
1428 tree id
= build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1430 /* Finally, build the call expression around the overload. */
1431 ++processing_template_decl
;
1432 vec
<tree
, va_gc
> *fargs
= make_tree_vector ();
1433 tree call
= build_min_nt_call_vec (id
, fargs
);
1434 TREE_TYPE (call
) = boolean_type_node
;
1435 release_tree_vector (fargs
);
1436 --processing_template_decl
;
1441 /* Builds an id-expression of the form `C<Args...>` where C is a variable
1445 build_variable_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1447 gcc_assert (variable_concept_p (tmpl
));
1448 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1449 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1450 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1451 if (args
== error_mark_node
)
1452 return error_mark_node
;
1453 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1456 /* Builds an id-expression of the form `C<Args...>` where C is a standard
1460 build_standard_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1462 gcc_assert (standard_concept_p (tmpl
));
1463 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1464 if (TREE_DEPRECATED (DECL_TEMPLATE_RESULT (tmpl
)))
1465 warn_deprecated_use (DECL_TEMPLATE_RESULT (tmpl
), NULL_TREE
);
1466 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1467 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1468 if (args
== error_mark_node
)
1469 return error_mark_node
;
1470 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1473 /* Construct an expression that checks TARGET using ARGS. */
1476 build_concept_check (tree target
, tree args
, tsubst_flags_t complain
)
1478 return build_concept_check (target
, NULL_TREE
, args
, complain
);
1481 /* Construct an expression that checks the concept given by DECL. If
1482 concept_definition_p (DECL) is false, this returns null. */
1485 build_concept_check (tree decl
, tree arg
, tree rest
, tsubst_flags_t complain
)
1487 tree args
= build_concept_check_arguments (arg
, rest
);
1489 if (standard_concept_p (decl
))
1490 return build_standard_check (decl
, args
, complain
);
1491 if (variable_concept_p (decl
))
1492 return build_variable_check (decl
, args
, complain
);
1493 if (function_concept_p (decl
))
1494 return build_function_check (decl
, args
, complain
);
1496 return error_mark_node
;
1499 /* Build a template-id that can participate in a concept check. */
1502 build_concept_id (tree decl
, tree args
)
1504 tree check
= build_concept_check (decl
, args
, tf_warning_or_error
);
1505 if (check
== error_mark_node
)
1506 return error_mark_node
;
1507 return unpack_concept_check (check
);
1510 /* Build a template-id that can participate in a concept check, preserving
1511 the source location of the original template-id. */
1514 build_concept_id (tree expr
)
1516 gcc_assert (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
);
1517 tree id
= build_concept_id (TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
1518 protected_set_expr_location (id
, cp_expr_location (expr
));
1522 /* Build as template-id with a placeholder that can be used as a
1525 Note that this will diagnose errors if the initial concept check
1529 build_type_constraint (tree decl
, tree args
, tsubst_flags_t complain
)
1531 tree wildcard
= build_nt (WILDCARD_DECL
);
1532 ++processing_template_decl
;
1533 tree check
= build_concept_check (decl
, wildcard
, args
, complain
);
1534 --processing_template_decl
;
1535 if (check
== error_mark_node
)
1536 return error_mark_node
;
1537 return unpack_concept_check (check
);
1540 /* Returns a TYPE_DECL that contains sufficient information to
1541 build a template parameter of the same kind as PROTO and
1542 constrained by the concept declaration CNC. Note that PROTO
1543 is the first template parameter of CNC.
1545 If specified, ARGS provides additional arguments to the
1546 constraint check. */
1548 build_constrained_parameter (tree cnc
, tree proto
, tree args
)
1550 tree name
= DECL_NAME (cnc
);
1551 tree type
= TREE_TYPE (proto
);
1552 tree decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
1553 CONSTRAINED_PARM_PROTOTYPE (decl
) = proto
;
1554 CONSTRAINED_PARM_CONCEPT (decl
) = cnc
;
1555 CONSTRAINED_PARM_EXTRA_ARGS (decl
) = args
;
1559 /* Create a constraint expression for the given DECL that evaluates the
1560 requirements specified by CONSTR, a TYPE_DECL that contains all the
1561 information necessary to build the requirements (see finish_concept_name
1562 for the layout of that TYPE_DECL).
1564 Note that the constraints are neither reduced nor decomposed. That is
1565 done only after the requires clause has been parsed (or not). */
1568 finish_shorthand_constraint (tree decl
, tree constr
)
1570 /* No requirements means no constraints. */
1574 if (error_operand_p (constr
))
1577 tree proto
= CONSTRAINED_PARM_PROTOTYPE (constr
);
1578 tree con
= CONSTRAINED_PARM_CONCEPT (constr
);
1579 tree args
= CONSTRAINED_PARM_EXTRA_ARGS (constr
);
1581 /* The TS lets use shorthand to constrain a pack of arguments, but the
1584 For the TS, consider:
1586 template<C... Ts> struct s;
1588 If C is variadic (and because Ts is a pack), we associate the
1589 constraint C<Ts...>. In all other cases, we associate
1590 the constraint (C<Ts> && ...).
1592 The standard behavior cannot be overridden by -fconcepts-ts. */
1593 bool variadic_concept_p
= template_parameter_pack_p (proto
);
1594 bool declared_pack_p
= template_parameter_pack_p (decl
);
1595 bool apply_to_each_p
= (cxx_dialect
>= cxx20
) ? true : !variadic_concept_p
;
1597 /* Get the argument and overload used for the requirement
1598 and adjust it if we're going to expand later. */
1599 tree arg
= template_parm_to_arg (decl
);
1600 if (apply_to_each_p
&& declared_pack_p
)
1601 arg
= PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0));
1603 /* Build the concept constraint-expression. */
1604 tree tmpl
= DECL_TI_TEMPLATE (con
);
1606 if (TREE_CODE (con
) == FUNCTION_DECL
)
1607 check
= ovl_make (tmpl
);
1608 check
= build_concept_check (check
, arg
, args
, tf_warning_or_error
);
1610 /* Make the check a fold-expression if needed.
1611 Use UNKNOWN_LOCATION so write_template_args can tell the
1612 difference between this and a fold the user wrote. */
1613 if (apply_to_each_p
&& declared_pack_p
)
1614 check
= finish_left_unary_fold_expr (UNKNOWN_LOCATION
,
1615 check
, TRUTH_ANDIF_EXPR
);
1620 /* Returns a conjunction of shorthand requirements for the template
1621 parameter list PARMS. Note that the requirements are stored in
1622 the TYPE of each tree node. */
1625 get_shorthand_constraints (tree parms
)
1627 tree result
= NULL_TREE
;
1628 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1629 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
1631 tree parm
= TREE_VEC_ELT (parms
, i
);
1632 tree constr
= TEMPLATE_PARM_CONSTRAINTS (parm
);
1633 result
= combine_constraint_expressions (result
, constr
);
1638 /* Get the deduced wildcard from a DEDUCED placeholder. If the deduced
1639 wildcard is a pack, return the first argument of that pack. */
1642 get_deduced_wildcard (tree wildcard
)
1644 if (ARGUMENT_PACK_P (wildcard
))
1645 wildcard
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard
), 0);
1646 gcc_assert (TREE_CODE (wildcard
) == WILDCARD_DECL
);
1650 /* Returns the prototype parameter for the nth deduced wildcard. */
1653 get_introduction_prototype (tree wildcards
, int index
)
1655 return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards
, index
)));
1658 /* Introduce a type template parameter. */
1661 introduce_type_template_parameter (tree wildcard
, bool& non_type_p
)
1664 return finish_template_type_parm (class_type_node
, DECL_NAME (wildcard
));
1667 /* Introduce a template template parameter. */
1670 introduce_template_template_parameter (tree wildcard
, bool& non_type_p
)
1673 begin_template_parm_list ();
1674 current_template_parms
= DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard
));
1675 end_template_parm_list ();
1676 return finish_template_template_parm (class_type_node
, DECL_NAME (wildcard
));
1679 /* Introduce a template non-type parameter. */
1682 introduce_nontype_template_parameter (tree wildcard
, bool& non_type_p
)
1685 tree parm
= copy_decl (TREE_TYPE (wildcard
));
1686 DECL_NAME (parm
) = DECL_NAME (wildcard
);
1690 /* Introduce a single template parameter. */
1693 build_introduced_template_parameter (tree wildcard
, bool& non_type_p
)
1695 tree proto
= TREE_TYPE (wildcard
);
1698 if (TREE_CODE (proto
) == TYPE_DECL
)
1699 parm
= introduce_type_template_parameter (wildcard
, non_type_p
);
1700 else if (TREE_CODE (proto
) == TEMPLATE_DECL
)
1701 parm
= introduce_template_template_parameter (wildcard
, non_type_p
);
1703 parm
= introduce_nontype_template_parameter (wildcard
, non_type_p
);
1705 /* Wrap in a TREE_LIST for process_template_parm. Note that introduced
1706 parameters do not retain the defaults from the source parameter. */
1707 return build_tree_list (NULL_TREE
, parm
);
1710 /* Introduce a single template parameter. */
1713 introduce_template_parameter (tree parms
, tree wildcard
)
1715 gcc_assert (!ARGUMENT_PACK_P (wildcard
));
1716 tree proto
= TREE_TYPE (wildcard
);
1717 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1719 /* Diagnose the case where we have C{...Args}. */
1720 if (WILDCARD_PACK_P (wildcard
))
1722 tree id
= DECL_NAME (wildcard
);
1723 error_at (loc
, "%qE cannot be introduced with an ellipsis %<...%>", id
);
1724 inform (DECL_SOURCE_LOCATION (proto
), "prototype declared here");
1728 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1729 return process_template_parm (parms
, loc
, parm
, non_type_p
, false);
1732 /* Introduce a template parameter pack. */
1735 introduce_template_parameter_pack (tree parms
, tree wildcard
)
1738 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1739 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1740 return process_template_parm (parms
, loc
, parm
, non_type_p
, true);
1743 /* Introduce the nth template parameter. */
1746 introduce_template_parameter (tree parms
, tree wildcards
, int& index
)
1748 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1749 return introduce_template_parameter (parms
, deduced
);
1752 /* Introduce either a template parameter pack or a list of template
1756 introduce_template_parameters (tree parms
, tree wildcards
, int& index
)
1758 /* If the prototype was a parameter, we better have deduced an
1759 argument pack, and that argument must be the last deduced value
1760 in the wildcard vector. */
1761 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1762 gcc_assert (ARGUMENT_PACK_P (deduced
));
1763 gcc_assert (index
== TREE_VEC_LENGTH (wildcards
));
1765 /* Introduce each element in the pack. */
1766 tree args
= ARGUMENT_PACK_ARGS (deduced
);
1767 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1769 tree arg
= TREE_VEC_ELT (args
, i
);
1770 if (WILDCARD_PACK_P (arg
))
1771 parms
= introduce_template_parameter_pack (parms
, arg
);
1773 parms
= introduce_template_parameter (parms
, arg
);
1779 /* Builds the template parameter list PARMS by chaining introduced
1780 parameters from the WILDCARD vector. INDEX is the position of
1781 the current parameter. */
1784 process_introduction_parms (tree parms
, tree wildcards
, int& index
)
1786 tree proto
= get_introduction_prototype (wildcards
, index
);
1787 if (template_parameter_pack_p (proto
))
1788 return introduce_template_parameters (parms
, wildcards
, index
);
1790 return introduce_template_parameter (parms
, wildcards
, index
);
1793 /* Ensure that all template parameters have been introduced for the concept
1794 named in CHECK. If not, emit a diagnostic.
1796 Note that implicitly introducing a parameter with a default argument
1797 creates a case where a parameter is declared, but unnamed, making
1798 it unusable in the definition. */
1801 check_introduction_list (tree intros
, tree check
)
1803 check
= unpack_concept_check (check
);
1804 tree tmpl
= TREE_OPERAND (check
, 0);
1806 tmpl
= OVL_FIRST (tmpl
);
1808 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
1809 if (TREE_VEC_LENGTH (intros
) < TREE_VEC_LENGTH (parms
))
1811 error_at (input_location
, "all template parameters of %qD must "
1812 "be introduced", tmpl
);
1819 /* Associates a constraint check to the current template based on the
1820 introduction parameters. INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs
1821 containing a chained PARM_DECL which contains the identifier as well as
1822 the source location. TMPL_DECL is the decl for the concept being used.
1823 If we take a concept, C, this will form a check in the form of
1824 C<INTRO_LIST> filling in any extra arguments needed by the defaults
1827 Returns NULL_TREE if no concept could be matched and error_mark_node if
1828 an error occurred when matching. */
1831 finish_template_introduction (tree tmpl_decl
,
1833 location_t intro_loc
)
1835 /* Build a concept check to deduce the actual parameters. */
1836 tree expr
= build_concept_check (tmpl_decl
, intro_list
, tf_none
);
1837 if (expr
== error_mark_node
)
1839 error_at (intro_loc
, "cannot deduce template parameters from "
1840 "introduction list");
1841 return error_mark_node
;
1844 if (!check_introduction_list (intro_list
, expr
))
1845 return error_mark_node
;
1847 tree parms
= deduce_concept_introduction (expr
);
1851 /* Build template parameter scope for introduction. */
1852 tree parm_list
= NULL_TREE
;
1853 begin_template_parm_list ();
1854 int nargs
= MIN (TREE_VEC_LENGTH (parms
), TREE_VEC_LENGTH (intro_list
));
1855 for (int n
= 0; n
< nargs
; )
1856 parm_list
= process_introduction_parms (parm_list
, parms
, n
);
1857 parm_list
= end_template_parm_list (parm_list
);
1859 /* Update the number of arguments to reflect the number of deduced
1860 template parameter introductions. */
1861 nargs
= TREE_VEC_LENGTH (parm_list
);
1863 /* Determine if any errors occurred during matching. */
1864 for (int i
= 0; i
< TREE_VEC_LENGTH (parm_list
); ++i
)
1865 if (TREE_VALUE (TREE_VEC_ELT (parm_list
, i
)) == error_mark_node
)
1867 end_template_decl ();
1868 return error_mark_node
;
1871 /* Build a concept check for our constraint. */
1872 tree check_args
= make_tree_vec (nargs
);
1874 for (; n
< TREE_VEC_LENGTH (parm_list
); ++n
)
1876 tree parm
= TREE_VEC_ELT (parm_list
, n
);
1877 TREE_VEC_ELT (check_args
, n
) = template_parm_to_arg (parm
);
1879 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args
, n
);
1881 /* If the template expects more parameters we should be able
1882 to use the defaults from our deduced concept. */
1883 for (; n
< TREE_VEC_LENGTH (parms
); ++n
)
1884 TREE_VEC_ELT (check_args
, n
) = TREE_VEC_ELT (parms
, n
);
1886 /* Associate the constraint. */
1887 tree check
= build_concept_check (tmpl_decl
,
1889 tf_warning_or_error
);
1890 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
) = check
;
1896 /* Given the concept check T from a constrained-type-specifier, extract
1897 its TMPL and ARGS. FIXME why do we need two different forms of
1898 constrained-type-specifier? */
1901 placeholder_extract_concept_and_args (tree t
, tree
&tmpl
, tree
&args
)
1903 if (concept_check_p (t
))
1905 t
= unpack_concept_check (t
);
1906 tmpl
= TREE_OPERAND (t
, 0);
1907 if (TREE_CODE (tmpl
) == OVERLOAD
)
1908 tmpl
= OVL_FIRST (tmpl
);
1909 args
= TREE_OPERAND (t
, 1);
1913 if (TREE_CODE (t
) == TYPE_DECL
)
1915 /* A constrained parameter. Build a constraint check
1916 based on the prototype parameter and then extract the
1917 arguments from that. */
1918 tree proto
= CONSTRAINED_PARM_PROTOTYPE (t
);
1919 tree check
= finish_shorthand_constraint (proto
, t
);
1920 placeholder_extract_concept_and_args (check
, tmpl
, args
);
1925 /* Returns true iff the placeholders C1 and C2 are equivalent. C1
1926 and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */
1929 equivalent_placeholder_constraints (tree c1
, tree c2
)
1931 if (c1
&& TREE_CODE (c1
) == TEMPLATE_TYPE_PARM
)
1932 /* A constrained auto. */
1933 c1
= PLACEHOLDER_TYPE_CONSTRAINTS (c1
);
1934 if (c2
&& TREE_CODE (c2
) == TEMPLATE_TYPE_PARM
)
1935 c2
= PLACEHOLDER_TYPE_CONSTRAINTS (c2
);
1941 if (c1
== error_mark_node
|| c2
== error_mark_node
)
1942 /* We get here during satisfaction; when a deduction constraint
1943 fails, substitution can produce an error_mark_node for the
1944 placeholder constraints. */
1947 tree t1
, t2
, a1
, a2
;
1948 placeholder_extract_concept_and_args (c1
, t1
, a1
);
1949 placeholder_extract_concept_and_args (c2
, t2
, a2
);
1954 int len1
= TREE_VEC_LENGTH (a1
);
1955 int len2
= TREE_VEC_LENGTH (a2
);
1959 /* Skip the first argument so we don't infinitely recurse.
1960 Also, they may differ in template parameter index. */
1961 for (int i
= 1; i
< len1
; ++i
)
1963 tree t1
= TREE_VEC_ELT (a1
, i
);
1964 tree t2
= TREE_VEC_ELT (a2
, i
);
1965 if (!template_args_equal (t1
, t2
))
1971 /* Return a hash value for the placeholder ATOMIC_CONSTR C. */
1974 hash_placeholder_constraint (tree c
)
1977 placeholder_extract_concept_and_args (c
, t
, a
);
1979 /* Like hash_tmpl_and_args, but skip the first argument. */
1980 hashval_t val
= iterative_hash_object (DECL_UID (t
), 0);
1982 for (int i
= TREE_VEC_LENGTH (a
)-1; i
> 0; --i
)
1983 val
= iterative_hash_template_arg (TREE_VEC_ELT (a
, i
), val
);
1988 /* Substitute through the expression of a simple requirement or
1989 compound requirement. */
1992 tsubst_valid_expression_requirement (tree t
, tree args
, sat_info info
)
1994 tsubst_flags_t quiet
= info
.complain
& ~tf_warning_or_error
;
1995 tree r
= tsubst_expr (t
, args
, quiet
, info
.in_decl
);
1996 if (convert_to_void (r
, ICV_STATEMENT
, quiet
) != error_mark_node
)
1999 if (info
.diagnose_unsatisfaction_p ())
2001 location_t loc
= cp_expr_loc_or_input_loc (t
);
2002 if (diagnosing_failed_constraint::replay_errors_p ())
2004 inform (loc
, "the required expression %qE is invalid, because", t
);
2005 if (r
== error_mark_node
)
2006 tsubst_expr (t
, args
, info
.complain
, info
.in_decl
);
2008 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
2011 inform (loc
, "the required expression %qE is invalid", t
);
2013 else if (info
.noisy ())
2015 r
= tsubst_expr (t
, args
, info
.complain
, info
.in_decl
);
2016 convert_to_void (r
, ICV_STATEMENT
, info
.complain
);
2019 return error_mark_node
;
2023 /* Substitute through the simple requirement. */
2026 tsubst_simple_requirement (tree t
, tree args
, sat_info info
)
2028 tree t0
= TREE_OPERAND (t
, 0);
2029 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
2030 if (expr
== error_mark_node
)
2031 return error_mark_node
;
2032 if (processing_template_decl
)
2033 return finish_simple_requirement (EXPR_LOCATION (t
), expr
);
2034 return boolean_true_node
;
2037 /* Subroutine of tsubst_type_requirement that performs the actual substitution
2038 and diagnosing. Also used by tsubst_compound_requirement. */
2041 tsubst_type_requirement_1 (tree t
, tree args
, sat_info info
, location_t loc
)
2043 tsubst_flags_t quiet
= info
.complain
& ~tf_warning_or_error
;
2044 tree r
= tsubst (t
, args
, quiet
, info
.in_decl
);
2045 if (r
!= error_mark_node
)
2048 if (info
.diagnose_unsatisfaction_p ())
2050 if (diagnosing_failed_constraint::replay_errors_p ())
2052 /* Replay the substitution error. */
2053 inform (loc
, "the required type %qT is invalid, because", t
);
2054 tsubst (t
, args
, info
.complain
, info
.in_decl
);
2057 inform (loc
, "the required type %qT is invalid", t
);
2059 else if (info
.noisy ())
2060 tsubst (t
, args
, info
.complain
, info
.in_decl
);
2062 return error_mark_node
;
2066 /* Substitute through the type requirement. */
2069 tsubst_type_requirement (tree t
, tree args
, sat_info info
)
2071 tree t0
= TREE_OPERAND (t
, 0);
2072 tree type
= tsubst_type_requirement_1 (t0
, args
, info
, EXPR_LOCATION (t
));
2073 if (type
== error_mark_node
)
2074 return error_mark_node
;
2075 if (processing_template_decl
)
2076 return finish_type_requirement (EXPR_LOCATION (t
), type
);
2077 return boolean_true_node
;
2080 /* True if TYPE can be deduced from EXPR. */
2083 type_deducible_p (tree expr
, tree type
, tree placeholder
, tree args
,
2086 /* Make sure deduction is performed against ( EXPR ), so that
2087 references are preserved in the result. */
2088 expr
= force_paren_expr_uneval (expr
);
2090 tree deduced_type
= do_auto_deduction (type
, expr
, placeholder
,
2091 info
.complain
, adc_requirement
,
2092 /*outer_targs=*/args
);
2094 return deduced_type
!= error_mark_node
;
2097 /* True if EXPR can not be converted to TYPE. */
2100 expression_convertible_p (tree expr
, tree type
, subst_info info
)
2103 perform_direct_initialization_if_possible (type
, expr
, false,
2105 if (conv
== error_mark_node
)
2107 if (conv
== NULL_TREE
)
2109 if (info
.complain
& tf_error
)
2111 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
2112 error_at (loc
, "cannot convert %qE to %qT", expr
, type
);
2120 /* Substitute through the compound requirement. */
2123 tsubst_compound_requirement (tree t
, tree args
, sat_info info
)
2125 tree t0
= TREE_OPERAND (t
, 0);
2126 tree t1
= TREE_OPERAND (t
, 1);
2127 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
2128 if (expr
== error_mark_node
)
2129 return error_mark_node
;
2131 location_t loc
= cp_expr_loc_or_input_loc (expr
);
2133 subst_info
quiet (info
.complain
& ~tf_warning_or_error
, info
.in_decl
);
2135 /* Check the noexcept condition. */
2136 bool noexcept_p
= COMPOUND_REQ_NOEXCEPT_P (t
);
2137 if (noexcept_p
&& !processing_template_decl
2138 && !expr_noexcept_p (expr
, quiet
.complain
))
2140 if (info
.diagnose_unsatisfaction_p ())
2141 inform (loc
, "%qE is not %<noexcept%>", expr
);
2143 return error_mark_node
;
2146 /* Substitute through the type expression, if any. */
2147 tree type
= tsubst_type_requirement_1 (t1
, args
, info
, EXPR_LOCATION (t
));
2148 if (type
== error_mark_node
)
2149 return error_mark_node
;
2151 /* Check expression against the result type. */
2152 if (type
&& !processing_template_decl
)
2154 if (tree placeholder
= type_uses_auto (type
))
2156 if (!type_deducible_p (expr
, type
, placeholder
, args
, quiet
))
2158 if (info
.diagnose_unsatisfaction_p ())
2160 if (diagnosing_failed_constraint::replay_errors_p ())
2163 "%qE does not satisfy return-type-requirement, "
2165 /* Further explain the reason for the error. */
2166 type_deducible_p (expr
, type
, placeholder
, args
, info
);
2170 "%qE does not satisfy return-type-requirement", t0
);
2172 return error_mark_node
;
2175 else if (!expression_convertible_p (expr
, type
, quiet
))
2177 if (info
.diagnose_unsatisfaction_p ())
2179 if (diagnosing_failed_constraint::replay_errors_p ())
2181 inform (loc
, "cannot convert %qE to %qT because", t0
, type
);
2182 /* Further explain the reason for the error. */
2183 expression_convertible_p (expr
, type
, info
);
2186 inform (loc
, "cannot convert %qE to %qT", t0
, type
);
2188 return error_mark_node
;
2192 if (processing_template_decl
)
2193 return finish_compound_requirement (EXPR_LOCATION (t
),
2194 expr
, type
, noexcept_p
);
2195 return boolean_true_node
;
2198 /* Substitute through the nested requirement. */
2201 tsubst_nested_requirement (tree t
, tree args
, sat_info info
)
2203 if (processing_template_decl
)
2205 tree req
= TREE_OPERAND (t
, 0);
2206 req
= tsubst_constraint (req
, args
, info
.complain
, info
.in_decl
);
2207 if (req
== error_mark_node
)
2208 return error_mark_node
;
2209 return finish_nested_requirement (EXPR_LOCATION (t
), req
);
2212 sat_info
quiet (info
.complain
& ~tf_warning_or_error
, info
.in_decl
);
2213 tree result
= constraint_satisfaction_value (t
, args
, quiet
);
2214 if (result
== boolean_true_node
)
2215 return boolean_true_node
;
2217 if (result
== boolean_false_node
2218 && info
.diagnose_unsatisfaction_p ())
2220 tree expr
= TREE_OPERAND (t
, 0);
2221 location_t loc
= cp_expr_location (t
);
2222 if (diagnosing_failed_constraint::replay_errors_p ())
2224 /* Replay the substitution error. */
2225 inform (loc
, "nested requirement %qE is not satisfied, because", expr
);
2226 constraint_satisfaction_value (t
, args
, info
);
2229 inform (loc
, "nested requirement %qE is not satisfied", expr
);
2232 return error_mark_node
;
2235 /* Substitute ARGS into the requirement T. */
2238 tsubst_requirement (tree t
, tree args
, sat_info info
)
2240 iloc_sentinel
loc_s (cp_expr_location (t
));
2241 switch (TREE_CODE (t
))
2244 return tsubst_simple_requirement (t
, args
, info
);
2246 return tsubst_type_requirement (t
, args
, info
);
2248 return tsubst_compound_requirement (t
, args
, info
);
2250 return tsubst_nested_requirement (t
, args
, info
);
2258 declare_constraint_vars (tree parms
, tree vars
)
2261 for (tree t
= parms
; t
; t
= DECL_CHAIN (t
))
2263 if (DECL_PACK_P (t
))
2265 tree pack
= extract_fnparm_pack (t
, &s
);
2266 register_local_specialization (pack
, t
);
2270 register_local_specialization (s
, t
);
2277 /* Substitute through as if checking function parameter types. This
2278 will diagnose common parameter type errors. Returns error_mark_node
2279 if an error occurred. */
2282 check_constraint_variables (tree t
, tree args
, subst_info info
)
2284 tree types
= NULL_TREE
;
2286 while (p
&& !VOID_TYPE_P (p
))
2288 types
= tree_cons (NULL_TREE
, TREE_TYPE (p
), types
);
2291 types
= chainon (nreverse (types
), void_list_node
);
2292 return tsubst_function_parms (types
, args
, info
.complain
, info
.in_decl
);
2295 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
2296 into the parameter list T, producing a sequence of constraint
2297 variables, declared in the current scope.
2299 Note that the caller must establish a local specialization stack
2300 prior to calling this function since this substitution will
2301 declare the substituted parameters. */
2304 tsubst_constraint_variables (tree t
, tree args
, subst_info info
)
2306 /* Perform a trial substitution to check for type errors. */
2307 tree parms
= check_constraint_variables (t
, args
, info
);
2308 if (parms
== error_mark_node
)
2309 return error_mark_node
;
2311 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
2313 int saved_unevaluated_operand
= cp_unevaluated_operand
;
2314 cp_unevaluated_operand
= 0;
2315 tree vars
= tsubst (t
, args
, info
.complain
, info
.in_decl
);
2316 cp_unevaluated_operand
= saved_unevaluated_operand
;
2317 if (vars
== error_mark_node
)
2318 return error_mark_node
;
2319 return declare_constraint_vars (t
, vars
);
2322 /* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
2323 substitution of template arguments into a requires-expression
2324 may result in the formation of invalid types or expressions
2325 in its requirements ... In such cases, the expression evaluates
2326 to false; it does not cause the program to be ill-formed.
2328 When substituting through a REQUIRES_EXPR as part of template
2329 instantiation, we call this routine with info.quiet() true.
2331 When evaluating a REQUIRES_EXPR that appears outside a template in
2332 cp_parser_requires_expression, we call this routine with
2335 Finally, when diagnosing unsatisfaction from diagnose_atomic_constraint
2336 and when diagnosing a false REQUIRES_EXPR via diagnose_constraints,
2337 we call this routine with info.diagnose_unsatisfaction_p() true. */
2340 tsubst_requires_expr (tree t
, tree args
, sat_info info
)
2342 local_specialization_stack
stack (lss_copy
);
2344 /* We need to check access during the substitution. */
2345 deferring_access_check_sentinel
acs (dk_no_deferred
);
2347 /* A requires-expression is an unevaluated context. */
2350 args
= add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t
), args
,
2351 info
.complain
, info
.in_decl
);
2352 if (processing_template_decl
2353 && !processing_constraint_expression_p ())
2355 /* We're partially instantiating a generic lambda. Substituting into
2356 this requires-expression now may cause its requirements to get
2357 checked out of order, so instead just remember the template
2358 arguments and wait until we can substitute them all at once.
2360 Except if this requires-expr is part of associated constraints
2361 that we're substituting into directly (for e.g. declaration
2362 matching or dguide constraint rewriting), in which case we need
2363 to partially substitute. */
2365 REQUIRES_EXPR_EXTRA_ARGS (t
) = NULL_TREE
;
2366 REQUIRES_EXPR_EXTRA_ARGS (t
) = build_extra_args (t
, args
, info
.complain
);
2370 tree parms
= REQUIRES_EXPR_PARMS (t
);
2373 parms
= tsubst_constraint_variables (parms
, args
, info
);
2374 if (parms
== error_mark_node
)
2375 return boolean_false_node
;
2378 tree result
= boolean_true_node
;
2379 if (processing_template_decl
)
2381 for (tree reqs
= REQUIRES_EXPR_REQS (t
); reqs
; reqs
= TREE_CHAIN (reqs
))
2383 tree req
= TREE_VALUE (reqs
);
2384 req
= tsubst_requirement (req
, args
, info
);
2385 if (req
== error_mark_node
)
2387 result
= boolean_false_node
;
2388 if (info
.diagnose_unsatisfaction_p ())
2389 /* Keep going so that we diagnose all failed requirements. */;
2393 else if (processing_template_decl
)
2394 result
= tree_cons (NULL_TREE
, req
, result
);
2396 if (processing_template_decl
&& result
!= boolean_false_node
)
2397 result
= finish_requires_expr (EXPR_LOCATION (t
), parms
, nreverse (result
));
2401 /* Public wrapper for the above. */
2404 tsubst_requires_expr (tree t
, tree args
,
2405 tsubst_flags_t complain
, tree in_decl
)
2407 sat_info
info (complain
, in_decl
);
2408 return tsubst_requires_expr (t
, args
, info
);
2411 /* Substitute ARGS into the constraint information CI, producing a new
2412 constraint record. */
2415 tsubst_constraint_info (tree t
, tree args
,
2416 tsubst_flags_t complain
, tree in_decl
)
2418 if (!t
|| t
== error_mark_node
|| !check_constraint_info (t
))
2421 tree tr
= tsubst_constraint (CI_TEMPLATE_REQS (t
), args
, complain
, in_decl
);
2422 tree dr
= tsubst_constraint (CI_DECLARATOR_REQS (t
), args
, complain
, in_decl
);
2423 return build_constraints (tr
, dr
);
2426 /* Substitute through a parameter mapping, in order to get the actual
2427 arguments used to instantiate an atomic constraint. This may fail
2428 if the substitution into arguments produces something ill-formed. */
2431 tsubst_parameter_mapping (tree map
, tree args
, subst_info info
)
2436 tsubst_flags_t complain
= info
.complain
;
2437 tree in_decl
= info
.in_decl
;
2439 tree result
= NULL_TREE
;
2440 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2442 if (p
== error_mark_node
)
2443 return error_mark_node
;
2444 tree parm
= TREE_VALUE (p
);
2445 tree arg
= TREE_PURPOSE (p
);
2447 if (ARGUMENT_PACK_P (arg
))
2448 new_arg
= tsubst_argument_pack (arg
, args
, complain
, in_decl
);
2451 new_arg
= tsubst_template_arg (arg
, args
, complain
, in_decl
);
2452 if (TYPE_P (new_arg
))
2453 new_arg
= canonicalize_type_argument (new_arg
, complain
);
2455 if (TREE_CODE (new_arg
) == TYPE_ARGUMENT_PACK
)
2457 tree pack_args
= ARGUMENT_PACK_ARGS (new_arg
);
2458 for (tree
& pack_arg
: tree_vec_range (pack_args
))
2459 if (TYPE_P (pack_arg
))
2460 pack_arg
= canonicalize_type_argument (pack_arg
, complain
);
2462 if (new_arg
== error_mark_node
)
2463 return error_mark_node
;
2465 result
= tree_cons (new_arg
, parm
, result
);
2467 return nreverse (result
);
2471 tsubst_parameter_mapping (tree map
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2473 return tsubst_parameter_mapping (map
, args
, subst_info (complain
, in_decl
));
2476 /*---------------------------------------------------------------------------
2477 Constraint satisfaction
2478 ---------------------------------------------------------------------------*/
2480 /* True if we are currently satisfying a constraint. */
2482 static bool satisfying_constraint
;
2484 /* A vector of incomplete types (and of declarations with undeduced return type),
2485 appended to by note_failed_type_completion_for_satisfaction. The
2486 satisfaction caches use this in order to keep track of "potentially unstable"
2487 satisfaction results.
2489 Since references to entries in this vector are stored only in the
2490 GC-deletable sat_cache, it's safe to make this deletable as well. */
2492 static GTY((deletable
)) vec
<tree
, va_gc
> *failed_type_completions
;
2494 /* Called whenever a type completion (or return type deduction) failure occurs
2495 that definitely affects the meaning of the program, by e.g. inducing
2496 substitution failure. */
2499 note_failed_type_completion_for_satisfaction (tree t
)
2501 if (satisfying_constraint
)
2503 gcc_checking_assert ((TYPE_P (t
) && !COMPLETE_TYPE_P (t
))
2504 || (DECL_P (t
) && undeduced_auto_decl (t
)));
2505 vec_safe_push (failed_type_completions
, t
);
2509 /* Returns true if the range [BEGIN, END) of elements within the
2510 failed_type_completions vector contains a complete type (or a
2511 declaration with a non-placeholder return type). */
2514 some_type_complete_p (int begin
, int end
)
2516 for (int i
= begin
; i
< end
; i
++)
2518 tree t
= (*failed_type_completions
)[i
];
2519 if (TYPE_P (t
) && COMPLETE_TYPE_P (t
))
2521 if (DECL_P (t
) && !undeduced_auto_decl (t
))
2527 /* Hash functions and data types for satisfaction cache entries. */
2529 struct GTY((for_user
)) sat_entry
2531 /* The relevant ATOMIC_CONSTR. */
2534 /* The relevant template arguments. */
2537 /* The result of satisfaction of ATOM+ARGS.
2538 This is either boolean_true_node, boolean_false_node or error_mark_node,
2539 where error_mark_node indicates ill-formed satisfaction.
2540 It's set to NULL_TREE while computing satisfaction of ATOM+ARGS for
2544 /* The value of input_location when satisfaction of ATOM+ARGS was first
2546 location_t location
;
2548 /* The range of elements appended to the failed_type_completions vector
2549 during computation of this satisfaction result, encoded as a begin/end
2551 int ftc_begin
, ftc_end
;
2553 /* True if we want to diagnose the above instability when it's detected.
2554 We don't always want to do so, in order to avoid emitting duplicate
2555 diagnostics in some cases. */
2556 bool diagnose_instability
;
2558 /* True if we're in the middle of computing this satisfaction result.
2559 Used during both quiet and noisy satisfaction to detect self-recursive
2564 struct sat_hasher
: ggc_ptr_hash
<sat_entry
>
2566 static hashval_t
hash (sat_entry
*e
)
2568 auto cso
= make_temp_override (comparing_specializations
);
2569 ++comparing_specializations
;
2571 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e
->atom
))
2573 /* Atoms with instantiated mappings are built during satisfaction.
2574 They live only inside the sat_cache, and we build one to query
2575 the cache with each time we instantiate a mapping. */
2576 gcc_assert (!e
->args
);
2577 return hash_atomic_constraint (e
->atom
);
2580 /* Atoms with uninstantiated mappings are built during normalization.
2581 Since normalize_atom caches the atoms it returns, we can assume
2582 pointer-based identity for fast hashing and comparison. Even if this
2583 assumption is violated, that's okay, we'll just get a cache miss. */
2584 hashval_t value
= htab_hash_pointer (e
->atom
);
2586 if (tree map
= ATOMIC_CONSTR_MAP (e
->atom
))
2587 /* Only the parameters that are used in the targets of the mapping
2588 affect the satisfaction value of the atom. So we consider only
2589 the arguments for these parameters, and ignore the rest. */
2590 for (tree target_parms
= TREE_TYPE (map
);
2592 target_parms
= TREE_CHAIN (target_parms
))
2595 tree parm
= TREE_VALUE (target_parms
);
2596 template_parm_level_and_index (parm
, &level
, &index
);
2597 tree arg
= TMPL_ARG (e
->args
, level
, index
);
2598 value
= iterative_hash_template_arg (arg
, value
);
2603 static bool equal (sat_entry
*e1
, sat_entry
*e2
)
2605 auto cso
= make_temp_override (comparing_specializations
);
2606 ++comparing_specializations
;
2608 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
)
2609 != ATOMIC_CONSTR_MAP_INSTANTIATED_P (e2
->atom
))
2612 /* See sat_hasher::hash. */
2613 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1
->atom
))
2615 gcc_assert (!e1
->args
&& !e2
->args
);
2616 return atomic_constraints_identical_p (e1
->atom
, e2
->atom
);
2619 if (e1
->atom
!= e2
->atom
)
2622 if (tree map
= ATOMIC_CONSTR_MAP (e1
->atom
))
2623 for (tree target_parms
= TREE_TYPE (map
);
2625 target_parms
= TREE_CHAIN (target_parms
))
2628 tree parm
= TREE_VALUE (target_parms
);
2629 template_parm_level_and_index (parm
, &level
, &index
);
2630 tree arg1
= TMPL_ARG (e1
->args
, level
, index
);
2631 tree arg2
= TMPL_ARG (e2
->args
, level
, index
);
2632 if (!template_args_equal (arg1
, arg2
))
2639 /* Cache the result of satisfy_atom. */
2640 static GTY((deletable
)) hash_table
<sat_hasher
> *sat_cache
;
2642 /* Cache the result of satisfy_declaration_constraints. */
2643 static GTY((deletable
)) hash_map
<tree
, tree
> *decl_satisfied_cache
;
2645 /* A tool used by satisfy_atom to help manage satisfaction caching and to
2646 diagnose "unstable" satisfaction values. We insert into the cache only
2647 when performing satisfaction quietly. */
2649 struct satisfaction_cache
2651 satisfaction_cache (tree
, tree
, sat_info
);
2660 /* Constructor for the satisfaction_cache class. We're performing satisfaction
2661 of ATOM+ARGS according to INFO. */
2664 ::satisfaction_cache (tree atom
, tree args
, sat_info info
)
2665 : entry(nullptr), info(info
), ftc_begin(-1)
2668 sat_cache
= hash_table
<sat_hasher
>::create_ggc (31);
2670 /* When noisy, we query the satisfaction cache in order to diagnose
2671 "unstable" satisfaction values. */
2674 /* When noisy, constraints have been re-normalized, and that breaks the
2675 pointer-based identity assumption of sat_cache (for atoms with
2676 uninstantiated mappings). So undo this re-normalization by looking in
2677 the atom_cache for the corresponding atom that was used during quiet
2679 if (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2681 if (tree found
= atom_cache
->find (atom
))
2684 /* The lookup should always succeed, but if it fails then let's
2685 just leave 'entry' empty, effectively disabling the cache. */
2690 /* Look up or create the corresponding satisfaction entry. */
2694 sat_entry
**slot
= sat_cache
->find_slot (&elt
, INSERT
);
2697 else if (info
.quiet ())
2699 entry
= ggc_alloc
<sat_entry
> ();
2702 entry
->result
= NULL_TREE
;
2703 entry
->location
= input_location
;
2704 entry
->ftc_begin
= entry
->ftc_end
= -1;
2705 entry
->diagnose_instability
= false;
2706 if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (atom
))
2707 /* We always want to diagnose instability of an atom with an
2708 instantiated parameter mapping. For atoms with an uninstantiated
2709 mapping, we set this flag (in satisfy_atom) only if substitution
2710 into its mapping previously failed. */
2711 entry
->diagnose_instability
= true;
2712 entry
->evaluating
= false;
2717 /* We're evaluating this atom for the first time, and doing so noisily.
2718 This shouldn't happen outside of error recovery situations involving
2719 unstable satisfaction. Let's just leave 'entry' empty, effectively
2720 disabling the cache, and remove the empty slot. */
2721 gcc_checking_assert (seen_error ());
2722 /* Appease hash_table::check_complete_insertion. */
2723 *slot
= ggc_alloc
<sat_entry
> ();
2724 sat_cache
->clear_slot (slot
);
2728 /* Returns the cached satisfaction result if we have one and we're not
2729 recomputing the satisfaction result from scratch. Otherwise returns
2733 satisfaction_cache::get ()
2738 if (entry
->evaluating
)
2740 /* If we get here, it means satisfaction is self-recursive. */
2741 gcc_checking_assert (!entry
->result
|| seen_error ());
2743 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2744 "satisfaction of atomic constraint %qE depends on itself",
2746 return error_mark_node
;
2749 /* This satisfaction result is "potentially unstable" if a type for which
2750 type completion failed during its earlier computation is now complete. */
2751 bool maybe_unstable
= some_type_complete_p (entry
->ftc_begin
,
2754 if (info
.noisy () || maybe_unstable
|| !entry
->result
)
2756 /* We're computing the satisfaction result from scratch. */
2757 entry
->evaluating
= true;
2758 ftc_begin
= vec_safe_length (failed_type_completions
);
2762 return entry
->result
;
2765 /* RESULT is the computed satisfaction result. If RESULT differs from the
2766 previously cached result, this routine issues an appropriate error.
2767 Otherwise, when evaluating quietly, updates the cache appropriately. */
2770 satisfaction_cache::save (tree result
)
2775 gcc_checking_assert (entry
->evaluating
);
2776 entry
->evaluating
= false;
2778 if (entry
->result
&& result
!= entry
->result
)
2781 /* Return error_mark_node to force satisfaction to get replayed
2783 return error_mark_node
;
2786 if (entry
->diagnose_instability
)
2788 auto_diagnostic_group d
;
2789 error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry
->atom
)),
2790 "satisfaction value of atomic constraint %qE changed "
2791 "from %qE to %qE", entry
->atom
, entry
->result
, result
);
2792 inform (entry
->location
,
2793 "satisfaction value first evaluated to %qE from here",
2796 /* For sake of error recovery, allow this latest satisfaction result
2798 entry
->result
= result
;
2805 entry
->result
= result
;
2806 /* Store into this entry the list of relevant failed type completions
2807 that occurred during (re)computation of the satisfaction result. */
2808 gcc_checking_assert (ftc_begin
!= -1);
2809 entry
->ftc_begin
= ftc_begin
;
2810 entry
->ftc_end
= vec_safe_length (failed_type_completions
);
2816 /* Substitute ARGS into constraint-expression T during instantiation of
2817 a member of a class template. */
2820 tsubst_constraint (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2822 /* We also don't want to evaluate concept-checks when substituting the
2823 constraint-expressions of a declaration. */
2824 processing_constraint_expression_sentinel s
;
2826 tree expr
= tsubst_expr (t
, args
, complain
, in_decl
);
2830 static tree
satisfy_constraint_r (tree
, tree
, sat_info info
);
2832 /* Compute the satisfaction of a conjunction. */
2835 satisfy_conjunction (tree t
, tree args
, sat_info info
)
2837 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, info
);
2838 if (lhs
== error_mark_node
|| lhs
== boolean_false_node
)
2840 return satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, info
);
2843 /* The current depth at which we're replaying an error during recursive
2844 diagnosis of a constraint satisfaction failure. */
2846 static int current_constraint_diagnosis_depth
;
2848 /* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded
2849 CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint
2850 satisfaction error. */
2852 static bool concepts_diagnostics_max_depth_exceeded_p
;
2854 /* Recursive subroutine of collect_operands_of_disjunction. T is a normalized
2855 subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs)
2856 and E is the corresponding unnormalized subexpression (composed of
2857 TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */
2860 collect_operands_of_disjunction_r (tree t
, tree e
,
2861 auto_vec
<tree_pair
> *operands
)
2863 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
)
2865 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 0),
2866 TREE_OPERAND (e
, 0), operands
);
2867 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 1),
2868 TREE_OPERAND (e
, 1), operands
);
2872 tree_pair p
= std::make_pair (t
, e
);
2873 operands
->safe_push (p
);
2877 /* Recursively collect the normalized and unnormalized operands of the
2878 disjunction T and append them to OPERANDS in order. */
2881 collect_operands_of_disjunction (tree t
, auto_vec
<tree_pair
> *operands
)
2883 collect_operands_of_disjunction_r (t
, CONSTR_EXPR (t
), operands
);
2886 /* Compute the satisfaction of a disjunction. */
2889 satisfy_disjunction (tree t
, tree args
, sat_info info
)
2891 /* Evaluate each operand with unsatisfaction diagnostics disabled. */
2892 sat_info sub
= info
;
2893 sub
.diagnose_unsatisfaction
= false;
2895 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, sub
);
2896 if (lhs
== boolean_true_node
|| lhs
== error_mark_node
)
2899 tree rhs
= satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, sub
);
2900 if (rhs
== boolean_true_node
|| rhs
== error_mark_node
)
2903 /* Both branches evaluated to false. Explain the satisfaction failure in
2905 if (info
.diagnose_unsatisfaction_p ())
2907 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2908 cp_expr disj_expr
= CONSTR_EXPR (t
);
2909 inform (disj_expr
.get_location (),
2910 "no operand of the disjunction is satisfied");
2911 if (diagnosing_failed_constraint::replay_errors_p ())
2913 /* Replay the error in each branch of the disjunction. */
2914 auto_vec
<tree_pair
> operands
;
2915 collect_operands_of_disjunction (t
, &operands
);
2916 for (unsigned i
= 0; i
< operands
.length (); i
++)
2918 tree norm_op
= operands
[i
].first
;
2919 tree op
= operands
[i
].second
;
2920 location_t loc
= make_location (cp_expr_location (op
),
2921 disj_expr
.get_start (),
2922 disj_expr
.get_finish ());
2923 inform (loc
, "the operand %qE is unsatisfied because", op
);
2924 satisfy_constraint_r (norm_op
, args
, info
);
2929 return boolean_false_node
;
2932 /* Ensures that T is a truth value and not (accidentally, as sometimes
2933 happens) an integer value. */
2936 satisfaction_value (tree t
)
2938 if (t
== error_mark_node
|| t
== boolean_true_node
|| t
== boolean_false_node
)
2941 gcc_assert (TREE_CODE (t
) == INTEGER_CST
2942 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t
),
2943 boolean_type_node
));
2944 if (integer_zerop (t
))
2945 return boolean_false_node
;
2947 return boolean_true_node
;
2950 /* Build a new template argument vector corresponding to the parameter
2951 mapping of the atomic constraint T, using arguments from ARGS. */
2954 get_mapped_args (tree t
, tree args
)
2956 tree map
= ATOMIC_CONSTR_MAP (t
);
2958 /* No map, no arguments. */
2962 /* Determine the depth of the resulting argument vector. */
2964 if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t
))
2965 /* The expression of this atomic constraint comes from a concept definition,
2966 whose template depth is always one, so the resulting argument vector
2967 will also have depth one. */
2970 /* Otherwise, the expression of this atomic constraint comes from
2971 the context of the constrained entity, whose template depth is that
2973 depth
= TMPL_ARGS_DEPTH (args
);
2975 /* Place each argument at its corresponding position in the argument
2976 list. Note that the list will be sparse (not all arguments supplied),
2977 but instantiation is guaranteed to only use the parameters in the
2978 mapping, so null arguments would never be used. */
2979 auto_vec
< vec
<tree
> > lists (depth
);
2980 lists
.quick_grow_cleared (depth
);
2981 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2985 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
2987 /* Insert the argument into its corresponding position. */
2988 vec
<tree
> &list
= lists
[level
- 1];
2989 if (index
>= (int)list
.length ())
2990 list
.safe_grow_cleared (index
+ 1, /*exact=*/false);
2991 list
[index
] = TREE_PURPOSE (p
);
2994 /* Build the new argument list. */
2995 args
= make_tree_vec (lists
.length ());
2996 for (unsigned i
= 0; i
!= lists
.length (); ++i
)
2998 vec
<tree
> &list
= lists
[i
];
2999 tree level
= make_tree_vec (list
.length ());
3000 for (unsigned j
= 0; j
< list
.length(); ++j
)
3001 TREE_VEC_ELT (level
, j
) = list
[j
];
3002 SET_TMPL_ARGS_LEVEL (args
, i
+ 1, level
);
3005 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, 0);
3007 if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args
)
3008 && TMPL_ARGS_DEPTH (args
) == 1)
3010 /* Get rid of the redundant outer TREE_VEC. */
3011 tree level
= TMPL_ARGS_LEVEL (args
, 1);
3019 static void diagnose_atomic_constraint (tree
, tree
, tree
, sat_info
);
3021 /* Compute the satisfaction of an atomic constraint. */
3024 satisfy_atom (tree t
, tree args
, sat_info info
)
3026 /* In case there is a diagnostic, we want to establish the context
3027 prior to printing errors. If no errors occur, this context is
3028 removed before returning. */
3029 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
3031 satisfaction_cache
cache (t
, args
, info
);
3032 if (tree r
= cache
.get ())
3035 /* Perform substitution quietly. */
3036 subst_info
quiet (tf_none
, NULL_TREE
);
3038 /* Instantiate the parameter mapping. */
3039 tree map
= tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, quiet
);
3040 if (map
== error_mark_node
)
3042 /* If instantiation of the parameter mapping fails, the constraint is
3043 not satisfied. Replay the substitution. */
3044 if (info
.diagnose_unsatisfaction_p ())
3045 tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, info
);
3047 /* Since instantiation of the parameter mapping failed, we
3048 want to diagnose potential instability of this satisfaction
3050 cache
.entry
->diagnose_instability
= true;
3051 return cache
.save (boolean_false_node
);
3054 /* Now build a new atom using the instantiated mapping. We use
3055 this atom as a second key to the satisfaction cache, and we
3056 also pass it to diagnose_atomic_constraint so that diagnostics
3057 which refer to the atom display the instantiated mapping. */
3059 ATOMIC_CONSTR_MAP (t
) = map
;
3060 gcc_assert (!ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
));
3061 ATOMIC_CONSTR_MAP_INSTANTIATED_P (t
) = true;
3062 satisfaction_cache
inst_cache (t
, /*args=*/NULL_TREE
, info
);
3063 if (tree r
= inst_cache
.get ())
3065 cache
.entry
->location
= inst_cache
.entry
->location
;
3066 return cache
.save (r
);
3069 /* Rebuild the argument vector from the parameter mapping. */
3070 args
= get_mapped_args (t
, args
);
3072 /* Apply the parameter mapping (i.e., just substitute). */
3073 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3074 tree result
= tsubst_expr (expr
, args
, quiet
.complain
, quiet
.in_decl
);
3075 if (result
== error_mark_node
)
3077 /* If substitution results in an invalid type or expression, the constraint
3078 is not satisfied. Replay the substitution. */
3079 if (info
.diagnose_unsatisfaction_p ())
3080 tsubst_expr (expr
, args
, info
.complain
, info
.in_decl
);
3081 return cache
.save (inst_cache
.save (boolean_false_node
));
3084 /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary,
3085 and EXPR shall be a constant expression of type bool. */
3086 result
= force_rvalue (result
, info
.complain
);
3087 if (result
== error_mark_node
)
3088 return cache
.save (inst_cache
.save (error_mark_node
));
3089 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3092 diagnose_atomic_constraint (t
, args
, result
, info
);
3093 return cache
.save (inst_cache
.save (error_mark_node
));
3096 /* Compute the value of the constraint. */
3099 iloc_sentinel
ils (EXPR_LOCATION (result
));
3100 result
= cxx_constant_value (result
);
3104 result
= maybe_constant_value (result
, NULL_TREE
, mce_true
);
3105 if (!TREE_CONSTANT (result
))
3106 result
= error_mark_node
;
3108 result
= satisfaction_value (result
);
3109 if (result
== boolean_false_node
&& info
.diagnose_unsatisfaction_p ())
3110 diagnose_atomic_constraint (t
, args
, result
, info
);
3112 return cache
.save (inst_cache
.save (result
));
3115 /* Determine if the normalized constraint T is satisfied.
3116 Returns boolean_true_node if the expression/constraint is
3117 satisfied, boolean_false_node if not, and error_mark_node
3118 if the there was an error evaluating the constraint.
3120 The parameter mapping of atomic constraints is simply the
3121 set of template arguments that will be substituted into
3122 the expression, regardless of template parameters appearing
3123 withing. Whether a template argument is used in the atomic
3124 constraint only matters for subsumption. */
3127 satisfy_constraint_r (tree t
, tree args
, sat_info info
)
3129 if (t
== error_mark_node
)
3130 return error_mark_node
;
3132 switch (TREE_CODE (t
))
3135 return satisfy_conjunction (t
, args
, info
);
3137 return satisfy_disjunction (t
, args
, info
);
3139 return satisfy_atom (t
, args
, info
);
3145 /* Check that the normalized constraint T is satisfied for ARGS. */
3148 satisfy_normalized_constraints (tree t
, tree args
, sat_info info
)
3150 auto_timevar
time (TV_CONSTRAINT_SAT
);
3152 auto ovr
= make_temp_override (satisfying_constraint
, true);
3154 /* Turn off template processing. Constraint satisfaction only applies
3155 to non-dependent terms, so we want to ensure full checking here. */
3156 processing_template_decl_sentinel
proc (true);
3158 /* We need to check access during satisfaction. */
3159 deferring_access_check_sentinel
acs (dk_no_deferred
);
3161 /* Constraints are unevaluated operands. */
3164 return satisfy_constraint_r (t
, args
, info
);
3167 /* Return the normal form of the constraints on the placeholder 'auto'
3171 normalize_placeholder_type_constraints (tree t
, bool diag
)
3173 gcc_assert (is_auto (t
));
3174 tree ci
= PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t
);
3178 tree constr
= TREE_VALUE (ci
);
3179 /* The TREE_PURPOSE contains the set of template parameters that were in
3180 scope for this placeholder type; use them as the initial template
3181 parameters for normalization. */
3182 tree initial_parms
= TREE_PURPOSE (ci
);
3184 /* The 'auto' itself is used as the first argument in its own constraints,
3185 and its level is one greater than its template depth. So in order to
3186 capture all used template parameters, we need to add an extra level of
3187 template parameters to the context; a dummy level suffices. */
3189 = tree_cons (size_int (initial_parms
3190 ? TMPL_PARMS_DEPTH (initial_parms
) + 1 : 1),
3191 make_tree_vec (0), initial_parms
);
3193 norm_info
info (diag
);
3194 info
.initial_parms
= initial_parms
;
3195 return normalize_constraint_expression (constr
, info
);
3198 /* Evaluate the constraints of T using ARGS, returning a satisfaction value.
3199 Here, T can be a concept-id, nested-requirement, placeholder 'auto', or
3200 requires-expression. */
3203 satisfy_nondeclaration_constraints (tree t
, tree args
, sat_info info
)
3205 if (t
== error_mark_node
)
3206 return error_mark_node
;
3208 /* Handle REQUIRES_EXPR directly, bypassing satisfaction. */
3209 if (TREE_CODE (t
) == REQUIRES_EXPR
)
3211 auto ovr
= make_temp_override (current_constraint_diagnosis_depth
);
3213 ++current_constraint_diagnosis_depth
;
3214 return tsubst_requires_expr (t
, args
, info
);
3217 /* Get the normalized constraints. */
3219 if (concept_check_p (t
))
3222 tree id
= unpack_concept_check (t
);
3223 args
= TREE_OPERAND (id
, 1);
3224 tree tmpl
= get_concept_check_template (id
);
3225 norm
= normalize_concept_definition (tmpl
, info
.noisy ());
3227 else if (TREE_CODE (t
) == NESTED_REQ
)
3229 norm_info
ninfo (info
.noisy ());
3230 /* The TREE_TYPE contains the set of template parameters that were in
3231 scope for this nested requirement; use them as the initial template
3232 parameters for normalization. */
3233 ninfo
.initial_parms
= TREE_TYPE (t
);
3234 norm
= normalize_constraint_expression (TREE_OPERAND (t
, 0), ninfo
);
3236 else if (is_auto (t
))
3238 norm
= normalize_placeholder_type_constraints (t
, info
.noisy ());
3240 return boolean_true_node
;
3245 /* Perform satisfaction. */
3246 return satisfy_normalized_constraints (norm
, args
, info
);
3249 /* Evaluate the associated constraints of the template specialization T
3250 according to INFO, returning a satisfaction value. */
3253 satisfy_declaration_constraints (tree t
, sat_info info
)
3255 gcc_assert (DECL_P (t
) && TREE_CODE (t
) != TEMPLATE_DECL
);
3256 const tree saved_t
= t
;
3258 /* For inherited constructors, consider the original declaration;
3259 it has the correct template information attached. */
3260 t
= strip_inheriting_ctors (t
);
3261 tree inh_ctor_targs
= NULL_TREE
;
3263 if (tree ti
= DECL_TEMPLATE_INFO (saved_t
))
3264 /* The inherited constructor points to an instantiation of a constructor
3265 template; remember its template arguments. */
3266 inh_ctor_targs
= TI_ARGS (ti
);
3268 /* Update the declaration for diagnostics. */
3272 if (tree
*result
= hash_map_safe_get (decl_satisfied_cache
, saved_t
))
3275 tree args
= NULL_TREE
;
3276 if (tree ti
= DECL_TEMPLATE_INFO (t
))
3278 /* The initial parameter mapping is the complete set of
3279 template arguments substituted into the declaration. */
3280 args
= TI_ARGS (ti
);
3282 args
= add_outermost_template_args (args
, inh_ctor_targs
);
3285 if (regenerated_lambda_fn_p (t
))
3287 /* The TI_ARGS of a regenerated lambda contains only the innermost
3288 set of template arguments. Augment this with the outer template
3289 arguments that were used to regenerate the lambda. */
3290 gcc_assert (!args
|| TMPL_ARGS_DEPTH (args
) == 1);
3291 tree regen_args
= lambda_regenerating_args (t
);
3293 args
= add_to_template_args (regen_args
, args
);
3298 /* If the innermost arguments are dependent, or if the outer arguments
3299 are dependent and are needed by the constraints, we can't check
3300 satisfaction yet so pretend they're satisfied for now. */
3301 if (uses_template_parms (args
)
3302 && ((DECL_TEMPLATE_INFO (t
)
3303 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t
))
3304 && (TMPL_ARGS_DEPTH (args
) == 1
3305 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))))
3306 || uses_outer_template_parms_in_constraints (t
)))
3307 return boolean_true_node
;
3309 /* Get the normalized constraints. */
3310 tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ());
3312 unsigned ftc_count
= vec_safe_length (failed_type_completions
);
3314 tree result
= boolean_true_node
;
3317 if (!push_tinst_level (t
))
3319 push_to_top_level ();
3320 push_access_scope (t
);
3321 result
= satisfy_normalized_constraints (norm
, args
, info
);
3322 pop_access_scope (t
);
3323 pop_from_top_level ();
3327 /* True if this satisfaction is (heuristically) potentially unstable, i.e.
3328 if its result may depend on where in the program it was performed. */
3329 bool maybe_unstable_satisfaction
= false;
3330 if (ftc_count
!= vec_safe_length (failed_type_completions
))
3331 /* Type completion failure occurred during satisfaction. The satisfaction
3332 result may (or may not) materially depend on the completeness of a type,
3333 so we consider it potentially unstable. */
3334 maybe_unstable_satisfaction
= true;
3336 if (maybe_unstable_satisfaction
)
3337 /* Don't cache potentially unstable satisfaction, to allow satisfy_atom
3338 to check the stability the next time around. */;
3339 else if (info
.quiet ())
3340 hash_map_safe_put
<hm_ggc
> (decl_satisfied_cache
, saved_t
, result
);
3345 /* Evaluate the associated constraints of the template T using ARGS as the
3346 innermost set of template arguments and according to INFO, returning a
3347 satisfaction value. */
3350 satisfy_declaration_constraints (tree t
, tree args
, sat_info info
)
3352 /* Update the declaration for diagnostics. */
3355 gcc_assert (TREE_CODE (t
) == TEMPLATE_DECL
);
3357 if (regenerated_lambda_fn_p (t
))
3359 /* As in the two-parameter version of this function. */
3360 gcc_assert (TMPL_ARGS_DEPTH (args
) == 1);
3361 tree lambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t
));
3362 tree outer_args
= TI_ARGS (LAMBDA_EXPR_REGEN_INFO (lambda
));
3363 args
= add_to_template_args (outer_args
, args
);
3366 args
= add_outermost_template_args (t
, args
);
3368 /* If the innermost arguments are dependent, or if the outer arguments
3369 are dependent and are needed by the constraints, we can't check
3370 satisfaction yet so pretend they're satisfied for now. */
3371 if (uses_template_parms (args
)
3372 && (TMPL_ARGS_DEPTH (args
) == 1
3373 || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args
))
3374 || uses_outer_template_parms_in_constraints (t
)))
3375 return boolean_true_node
;
3377 tree result
= boolean_true_node
;
3378 if (tree norm
= get_normalized_constraints_from_decl (t
, info
.noisy ()))
3380 if (!push_tinst_level (t
, args
))
3382 tree pattern
= DECL_TEMPLATE_RESULT (t
);
3383 push_to_top_level ();
3384 push_access_scope (pattern
);
3385 result
= satisfy_normalized_constraints (norm
, args
, info
);
3386 pop_access_scope (pattern
);
3387 pop_from_top_level ();
3394 /* A wrapper around satisfy_declaration_constraints and
3395 satisfy_nondeclaration_constraints which additionally replays
3396 quiet ill-formed satisfaction noisily, so that ill-formed
3397 satisfaction always gets diagnosed. */
3400 constraint_satisfaction_value (tree t
, tree args
, sat_info info
)
3406 r
= satisfy_declaration_constraints (t
, args
, info
);
3408 r
= satisfy_declaration_constraints (t
, info
);
3411 r
= satisfy_nondeclaration_constraints (t
, args
, info
);
3412 if (r
== error_mark_node
&& info
.quiet ()
3413 && !(DECL_P (t
) && warning_suppressed_p (t
)))
3415 /* Replay the error noisily. */
3416 sat_info
noisy (tf_warning_or_error
, info
.in_decl
);
3417 constraint_satisfaction_value (t
, args
, noisy
);
3418 if (DECL_P (t
) && !args
)
3419 /* Avoid giving these errors again. */
3420 suppress_warning (t
);
3425 /* True iff the result of satisfying T using ARGS is BOOLEAN_TRUE_NODE
3426 and false otherwise, even in the case of errors.
3429 - a template declaration
3430 - a template specialization (in which case ARGS must be empty)
3431 - a concept-id (in which case ARGS must be empty)
3432 - a nested-requirement
3433 - a placeholder 'auto'
3434 - a requires-expression. */
3437 constraints_satisfied_p (tree t
, tree args
/*= NULL_TREE */)
3442 sat_info
quiet (tf_none
, NULL_TREE
);
3443 return constraint_satisfaction_value (t
, args
, quiet
) == boolean_true_node
;
3446 /* Evaluate a concept check of the form C<ARGS>. This is only used for the
3447 evaluation of template-ids as id-expressions. */
3450 evaluate_concept_check (tree check
)
3452 if (check
== error_mark_node
)
3453 return error_mark_node
;
3455 gcc_assert (concept_check_p (check
));
3457 /* Check for satisfaction without diagnostics. */
3458 sat_info
quiet (tf_none
, NULL_TREE
);
3459 return constraint_satisfaction_value (check
, /*args=*/NULL_TREE
, quiet
);
3462 /* Evaluate the requires-expression T, returning either boolean_true_node
3463 or boolean_false_node. This is used during folding and constexpr
3467 evaluate_requires_expr (tree t
)
3469 gcc_assert (TREE_CODE (t
) == REQUIRES_EXPR
);
3470 sat_info
quiet (tf_none
, NULL_TREE
);
3471 return constraint_satisfaction_value (t
, /*args=*/NULL_TREE
, quiet
);
3474 /*---------------------------------------------------------------------------
3475 Semantic analysis of requires-expressions
3476 ---------------------------------------------------------------------------*/
3478 /* Finish a requires expression for the given PARMS (possibly
3479 null) and the non-empty sequence of requirements. */
3482 finish_requires_expr (location_t loc
, tree parms
, tree reqs
)
3484 /* Build the node. */
3485 tree r
= build_min (REQUIRES_EXPR
, boolean_type_node
, parms
, reqs
, NULL_TREE
);
3486 TREE_SIDE_EFFECTS (r
) = false;
3487 TREE_CONSTANT (r
) = true;
3488 SET_EXPR_LOCATION (r
, loc
);
3492 /* Construct a requirement for the validity of EXPR. */
3495 finish_simple_requirement (location_t loc
, tree expr
)
3497 tree r
= build_nt (SIMPLE_REQ
, expr
);
3498 SET_EXPR_LOCATION (r
, loc
);
3502 /* Construct a requirement for the validity of TYPE. */
3505 finish_type_requirement (location_t loc
, tree type
)
3507 tree r
= build_nt (TYPE_REQ
, type
);
3508 SET_EXPR_LOCATION (r
, loc
);
3512 /* Construct a requirement for the validity of EXPR, along with
3513 its properties. if TYPE is non-null, then it specifies either
3514 an implicit conversion or argument deduction constraint,
3515 depending on whether any placeholders occur in the type name.
3516 NOEXCEPT_P is true iff the noexcept keyword was specified. */
3519 finish_compound_requirement (location_t loc
, tree expr
, tree type
, bool noexcept_p
)
3521 tree req
= build_nt (COMPOUND_REQ
, expr
, type
);
3522 SET_EXPR_LOCATION (req
, loc
);
3523 COMPOUND_REQ_NOEXCEPT_P (req
) = noexcept_p
;
3527 /* Finish a nested requirement. */
3530 finish_nested_requirement (location_t loc
, tree expr
)
3532 /* Build the requirement, saving the set of in-scope template
3533 parameters as its type. */
3534 tree r
= build1 (NESTED_REQ
, current_template_parms
, expr
);
3535 SET_EXPR_LOCATION (r
, loc
);
3539 /* Check that FN satisfies the structural requirements of a
3540 function concept definition. */
3542 check_function_concept (tree fn
)
3544 /* Check that the function is comprised of only a return statement. */
3545 tree body
= DECL_SAVED_TREE (fn
);
3546 if (TREE_CODE (body
) == BIND_EXPR
)
3547 body
= BIND_EXPR_BODY (body
);
3549 /* Sometimes a function call results in the creation of clean up
3550 points. Allow these to be preserved in the body of the
3551 constraint, as we might actually need them for some constexpr
3553 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
3554 body
= TREE_OPERAND (body
, 0);
3556 /* Check that the definition is written correctly. */
3557 if (TREE_CODE (body
) != RETURN_EXPR
)
3559 location_t loc
= DECL_SOURCE_LOCATION (fn
);
3560 if (TREE_CODE (body
) == STATEMENT_LIST
&& !STATEMENT_LIST_HEAD (body
))
3563 /* The definition was probably erroneous, not empty. */;
3565 error_at (loc
, "definition of concept %qD is empty", fn
);
3568 error_at (loc
, "definition of concept %qD has multiple statements", fn
);
3574 /*---------------------------------------------------------------------------
3575 Equivalence of constraints
3576 ---------------------------------------------------------------------------*/
3578 /* Returns true when A and B are equivalent constraints. */
3580 equivalent_constraints (tree a
, tree b
)
3582 gcc_assert (!a
|| TREE_CODE (a
) == CONSTRAINT_INFO
);
3583 gcc_assert (!b
|| TREE_CODE (b
) == CONSTRAINT_INFO
);
3584 return cp_tree_equal (a
, b
);
3587 /* Returns true if the template declarations A and B have equivalent
3588 constraints. This is the case when A's constraints subsume B's and
3589 when B's also constrain A's. */
3591 equivalently_constrained (tree d1
, tree d2
)
3593 gcc_assert (TREE_CODE (d1
) == TREE_CODE (d2
));
3594 return equivalent_constraints (get_constraints (d1
), get_constraints (d2
));
3597 /*---------------------------------------------------------------------------
3598 Partial ordering of constraints
3599 ---------------------------------------------------------------------------*/
3601 /* Returns true when the constraints in CI strictly subsume
3602 the associated constraints of TMPL. */
3605 strictly_subsumes (tree ci
, tree tmpl
)
3607 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3608 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3610 return subsumes (n1
, n2
) && !subsumes (n2
, n1
);
3613 /* Returns true when the constraints in CI subsume the
3614 associated constraints of TMPL. */
3617 weakly_subsumes (tree ci
, tree tmpl
)
3619 tree n1
= get_normalized_constraints_from_info (ci
, NULL_TREE
);
3620 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3622 return subsumes (n1
, n2
);
3625 /* Determines which of the declarations, A or B, is more constrained.
3626 That is, which declaration's constraints subsume but are not subsumed
3629 Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
3630 than D1, and 0 otherwise. */
3633 more_constrained (tree d1
, tree d2
)
3635 tree n1
= get_normalized_constraints_from_decl (d1
);
3636 tree n2
= get_normalized_constraints_from_decl (d2
);
3639 if (subsumes (n1
, n2
))
3641 if (subsumes (n2
, n1
))
3646 /* Return whether D1 is at least as constrained as D2. */
3649 at_least_as_constrained (tree d1
, tree d2
)
3651 tree n1
= get_normalized_constraints_from_decl (d1
);
3652 tree n2
= get_normalized_constraints_from_decl (d2
);
3654 return subsumes (n1
, n2
);
3657 /*---------------------------------------------------------------------------
3658 Constraint diagnostics
3659 ---------------------------------------------------------------------------*/
3661 /* Returns the best location to diagnose a constraint error. */
3664 get_constraint_error_location (tree t
)
3666 if (location_t loc
= cp_expr_location (t
))
3669 /* If we have a specific location give it. */
3670 tree expr
= CONSTR_EXPR (t
);
3671 if (location_t loc
= cp_expr_location (expr
))
3674 /* If the constraint is normalized from a requires-clause, give
3675 the location as that of the constrained declaration. */
3676 tree cxt
= CONSTR_CONTEXT (t
);
3677 tree src
= cxt
? TREE_VALUE (cxt
) : NULL_TREE
;
3679 /* TODO: This only happens for constrained non-template declarations. */
3681 else if (DECL_P (src
))
3682 return DECL_SOURCE_LOCATION (src
);
3683 /* Otherwise, give the location as the defining concept. */
3684 else if (concept_check_p (src
))
3686 tree id
= unpack_concept_check (src
);
3687 tree tmpl
= TREE_OPERAND (id
, 0);
3689 tmpl
= OVL_FIRST (tmpl
);
3690 return DECL_SOURCE_LOCATION (tmpl
);
3693 return input_location
;
3696 /* Emit a diagnostic for a failed trait. */
3699 diagnose_trait_expr (tree expr
, tree args
)
3701 location_t loc
= cp_expr_location (expr
);
3703 /* Build a "fake" version of the instantiated trait, so we can
3704 get the instantiated types from result. */
3705 ++processing_template_decl
;
3706 expr
= tsubst_expr (expr
, args
, tf_none
, NULL_TREE
);
3707 --processing_template_decl
;
3709 tree t1
= TRAIT_EXPR_TYPE1 (expr
);
3710 tree t2
= TRAIT_EXPR_TYPE2 (expr
);
3711 if (t2
&& TREE_CODE (t2
) == TREE_VEC
)
3713 /* Convert the TREE_VEC of arguments into a TREE_LIST, since we can't
3714 directly print a TREE_VEC but we can a TREE_LIST via the E format
3716 tree list
= NULL_TREE
;
3717 for (tree t
: tree_vec_range (t2
))
3718 list
= tree_cons (NULL_TREE
, t
, list
);
3719 t2
= nreverse (list
);
3721 switch (TRAIT_EXPR_KIND (expr
))
3723 case CPTK_HAS_NOTHROW_ASSIGN
:
3724 inform (loc
, " %qT is not nothrow copy assignable", t1
);
3726 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
3727 inform (loc
, " %qT is not nothrow default constructible", t1
);
3729 case CPTK_HAS_NOTHROW_COPY
:
3730 inform (loc
, " %qT is not nothrow copy constructible", t1
);
3732 case CPTK_HAS_TRIVIAL_ASSIGN
:
3733 inform (loc
, " %qT is not trivially copy assignable", t1
);
3735 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
3736 inform (loc
, " %qT is not trivially default constructible", t1
);
3738 case CPTK_HAS_TRIVIAL_COPY
:
3739 inform (loc
, " %qT is not trivially copy constructible", t1
);
3741 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
3742 inform (loc
, " %qT is not trivially destructible", t1
);
3744 case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS
:
3745 inform (loc
, " %qT does not have unique object representations", t1
);
3747 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
3748 inform (loc
, " %qT does not have a virtual destructor", t1
);
3750 case CPTK_IS_ABSTRACT
:
3751 inform (loc
, " %qT is not an abstract class", t1
);
3753 case CPTK_IS_AGGREGATE
:
3754 inform (loc
, " %qT is not an aggregate", t1
);
3757 inform (loc
, " %qT is not an array", t1
);
3759 case CPTK_IS_ASSIGNABLE
:
3760 inform (loc
, " %qT is not assignable from %qT", t1
, t2
);
3762 case CPTK_IS_BASE_OF
:
3763 inform (loc
, " %qT is not a base of %qT", t1
, t2
);
3765 case CPTK_IS_BOUNDED_ARRAY
:
3766 inform (loc
, " %qT is not a bounded array", t1
);
3769 inform (loc
, " %qT is not a class", t1
);
3772 inform (loc
, " %qT is not a const type", t1
);
3774 case CPTK_IS_CONSTRUCTIBLE
:
3776 inform (loc
, " %qT is not default constructible", t1
);
3778 inform (loc
, " %qT is not constructible from %qE", t1
, t2
);
3780 case CPTK_IS_CONVERTIBLE
:
3781 inform (loc
, " %qT is not convertible from %qE", t2
, t1
);
3784 inform (loc
, " %qT is not an empty class", t1
);
3787 inform (loc
, " %qT is not an enum", t1
);
3790 inform (loc
, " %qT is not a final class", t1
);
3792 case CPTK_IS_FUNCTION
:
3793 inform (loc
, " %qT is not a function", t1
);
3795 case CPTK_IS_INVOCABLE
:
3797 inform (loc
, " %qT is not invocable", t1
);
3799 inform (loc
, " %qT is not invocable by %qE", t1
, t2
);
3801 case CPTK_IS_LAYOUT_COMPATIBLE
:
3802 inform (loc
, " %qT is not layout compatible with %qT", t1
, t2
);
3804 case CPTK_IS_LITERAL_TYPE
:
3805 inform (loc
, " %qT is not a literal type", t1
);
3807 case CPTK_IS_MEMBER_FUNCTION_POINTER
:
3808 inform (loc
, " %qT is not a member function pointer", t1
);
3810 case CPTK_IS_MEMBER_OBJECT_POINTER
:
3811 inform (loc
, " %qT is not a member object pointer", t1
);
3813 case CPTK_IS_MEMBER_POINTER
:
3814 inform (loc
, " %qT is not a member pointer", t1
);
3816 case CPTK_IS_NOTHROW_ASSIGNABLE
:
3817 inform (loc
, " %qT is not nothrow assignable from %qT", t1
, t2
);
3819 case CPTK_IS_NOTHROW_CONSTRUCTIBLE
:
3821 inform (loc
, " %qT is not nothrow default constructible", t1
);
3823 inform (loc
, " %qT is not nothrow constructible from %qE", t1
, t2
);
3825 case CPTK_IS_NOTHROW_CONVERTIBLE
:
3826 inform (loc
, " %qT is not nothrow convertible from %qE", t2
, t1
);
3828 case CPTK_IS_NOTHROW_INVOCABLE
:
3830 inform (loc
, " %qT is not nothrow invocable", t1
);
3832 inform (loc
, " %qT is not nothrow invocable by %qE", t1
, t2
);
3834 case CPTK_IS_OBJECT
:
3835 inform (loc
, " %qT is not an object type", t1
);
3837 case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF
:
3838 inform (loc
, " %qT is not pointer-interconvertible base of %qT",
3842 inform (loc
, " %qT is not a POD type", t1
);
3844 case CPTK_IS_POINTER
:
3845 inform (loc
, " %qT is not a pointer", t1
);
3847 case CPTK_IS_POLYMORPHIC
:
3848 inform (loc
, " %qT is not a polymorphic type", t1
);
3850 case CPTK_IS_REFERENCE
:
3851 inform (loc
, " %qT is not a reference", t1
);
3854 inform (loc
, " %qT is not the same as %qT", t1
, t2
);
3856 case CPTK_IS_SCOPED_ENUM
:
3857 inform (loc
, " %qT is not a scoped enum", t1
);
3859 case CPTK_IS_STD_LAYOUT
:
3860 inform (loc
, " %qT is not an standard layout type", t1
);
3862 case CPTK_IS_TRIVIAL
:
3863 inform (loc
, " %qT is not a trivial type", t1
);
3865 case CPTK_IS_TRIVIALLY_ASSIGNABLE
:
3866 inform (loc
, " %qT is not trivially assignable from %qT", t1
, t2
);
3868 case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE
:
3870 inform (loc
, " %qT is not trivially default constructible", t1
);
3872 inform (loc
, " %qT is not trivially constructible from %qE", t1
, t2
);
3874 case CPTK_IS_TRIVIALLY_COPYABLE
:
3875 inform (loc
, " %qT is not trivially copyable", t1
);
3877 case CPTK_IS_UNBOUNDED_ARRAY
:
3878 inform (loc
, " %qT is not an unbounded array", t1
);
3881 inform (loc
, " %qT is not a union", t1
);
3883 case CPTK_IS_VOLATILE
:
3884 inform (loc
, " %qT is not a volatile type", t1
);
3887 inform (loc
, " %qT cannot yield a rank", t1
);
3889 case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY
:
3890 inform (loc
, " %qT is not a reference that binds to a temporary "
3891 "object of type %qT (direct-initialization)", t1
, t2
);
3893 case CPTK_REF_CONVERTS_FROM_TEMPORARY
:
3894 inform (loc
, " %qT is not a reference that binds to a temporary "
3895 "object of type %qT (copy-initialization)", t1
, t2
);
3897 case CPTK_IS_DEDUCIBLE
:
3898 inform (loc
, " %qD is not deducible from %qT", t1
, t2
);
3900 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
3902 #include "cp-trait.def"
3903 #undef DEFTRAIT_TYPE
3904 /* Type-yielding traits aren't expressions. */
3906 /* We deliberately omit the default case so that when adding a new
3907 trait we'll get reminded (by way of a warning) to handle it here. */
3911 /* Diagnose a substitution failure in the atomic constraint T using ARGS. */
3914 diagnose_atomic_constraint (tree t
, tree args
, tree result
, sat_info info
)
3916 /* If the constraint is already ill-formed, we've previously diagnosed
3917 the reason. We should still say why the constraints aren't satisfied. */
3918 if (t
== error_mark_node
)
3922 loc
= DECL_SOURCE_LOCATION (info
.in_decl
);
3924 loc
= input_location
;
3925 inform (loc
, "invalid constraints");
3929 location_t loc
= get_constraint_error_location (t
);
3930 iloc_sentinel
loc_s (loc
);
3932 /* Generate better diagnostics for certain kinds of expressions. */
3933 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3934 STRIP_ANY_LOCATION_WRAPPER (expr
);
3935 switch (TREE_CODE (expr
))
3938 diagnose_trait_expr (expr
, args
);
3941 gcc_checking_assert (info
.diagnose_unsatisfaction_p ());
3942 /* Clear in_decl before replaying the substitution to avoid emitting
3943 seemingly unhelpful "in declaration ..." notes that follow some
3944 substitution failure error messages. */
3945 info
.in_decl
= NULL_TREE
;
3946 tsubst_requires_expr (expr
, args
, info
);
3949 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3950 error_at (loc
, "constraint %qE has type %qT, not %<bool%>",
3951 t
, TREE_TYPE (result
));
3953 inform (loc
, "the expression %qE evaluated to %<false%>", t
);
3957 GTY(()) tree current_failed_constraint
;
3959 diagnosing_failed_constraint::
3960 diagnosing_failed_constraint (tree t
, tree args
, bool diag
)
3961 : diagnosing_error (diag
)
3963 if (diagnosing_error
)
3965 current_failed_constraint
3966 = tree_cons (args
, t
, current_failed_constraint
);
3967 ++current_constraint_diagnosis_depth
;
3971 diagnosing_failed_constraint::
3972 ~diagnosing_failed_constraint ()
3974 if (diagnosing_error
)
3976 --current_constraint_diagnosis_depth
;
3977 if (current_failed_constraint
)
3978 current_failed_constraint
= TREE_CHAIN (current_failed_constraint
);
3983 /* Whether we are allowed to replay an error that underlies a constraint failure
3984 at the current diagnosis depth. */
3987 diagnosing_failed_constraint::replay_errors_p ()
3989 if (current_constraint_diagnosis_depth
>= concepts_diagnostics_max_depth
)
3991 concepts_diagnostics_max_depth_exceeded_p
= true;
3998 /* Emit diagnostics detailing the failure ARGS to satisfy the constraints
3999 of T. Here, T and ARGS are as in constraints_satisfied_p. */
4002 diagnose_constraints (location_t loc
, tree t
, tree args
)
4004 inform (loc
, "constraints not satisfied");
4006 if (concepts_diagnostics_max_depth
== 0)
4009 /* Replay satisfaction, but diagnose unsatisfaction. */
4010 sat_info
noisy (tf_warning_or_error
, NULL_TREE
, /*diag_unsat=*/true);
4011 constraint_satisfaction_value (t
, args
, noisy
);
4013 static bool suggested_p
;
4014 if (concepts_diagnostics_max_depth_exceeded_p
4015 && current_constraint_diagnosis_depth
== 0
4018 inform (UNKNOWN_LOCATION
,
4019 "set %qs to at least %d for more detail",
4020 "-fconcepts-diagnostics-depth=",
4021 concepts_diagnostics_max_depth
+ 1);
4026 #include "gt-cp-constraint.h"