1 /* Processing rules for constraints.
2 Copyright (C) 2013-2020 Free Software Foundation, Inc.
3 Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "double-int.h"
36 #include "stringpool.h"
41 #include "c-family/c-common.h"
42 #include "c-family/c-objc.h"
43 #include "cp-objcp-common.h"
44 #include "tree-inline.h"
47 #include "type-utils.h"
49 static tree
satisfaction_value (tree t
);
51 /* When we're parsing or substuting a constraint expression, we have slightly
52 different expression semantics. In particular, we don't want to reduce a
53 concept-id to a satisfaction value. */
55 processing_constraint_expression_sentinel::
56 processing_constraint_expression_sentinel ()
58 ++scope_chain
->x_processing_constraint
;
61 processing_constraint_expression_sentinel::
62 ~processing_constraint_expression_sentinel ()
64 --scope_chain
->x_processing_constraint
;
68 processing_constraint_expression_p ()
70 return scope_chain
->x_processing_constraint
!= 0;
73 /*---------------------------------------------------------------------------
74 Constraint expressions
75 ---------------------------------------------------------------------------*/
77 /* Information provided to substitution. */
81 subst_info (tsubst_flags_t cmp
, tree in
)
82 : complain (cmp
), in_decl (in
)
85 /* True if we should not diagnose errors. */
88 return complain
== tf_none
;
91 /* True if we should diagnose errors. */
97 tsubst_flags_t complain
;
101 static tree
satisfy_constraint (tree
, tree
, subst_info
);
103 /* True if T is known to be some type other than bool. Note that this
104 is false for dependent types and errors. */
107 known_non_bool_p (tree t
)
109 return (t
&& !WILDCARD_TYPE_P (t
) && TREE_CODE (t
) != BOOLEAN_TYPE
);
113 check_constraint_atom (cp_expr expr
)
115 if (known_non_bool_p (TREE_TYPE (expr
)))
117 error_at (expr
.get_location (),
118 "constraint expression does not have type %<bool%>");
122 /* Check that we're using function concepts correctly. */
123 if (concept_check_p (expr
))
125 tree id
= unpack_concept_check (expr
);
126 tree tmpl
= TREE_OPERAND (id
, 0);
127 if (OVL_P (tmpl
) && TREE_CODE (expr
) == TEMPLATE_ID_EXPR
)
129 error_at (EXPR_LOC_OR_LOC (expr
, input_location
),
130 "function concept must be called");
139 check_constraint_operands (location_t
, cp_expr lhs
, cp_expr rhs
)
141 return check_constraint_atom (lhs
) && check_constraint_atom (rhs
);
144 /* Validate the semantic properties of the constraint expression. */
147 finish_constraint_binary_op (location_t loc
,
152 gcc_assert (processing_constraint_expression_p ());
153 if (lhs
== error_mark_node
|| rhs
== error_mark_node
)
154 return error_mark_node
;
155 if (!check_constraint_operands (loc
, lhs
, rhs
))
156 return error_mark_node
;
158 cp_expr expr
= build_x_binary_op (loc
, code
,
159 lhs
, TREE_CODE (lhs
),
160 rhs
, TREE_CODE (rhs
),
162 /* When either operand is dependent, the overload set may be non-empty. */
163 if (expr
== error_mark_node
)
164 return error_mark_node
;
165 expr
.set_location (loc
);
166 expr
.set_range (lhs
.get_start (), rhs
.get_finish ());
171 finish_constraint_or_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
173 return finish_constraint_binary_op (loc
, TRUTH_ORIF_EXPR
, lhs
, rhs
);
177 finish_constraint_and_expr (location_t loc
, cp_expr lhs
, cp_expr rhs
)
179 return finish_constraint_binary_op (loc
, TRUTH_ANDIF_EXPR
, lhs
, rhs
);
183 finish_constraint_primary_expr (cp_expr expr
)
185 if (expr
== error_mark_node
)
186 return error_mark_node
;
187 if (!check_constraint_atom (expr
))
188 return cp_expr (error_mark_node
, expr
.get_location ());
192 /* Combine two constraint-expressions with a logical-and. */
195 combine_constraint_expressions (tree lhs
, tree rhs
)
197 processing_constraint_expression_sentinel pce
;
202 return finish_constraint_and_expr (input_location
, lhs
, rhs
);
205 /* Extract the template-id from a concept check. For standard and variable
206 checks, this is simply T. For function concept checks, this is the
210 unpack_concept_check (tree t
)
212 gcc_assert (concept_check_p (t
));
214 if (TREE_CODE (t
) == CALL_EXPR
)
215 t
= CALL_EXPR_FN (t
);
217 gcc_assert (TREE_CODE (t
) == TEMPLATE_ID_EXPR
);
221 /* Extract the TEMPLATE_DECL from a concept check. */
224 get_concept_check_template (tree t
)
226 tree id
= unpack_concept_check (t
);
227 tree tmpl
= TREE_OPERAND (id
, 0);
229 tmpl
= OVL_FIRST (tmpl
);
233 /* Returns true if any of the arguments in the template argument list is
234 a wildcard or wildcard pack. */
237 contains_wildcard_p (tree args
)
239 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
241 tree arg
= TREE_VEC_ELT (args
, i
);
242 if (TREE_CODE (arg
) == WILDCARD_DECL
)
248 /*---------------------------------------------------------------------------
249 Resolution of qualified concept names
250 ---------------------------------------------------------------------------*/
252 /* This facility is used to resolve constraint checks from requirement
253 expressions. A constraint check is a call to a function template declared
254 with the keyword 'concept'.
256 The result of resolution is a pair (a TREE_LIST) whose value is the
257 matched declaration, and whose purpose contains the coerced template
258 arguments that can be substituted into the call. */
260 /* Given an overload set OVL, try to find a unique definition that can be
261 instantiated by the template arguments ARGS.
263 This function is not called for arbitrary call expressions. In particular,
264 the call expression must be written with explicit template arguments
265 and no function arguments. For example:
269 If a single match is found, this returns a TREE_LIST whose VALUE
270 is the constraint function (not the template), and its PURPOSE is
271 the complete set of arguments substituted into the parameter list. */
274 resolve_function_concept_overload (tree ovl
, tree args
)
277 tree cands
= NULL_TREE
;
278 for (lkp_iterator
iter (ovl
); iter
; ++iter
)
281 if (TREE_CODE (tmpl
) != TEMPLATE_DECL
)
284 /* Don't try to deduce checks for non-concepts. We often end up trying
285 to resolve constraints in functional casts as part of a
286 postfix-expression. We can save time and headaches by not
287 instantiating those declarations.
289 NOTE: This masks a potential error, caused by instantiating
290 non-deduced contexts using placeholder arguments. */
291 tree fn
= DECL_TEMPLATE_RESULT (tmpl
);
292 if (DECL_ARGUMENTS (fn
))
294 if (!DECL_DECLARED_CONCEPT_P (fn
))
297 /* Remember the candidate if we can deduce a substitution. */
298 ++processing_template_decl
;
299 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
300 if (tree subst
= coerce_template_parms (parms
, args
, tmpl
))
302 if (subst
== error_mark_node
)
305 cands
= tree_cons (subst
, fn
, cands
);
307 --processing_template_decl
;
311 /* We either had no candidates or failed deductions. */
312 return nerrs
? error_mark_node
: NULL_TREE
;
313 else if (TREE_CHAIN (cands
))
314 /* There are multiple candidates. */
315 return error_mark_node
;
320 /* Determine if the call expression CALL is a constraint check, and
321 return the concept declaration and arguments being checked. If CALL
322 does not denote a constraint check, return NULL. */
325 resolve_function_concept_check (tree call
)
327 gcc_assert (TREE_CODE (call
) == CALL_EXPR
);
329 /* A constraint check must be only a template-id expression.
330 If it's a call to a base-link, its function(s) should be a
331 template-id expression. If this is not a template-id, then
332 it cannot be a concept-check. */
333 tree target
= CALL_EXPR_FN (call
);
334 if (BASELINK_P (target
))
335 target
= BASELINK_FUNCTIONS (target
);
336 if (TREE_CODE (target
) != TEMPLATE_ID_EXPR
)
339 /* Get the overload set and template arguments and try to
340 resolve the target. */
341 tree ovl
= TREE_OPERAND (target
, 0);
343 /* This is a function call of a variable concept... ill-formed. */
344 if (TREE_CODE (ovl
) == TEMPLATE_DECL
)
346 error_at (location_of (call
),
347 "function call of variable concept %qE", call
);
348 return error_mark_node
;
351 tree args
= TREE_OPERAND (target
, 1);
352 return resolve_function_concept_overload (ovl
, args
);
355 /* Returns a pair containing the checked concept and its associated
356 prototype parameter. The result is a TREE_LIST whose TREE_VALUE
357 is the concept (non-template) and whose TREE_PURPOSE contains
358 the converted template arguments, including the deduced prototype
359 parameter (in position 0). */
362 resolve_concept_check (tree check
)
364 gcc_assert (concept_check_p (check
));
365 tree id
= unpack_concept_check (check
);
366 tree tmpl
= TREE_OPERAND (id
, 0);
368 /* If this is an overloaded function concept, perform overload
369 resolution (this only happens when deducing prototype parameters
370 and template introductions). */
371 if (TREE_CODE (tmpl
) == OVERLOAD
)
373 if (OVL_CHAIN (tmpl
))
374 return resolve_function_concept_check (check
);
375 tmpl
= OVL_FIRST (tmpl
);
378 tree args
= TREE_OPERAND (id
, 1);
379 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
380 ++processing_template_decl
;
381 tree result
= coerce_template_parms (parms
, args
, tmpl
);
382 --processing_template_decl
;
383 if (result
== error_mark_node
)
384 return error_mark_node
;
385 return build_tree_list (result
, DECL_TEMPLATE_RESULT (tmpl
));
388 /* Given a call expression or template-id expression to a concept EXPR
389 possibly including a wildcard, deduce the concept being checked and
390 the prototype parameter. Returns true if the constraint and prototype
391 can be deduced and false otherwise. Note that the CHECK and PROTO
392 arguments are set to NULL_TREE if this returns false. */
395 deduce_constrained_parameter (tree expr
, tree
& check
, tree
& proto
)
397 tree info
= resolve_concept_check (expr
);
398 if (info
&& info
!= error_mark_node
)
400 check
= TREE_VALUE (info
);
401 tree arg
= TREE_VEC_ELT (TREE_PURPOSE (info
), 0);
402 if (ARGUMENT_PACK_P (arg
))
403 arg
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0);
404 proto
= TREE_TYPE (arg
);
408 check
= proto
= NULL_TREE
;
412 /* Given a call expression or template-id expression to a concept, EXPR,
413 deduce the concept being checked and return the template arguments.
414 Returns NULL_TREE if deduction fails. */
416 deduce_concept_introduction (tree check
)
418 tree info
= resolve_concept_check (check
);
419 if (info
&& info
!= error_mark_node
)
420 return TREE_PURPOSE (info
);
424 /* Build a constrained placeholder type where SPEC is a type-constraint.
425 SPEC can be anything were concept_definition_p is true.
427 If DECLTYPE_P is true, then the placeholder is decltype(auto).
429 Returns a pair whose FIRST is the concept being checked and whose
430 SECOND is the prototype parameter. */
433 finish_type_constraints (tree spec
, tree args
, tsubst_flags_t complain
)
435 gcc_assert (concept_definition_p (spec
));
437 /* Build an initial concept check. */
438 tree check
= build_type_constraint (spec
, args
, complain
);
439 if (check
== error_mark_node
)
440 return std::make_pair (error_mark_node
, NULL_TREE
);
442 /* Extract the concept and prototype parameter from the check. */
445 if (!deduce_constrained_parameter (check
, con
, proto
))
446 return std::make_pair (error_mark_node
, NULL_TREE
);
448 return std::make_pair (con
, proto
);
451 /*---------------------------------------------------------------------------
452 Expansion of concept definitions
453 ---------------------------------------------------------------------------*/
455 /* Returns the expression of a function concept. */
458 get_returned_expression (tree fn
)
460 /* Extract the body of the function minus the return expression. */
461 tree body
= DECL_SAVED_TREE (fn
);
463 return error_mark_node
;
464 if (TREE_CODE (body
) == BIND_EXPR
)
465 body
= BIND_EXPR_BODY (body
);
466 if (TREE_CODE (body
) != RETURN_EXPR
)
467 return error_mark_node
;
469 return TREE_OPERAND (body
, 0);
472 /* Returns the initializer of a variable concept. */
475 get_variable_initializer (tree var
)
477 tree init
= DECL_INITIAL (var
);
479 return error_mark_node
;
480 if (BRACE_ENCLOSED_INITIALIZER_P (init
)
481 && CONSTRUCTOR_NELTS (init
) == 1)
482 init
= CONSTRUCTOR_ELT (init
, 0)->value
;
486 /* Returns the definition of a variable or function concept. */
489 get_concept_definition (tree decl
)
491 if (TREE_CODE (decl
) == OVERLOAD
)
492 decl
= OVL_FIRST (decl
);
494 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
495 decl
= DECL_TEMPLATE_RESULT (decl
);
497 if (TREE_CODE (decl
) == CONCEPT_DECL
)
498 return DECL_INITIAL (decl
);
500 return get_variable_initializer (decl
);
501 if (TREE_CODE (decl
) == FUNCTION_DECL
)
502 return get_returned_expression (decl
);
506 /*---------------------------------------------------------------------------
507 Normalization of expressions
509 This set of functions will transform an expression into a constraint
510 in a sequence of steps.
511 ---------------------------------------------------------------------------*/
514 debug_parameter_mapping (tree map
)
516 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
518 tree parm
= TREE_VALUE (p
);
519 tree arg
= TREE_PURPOSE (p
);
521 verbatim ("MAP %qD TO %qT", TEMPLATE_TYPE_DECL (parm
), arg
);
523 verbatim ("MAP %qD TO %qE", TEMPLATE_PARM_DECL (parm
), arg
);
524 // debug_tree (parm);
530 debug_argument_list (tree args
)
532 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
534 tree arg
= TREE_VEC_ELT (args
, i
);
536 verbatim ("ARG %qT", arg
);
538 verbatim ("ARG %qE", arg
);
542 /* Associate each parameter in PARMS with its corresponding template
546 map_arguments (tree parms
, tree args
)
548 for (tree p
= parms
; p
; p
= TREE_CHAIN (p
))
553 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
554 TREE_PURPOSE (p
) = TMPL_ARG (args
, level
, index
);
557 TREE_PURPOSE (p
) = TREE_VALUE (p
);
562 /* Build the parameter mapping for EXPR using ARGS. */
565 build_parameter_mapping (tree expr
, tree args
, tree decl
)
567 tree ctx_parms
= NULL_TREE
;
570 gcc_assert (TREE_CODE (decl
) == TEMPLATE_DECL
);
571 ctx_parms
= DECL_TEMPLATE_PARMS (decl
);
573 else if (current_template_parms
)
575 /* TODO: This should probably be the only case, but because the
576 point of declaration of concepts is currently set after the
577 initializer, the template parameter lists are not available
578 when normalizing concept definitions, hence the case above. */
579 ctx_parms
= current_template_parms
;
582 tree parms
= find_template_parameters (expr
, ctx_parms
);
583 tree map
= map_arguments (parms
, args
);
587 /* True if the parameter mappings of two atomic constraints are equivalent. */
590 parameter_mapping_equivalent_p (tree t1
, tree t2
)
592 tree map1
= ATOMIC_CONSTR_MAP (t1
);
593 tree map2
= ATOMIC_CONSTR_MAP (t2
);
596 tree arg1
= TREE_PURPOSE (map1
);
597 tree arg2
= TREE_PURPOSE (map2
);
598 if (!template_args_equal (arg1
, arg2
))
600 map1
= TREE_CHAIN (map1
);
601 map2
= TREE_CHAIN (map2
);
606 /* Provides additional context for normalization. */
608 struct norm_info
: subst_info
610 explicit norm_info (tsubst_flags_t complain
)
611 : subst_info (tf_warning_or_error
| complain
, NULL_TREE
),
615 /* Construct a top-level context for DECL. */
617 norm_info (tree in_decl
, tsubst_flags_t complain
)
618 : subst_info (tf_warning_or_error
| complain
, in_decl
),
619 context (make_context (in_decl
))
622 bool generate_diagnostics() const
624 return complain
& tf_norm
;
627 tree
make_context(tree in_decl
)
629 if (generate_diagnostics ())
630 return build_tree_list (NULL_TREE
, in_decl
);
634 void update_context(tree expr
, tree args
)
636 if (generate_diagnostics ())
638 tree map
= build_parameter_mapping (expr
, args
, in_decl
);
639 context
= tree_cons (map
, expr
, context
);
641 in_decl
= get_concept_check_template (expr
);
644 /* Provides information about the source of a constraint. This is a
645 TREE_LIST whose VALUE is either a concept check or a constrained
646 declaration. The PURPOSE, for concept checks is a parameter mapping
652 static tree
normalize_expression (tree
, tree
, norm_info
);
654 /* Transform a logical-or or logical-and expression into either
655 a conjunction or disjunction. */
658 normalize_logical_operation (tree t
, tree args
, tree_code c
, norm_info info
)
660 tree t0
= normalize_expression (TREE_OPERAND (t
, 0), args
, info
);
661 tree t1
= normalize_expression (TREE_OPERAND (t
, 1), args
, info
);
663 /* Build a new info object for the constraint. */
664 tree ci
= info
.generate_diagnostics()
665 ? build_tree_list (t
, info
.context
)
668 return build2 (c
, ci
, t0
, t1
);
672 normalize_concept_check (tree check
, tree args
, norm_info info
)
674 tree id
= unpack_concept_check (check
);
675 tree tmpl
= TREE_OPERAND (id
, 0);
676 tree targs
= TREE_OPERAND (id
, 1);
678 /* A function concept is wrapped in an overload. */
679 if (TREE_CODE (tmpl
) == OVERLOAD
)
681 /* TODO: Can we diagnose this error during parsing? */
682 if (TREE_CODE (check
) == TEMPLATE_ID_EXPR
)
683 error_at (EXPR_LOC_OR_LOC (check
, input_location
),
684 "function concept must be called");
685 tmpl
= OVL_FIRST (tmpl
);
688 /* Substitute through the arguments of the concept check. */
689 targs
= tsubst_template_args (targs
, args
, info
.complain
, info
.in_decl
);
690 if (targs
== error_mark_node
)
691 return error_mark_node
;
693 /* Build the substitution for the concept definition. */
694 tree parms
= TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl
));
695 /* Turn on template processing; coercing non-type template arguments
696 will automatically assume they're non-dependent. */
697 ++processing_template_decl
;
698 tree subst
= coerce_template_parms (parms
, targs
, tmpl
);
699 --processing_template_decl
;
700 if (subst
== error_mark_node
)
701 return error_mark_node
;
703 /* The concept may have been ill-formed. */
704 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
705 if (def
== error_mark_node
)
706 return error_mark_node
;
708 info
.update_context (check
, args
);
709 return normalize_expression (def
, subst
, info
);
712 /* The normal form of an atom depends on the expression. The normal
713 form of a function call to a function concept is a check constraint
714 for that concept. The normal form of a reference to a variable
715 concept is a check constraint for that concept. Otherwise, the
716 constraint is a predicate constraint. */
719 normalize_atom (tree t
, tree args
, norm_info info
)
721 /* Concept checks are not atomic. */
722 if (concept_check_p (t
))
723 return normalize_concept_check (t
, args
, info
);
725 /* Build the parameter mapping for the atom. */
726 tree map
= build_parameter_mapping (t
, args
, info
.in_decl
);
728 /* Build a new info object for the atom. */
729 tree ci
= build_tree_list (t
, info
.context
);
731 return build1 (ATOMIC_CONSTR
, ci
, map
);
734 /* Returns the normal form of an expression. */
737 normalize_expression (tree t
, tree args
, norm_info info
)
742 if (t
== error_mark_node
)
743 return error_mark_node
;
745 switch (TREE_CODE (t
))
747 case TRUTH_ANDIF_EXPR
:
748 return normalize_logical_operation (t
, args
, CONJ_CONSTR
, info
);
749 case TRUTH_ORIF_EXPR
:
750 return normalize_logical_operation (t
, args
, DISJ_CONSTR
, info
);
752 return normalize_atom (t
, args
, info
);
756 /* Cache of the normalized form of constraints. Marked as deletable because it
757 can all be recalculated. */
758 static GTY((deletable
)) hash_map
<tree
,tree
> *normalized_map
;
761 get_normalized_constraints (tree t
, tree args
, norm_info info
)
763 auto_timevar
time (TV_CONSTRAINT_NORM
);
764 return normalize_expression (t
, args
, info
);
767 /* Returns the normalized constraints from a constraint-info object
768 or NULL_TREE if the constraints are null. ARGS provide the initial
769 arguments for normalization and IN_DECL provides the declaration
770 to which the constraints belong. */
773 get_normalized_constraints_from_info (tree ci
, tree args
, tree in_decl
,
779 /* Substitution errors during normalization are fatal. */
780 ++processing_template_decl
;
781 norm_info
info (in_decl
, diag
? tf_norm
: tf_none
);
782 tree t
= get_normalized_constraints (CI_ASSOCIATED_CONSTRAINTS (ci
),
784 --processing_template_decl
;
789 /* Returns the normalized constraints for the declaration D. */
792 get_normalized_constraints_from_decl (tree d
, bool diag
= false)
797 /* For inherited constructors, consider the original declaration;
798 it has the correct template information attached. */
799 d
= strip_inheriting_ctors (d
);
801 if (TREE_CODE (d
) == TEMPLATE_DECL
)
804 decl
= DECL_TEMPLATE_RESULT (tmpl
);
808 if (tree ti
= DECL_TEMPLATE_INFO (d
))
809 tmpl
= TI_TEMPLATE (ti
);
815 /* Get the most general template for the declaration, and compute
816 arguments from that. This ensures that the arguments used for
817 normalization are always template parameters and not arguments
818 used for outer specializations. For example:
822 template<typename U> requires C<T, U> void f(U);
827 When we normalize the requirements for S<int>::f, we want the
828 arguments to be {T, U}, not {int, U}. One reason for this is that
829 accepting the latter causes the template parameter level of U
830 to be reduced in a way that makes it overly difficult substitute
831 concrete arguments (i.e., eventually {int, int} during satisfaction. */
834 if (DECL_LANG_SPECIFIC(tmpl
) && !DECL_TEMPLATE_SPECIALIZATION (tmpl
))
835 tmpl
= most_general_template (tmpl
);
838 /* If we're not diagnosing errors, use cached constraints, if any. */
840 if (tree
*p
= hash_map_safe_get (normalized_map
, tmpl
))
843 tree args
= generic_targs_for (tmpl
);
844 tree ci
= get_constraints (decl
);
845 tree norm
= get_normalized_constraints_from_info (ci
, args
, tmpl
, diag
);
848 hash_map_safe_put
<hm_ggc
> (normalized_map
, tmpl
, norm
);
853 /* Returns the normal form of TMPL's definition. */
856 normalize_concept_definition (tree tmpl
, bool diag
= false)
859 if (tree
*p
= hash_map_safe_get (normalized_map
, tmpl
))
862 gcc_assert (concept_definition_p (tmpl
));
864 tmpl
= OVL_FIRST (tmpl
);
865 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
866 tree args
= generic_targs_for (tmpl
);
867 tree def
= get_concept_definition (DECL_TEMPLATE_RESULT (tmpl
));
868 ++processing_template_decl
;
869 norm_info
info (tmpl
, diag
? tf_norm
: tf_none
);
870 tree norm
= get_normalized_constraints (def
, args
, info
);
871 --processing_template_decl
;
874 hash_map_safe_put
<hm_ggc
> (normalized_map
, tmpl
, norm
);
879 /* Returns the normal form of TMPL's requirements. */
882 normalize_template_requirements (tree tmpl
, bool diag
= false)
884 return get_normalized_constraints_from_decl (tmpl
, diag
);
887 /* Returns the normal form of TMPL's requirements. */
890 normalize_nontemplate_requirements (tree decl
, bool diag
= false)
892 return get_normalized_constraints_from_decl (decl
, diag
);
895 /* Normalize an EXPR as a constraint using ARGS. */
898 normalize_constraint_expression (tree expr
, tree args
, bool diag
= false)
900 if (!expr
|| expr
== error_mark_node
)
902 ++processing_template_decl
;
903 norm_info
info (diag
? tf_norm
: tf_none
);
904 tree norm
= get_normalized_constraints (expr
, args
, info
);
905 --processing_template_decl
;
909 /* Normalize an EXPR as a constraint. */
912 normalize_constraint_expression (tree expr
, bool diag
= false)
914 if (!expr
|| expr
== error_mark_node
)
917 /* For concept checks, use the supplied template arguments as those used
918 for normalization. Otherwise, there are no template arguments. */
920 if (concept_check_p (expr
))
922 tree id
= unpack_concept_check (expr
);
923 args
= TREE_OPERAND (id
, 1);
928 return normalize_constraint_expression (expr
, args
, diag
);
931 /* 17.4.1.2p2. Two constraints are identical if they are formed
932 from the same expression and the targets of the parameter mapping
936 atomic_constraints_identical_p (tree t1
, tree t2
)
938 gcc_assert (TREE_CODE (t1
) == ATOMIC_CONSTR
);
939 gcc_assert (TREE_CODE (t2
) == ATOMIC_CONSTR
);
941 if (ATOMIC_CONSTR_EXPR (t1
) != ATOMIC_CONSTR_EXPR (t2
))
944 if (!parameter_mapping_equivalent_p (t1
, t2
))
950 /* True if T1 and T2 are equivalent, meaning they have the same syntactic
951 structure and all corresponding constraints are identical. */
954 constraints_equivalent_p (tree t1
, tree t2
)
956 gcc_assert (CONSTR_P (t1
));
957 gcc_assert (CONSTR_P (t2
));
959 if (TREE_CODE (t1
) != TREE_CODE (t2
))
962 switch (TREE_CODE (t1
))
966 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0)))
968 if (!constraints_equivalent_p (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)))
972 if (!atomic_constraints_identical_p(t1
, t2
))
981 /* Compute the hash value for T. */
984 hash_atomic_constraint (tree t
)
986 gcc_assert (TREE_CODE (t
) == ATOMIC_CONSTR
);
988 /* Hash the identity of the expression. */
989 hashval_t val
= htab_hash_pointer (ATOMIC_CONSTR_EXPR (t
));
991 /* Hash the targets of the parameter map. */
992 tree p
= ATOMIC_CONSTR_MAP (t
);
995 val
= iterative_hash_template_arg (TREE_PURPOSE (p
), val
);
1006 add_constraint (tree t
, hash
& h
)
1008 h
.add_int(TREE_CODE (t
));
1009 switch (TREE_CODE (t
))
1013 add_constraint (TREE_OPERAND (t
, 0), h
);
1014 add_constraint (TREE_OPERAND (t
, 1), h
);
1017 h
.merge_hash (hash_atomic_constraint (t
));
1026 /* Computes a hash code for the constraint T. */
1029 iterative_hash_constraint (tree t
, hashval_t val
)
1031 gcc_assert (CONSTR_P (t
));
1032 inchash::hash
h (val
);
1033 inchash::add_constraint (t
, h
);
1037 // -------------------------------------------------------------------------- //
1038 // Constraint Semantic Processing
1040 // The following functions are called by the parser and substitution rules
1041 // to create and evaluate constraint-related nodes.
1043 // The constraints associated with the current template parameters.
1045 current_template_constraints (void)
1047 if (!current_template_parms
)
1049 tree tmpl_constr
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
1050 return build_constraints (tmpl_constr
, NULL_TREE
);
1053 /* If the recently parsed TYPE declares or defines a template or
1054 template specialization, get its corresponding constraints from the
1055 current template parameters and bind them to TYPE's declaration. */
1058 associate_classtype_constraints (tree type
)
1060 if (!type
|| type
== error_mark_node
|| !CLASS_TYPE_P (type
))
1063 /* An explicit class template specialization has no template parameters. */
1064 if (!current_template_parms
)
1067 if (CLASSTYPE_IS_TEMPLATE (type
) || CLASSTYPE_TEMPLATE_SPECIALIZATION (type
))
1069 tree decl
= TYPE_STUB_DECL (type
);
1070 tree ci
= current_template_constraints ();
1072 /* An implicitly instantiated member template declaration already
1073 has associated constraints. If it is defined outside of its
1074 class, then we need match these constraints against those of
1075 original declaration. */
1076 if (tree orig_ci
= get_constraints (decl
))
1078 if (!equivalent_constraints (ci
, orig_ci
))
1080 error ("%qT does not match original declaration", type
);
1081 tree tmpl
= CLASSTYPE_TI_TEMPLATE (type
);
1082 location_t loc
= DECL_SOURCE_LOCATION (tmpl
);
1083 inform (loc
, "original template declaration here");
1084 /* Fall through, so that we define the type anyway. */
1088 set_constraints (decl
, ci
);
1093 /* Create an empty constraint info block. */
1095 static inline tree_constraint_info
*
1096 build_constraint_info ()
1098 return (tree_constraint_info
*)make_node (CONSTRAINT_INFO
);
1101 /* Build a constraint-info object that contains the associated constraints
1102 of a declaration. This also includes the declaration's template
1103 requirements (TREQS) and any trailing requirements for a function
1104 declarator (DREQS). Note that both TREQS and DREQS must be constraints.
1106 If the declaration has neither template nor declaration requirements
1107 this returns NULL_TREE, indicating an unconstrained declaration. */
1110 build_constraints (tree tr
, tree dr
)
1115 tree_constraint_info
* ci
= build_constraint_info ();
1116 ci
->template_reqs
= tr
;
1117 ci
->declarator_reqs
= dr
;
1118 ci
->associated_constr
= combine_constraint_expressions (tr
, dr
);
1123 /* Add constraint RHS to the end of CONSTRAINT_INFO ci. */
1126 append_constraint (tree ci
, tree rhs
)
1128 tree tr
= ci
? CI_TEMPLATE_REQS (ci
) : NULL_TREE
;
1129 tree dr
= ci
? CI_DECLARATOR_REQS (ci
) : NULL_TREE
;
1130 dr
= combine_constraint_expressions (dr
, rhs
);
1133 CI_DECLARATOR_REQS (ci
) = dr
;
1134 tree ac
= combine_constraint_expressions (tr
, dr
);
1135 CI_ASSOCIATED_CONSTRAINTS (ci
) = ac
;
1138 ci
= build_constraints (tr
, dr
);
1142 /* A mapping from declarations to constraint information. */
1144 static GTY ((cache
)) decl_tree_cache_map
*decl_constraints
;
1146 /* Returns the template constraints of declaration T. If T is not
1147 constrained, return NULL_TREE. Note that T must be non-null. */
1150 get_constraints (const_tree t
)
1154 if (!decl_constraints
)
1157 gcc_assert (DECL_P (t
));
1158 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1159 t
= DECL_TEMPLATE_RESULT (t
);
1160 tree
* found
= decl_constraints
->get (CONST_CAST_TREE (t
));
1167 /* Associate the given constraint information CI with the declaration
1168 T. If T is a template, then the constraints are associated with
1169 its underlying declaration. Don't build associations if CI is
1173 set_constraints (tree t
, tree ci
)
1177 gcc_assert (t
&& flag_concepts
);
1178 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1179 t
= DECL_TEMPLATE_RESULT (t
);
1180 bool found
= hash_map_safe_put
<hm_ggc
> (decl_constraints
, t
, ci
);
1181 gcc_assert (!found
);
1184 /* Remove the associated constraints of the declaration T. */
1187 remove_constraints (tree t
)
1189 gcc_assert (DECL_P (t
));
1190 if (TREE_CODE (t
) == TEMPLATE_DECL
)
1191 t
= DECL_TEMPLATE_RESULT (t
);
1193 if (decl_constraints
)
1194 decl_constraints
->remove (t
);
1197 /* If DECL is a friend, substitute into REQS to produce requirements suitable
1198 for declaration matching. */
1201 maybe_substitute_reqs_for (tree reqs
, const_tree decl_
)
1203 if (reqs
== NULL_TREE
)
1205 tree decl
= CONST_CAST_TREE (decl_
);
1206 tree result
= STRIP_TEMPLATE (decl
);
1207 if (DECL_FRIEND_P (result
))
1209 tree tmpl
= decl
== result
? DECL_TI_TEMPLATE (result
) : decl
;
1210 tree gargs
= generic_targs_for (tmpl
);
1211 processing_template_decl_sentinel s
;
1212 if (uses_template_parms (gargs
))
1213 ++processing_template_decl
;
1214 reqs
= tsubst_constraint (reqs
, gargs
,
1215 tf_warning_or_error
, NULL_TREE
);
1220 /* Returns the template-head requires clause for the template
1221 declaration T or NULL_TREE if none. */
1224 get_template_head_requirements (tree t
)
1226 tree ci
= get_constraints (t
);
1229 return CI_TEMPLATE_REQS (ci
);
1232 /* Returns the trailing requires clause of the declarator of
1233 a template declaration T or NULL_TREE if none. */
1236 get_trailing_function_requirements (tree t
)
1238 tree ci
= get_constraints (t
);
1241 return CI_DECLARATOR_REQS (ci
);
1244 /* Construct a sequence of template arguments by prepending
1245 ARG to REST. Either ARG or REST may be null. */
1247 build_concept_check_arguments (tree arg
, tree rest
)
1249 gcc_assert (rest
? TREE_CODE (rest
) == TREE_VEC
: true);
1253 int n
= rest
? TREE_VEC_LENGTH (rest
) : 0;
1254 args
= make_tree_vec (n
+ 1);
1255 TREE_VEC_ELT (args
, 0) = arg
;
1257 for (int i
= 0; i
< n
; ++i
)
1258 TREE_VEC_ELT (args
, i
+ 1) = TREE_VEC_ELT (rest
, i
);
1259 int def
= rest
? GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (rest
) : 0;
1260 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, def
+ 1);
1264 gcc_assert (rest
!= NULL_TREE
);
1270 /* Builds an id-expression of the form `C<Args...>()` where C is a function
1274 build_function_check (tree tmpl
, tree args
, tsubst_flags_t
/*complain*/)
1276 if (TREE_CODE (tmpl
) == TEMPLATE_DECL
)
1278 /* If we just got a template, wrap it in an overload so it looks like any
1279 other template-id. */
1280 tmpl
= ovl_make (tmpl
);
1281 TREE_TYPE (tmpl
) = boolean_type_node
;
1284 /* Perform function concept resolution now so we always have a single
1285 function of the overload set (even if we started with only one; the
1286 resolution function converts template arguments). Note that we still
1287 wrap this in an overload set so we don't upset other parts of the
1288 compiler that expect template-ids referring to function concepts
1289 to have an overload set. */
1290 tree info
= resolve_function_concept_overload (tmpl
, args
);
1291 if (info
== error_mark_node
)
1292 return error_mark_node
;
1295 error ("no matching concepts for %qE", tmpl
);
1296 return error_mark_node
;
1298 args
= TREE_PURPOSE (info
);
1299 tmpl
= DECL_TI_TEMPLATE (TREE_VALUE (info
));
1301 /* Rebuild the singleton overload set; mark the type bool. */
1302 tmpl
= ovl_make (tmpl
, NULL_TREE
);
1303 TREE_TYPE (tmpl
) = boolean_type_node
;
1305 /* Build the id-expression around the overload set. */
1306 tree id
= build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1308 /* Finally, build the call expression around the overload. */
1309 ++processing_template_decl
;
1310 vec
<tree
, va_gc
> *fargs
= make_tree_vector ();
1311 tree call
= build_min_nt_call_vec (id
, fargs
);
1312 TREE_TYPE (call
) = boolean_type_node
;
1313 release_tree_vector (fargs
);
1314 --processing_template_decl
;
1319 /* Builds an id-expression of the form `C<Args...>` where C is a variable
1323 build_variable_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1325 gcc_assert (variable_concept_p (tmpl
));
1326 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1327 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1328 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1329 if (args
== error_mark_node
)
1330 return error_mark_node
;
1331 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1334 /* Builds an id-expression of the form `C<Args...>` where C is a standard
1338 build_standard_check (tree tmpl
, tree args
, tsubst_flags_t complain
)
1340 gcc_assert (standard_concept_p (tmpl
));
1341 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
1342 tree parms
= INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl
));
1343 args
= coerce_template_parms (parms
, args
, tmpl
, complain
);
1344 if (args
== error_mark_node
)
1345 return error_mark_node
;
1346 return build2 (TEMPLATE_ID_EXPR
, boolean_type_node
, tmpl
, args
);
1349 /* Construct an expression that checks TARGET using ARGS. */
1352 build_concept_check (tree target
, tree args
, tsubst_flags_t complain
)
1354 return build_concept_check (target
, NULL_TREE
, args
, complain
);
1357 /* Construct an expression that checks the concept given by DECL. If
1358 concept_definition_p (DECL) is false, this returns null. */
1361 build_concept_check (tree decl
, tree arg
, tree rest
, tsubst_flags_t complain
)
1363 if (arg
== NULL_TREE
&& rest
== NULL_TREE
)
1365 tree id
= build_nt (TEMPLATE_ID_EXPR
, decl
, rest
);
1366 error ("invalid use concept %qE", id
);
1367 return error_mark_node
;
1370 tree args
= build_concept_check_arguments (arg
, rest
);
1372 if (standard_concept_p (decl
))
1373 return build_standard_check (decl
, args
, complain
);
1374 if (variable_concept_p (decl
))
1375 return build_variable_check (decl
, args
, complain
);
1376 if (function_concept_p (decl
))
1377 return build_function_check (decl
, args
, complain
);
1379 return error_mark_node
;
1382 /* Build a template-id that can participate in a concept check. */
1385 build_concept_id (tree decl
, tree args
)
1387 tree check
= build_concept_check (decl
, args
, tf_warning_or_error
);
1388 if (check
== error_mark_node
)
1389 return error_mark_node
;
1390 return unpack_concept_check (check
);
1393 /* Build a template-id that can participate in a concept check, preserving
1394 the source location of the original template-id. */
1397 build_concept_id (tree expr
)
1399 gcc_assert (TREE_CODE (expr
) == TEMPLATE_ID_EXPR
);
1400 tree id
= build_concept_id (TREE_OPERAND (expr
, 0), TREE_OPERAND (expr
, 1));
1401 protected_set_expr_location (id
, cp_expr_location (expr
));
1405 /* Build as template-id with a placeholder that can be used as a
1408 Note that this will diagnose errors if the initial concept check
1412 build_type_constraint (tree decl
, tree args
, tsubst_flags_t complain
)
1414 tree wildcard
= build_nt (WILDCARD_DECL
);
1415 tree check
= build_concept_check (decl
, wildcard
, args
, complain
);
1416 if (check
== error_mark_node
)
1417 return error_mark_node
;
1418 return unpack_concept_check (check
);
1421 /* Returns a TYPE_DECL that contains sufficient information to
1422 build a template parameter of the same kind as PROTO and
1423 constrained by the concept declaration CNC. Note that PROTO
1424 is the first template parameter of CNC.
1426 If specified, ARGS provides additional arguments to the
1427 constraint check. */
1429 build_constrained_parameter (tree cnc
, tree proto
, tree args
)
1431 tree name
= DECL_NAME (cnc
);
1432 tree type
= TREE_TYPE (proto
);
1433 tree decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
1434 CONSTRAINED_PARM_PROTOTYPE (decl
) = proto
;
1435 CONSTRAINED_PARM_CONCEPT (decl
) = cnc
;
1436 CONSTRAINED_PARM_EXTRA_ARGS (decl
) = args
;
1440 /* Create a constraint expression for the given DECL that evaluates the
1441 requirements specified by CONSTR, a TYPE_DECL that contains all the
1442 information necessary to build the requirements (see finish_concept_name
1443 for the layout of that TYPE_DECL).
1445 Note that the constraints are neither reduced nor decomposed. That is
1446 done only after the requires clause has been parsed (or not). */
1449 finish_shorthand_constraint (tree decl
, tree constr
)
1451 /* No requirements means no constraints. */
1455 if (error_operand_p (constr
))
1458 tree proto
= CONSTRAINED_PARM_PROTOTYPE (constr
);
1459 tree con
= CONSTRAINED_PARM_CONCEPT (constr
);
1460 tree args
= CONSTRAINED_PARM_EXTRA_ARGS (constr
);
1462 /* The TS lets use shorthand to constrain a pack of arguments, but the
1465 For the TS, consider:
1467 template<C... Ts> struct s;
1469 If C is variadic (and because Ts is a pack), we associate the
1470 constraint C<Ts...>. In all other cases, we associate
1471 the constraint (C<Ts> && ...).
1473 The standard behavior cannot be overridden by -fconcepts-ts. */
1474 bool variadic_concept_p
= template_parameter_pack_p (proto
);
1475 bool declared_pack_p
= template_parameter_pack_p (decl
);
1476 bool apply_to_each_p
= (cxx_dialect
>= cxx2a
) ? true : !variadic_concept_p
;
1478 /* Get the argument and overload used for the requirement
1479 and adjust it if we're going to expand later. */
1480 tree arg
= template_parm_to_arg (build_tree_list (NULL_TREE
, decl
));
1481 if (apply_to_each_p
&& declared_pack_p
)
1482 arg
= PACK_EXPANSION_PATTERN (TREE_VEC_ELT (ARGUMENT_PACK_ARGS (arg
), 0));
1484 /* Build the concept constraint-expression. */
1485 tree tmpl
= DECL_TI_TEMPLATE (con
);
1487 if (TREE_CODE (con
) == FUNCTION_DECL
)
1488 check
= ovl_make (tmpl
);
1489 check
= build_concept_check (check
, arg
, args
, tf_warning_or_error
);
1491 /* Make the check a fold-expression if needed. */
1492 if (apply_to_each_p
&& declared_pack_p
)
1493 check
= finish_left_unary_fold_expr (check
, TRUTH_ANDIF_EXPR
);
1498 /* Returns a conjunction of shorthand requirements for the template
1499 parameter list PARMS. Note that the requirements are stored in
1500 the TYPE of each tree node. */
1503 get_shorthand_constraints (tree parms
)
1505 tree result
= NULL_TREE
;
1506 parms
= INNERMOST_TEMPLATE_PARMS (parms
);
1507 for (int i
= 0; i
< TREE_VEC_LENGTH (parms
); ++i
)
1509 tree parm
= TREE_VEC_ELT (parms
, i
);
1510 tree constr
= TEMPLATE_PARM_CONSTRAINTS (parm
);
1511 result
= combine_constraint_expressions (result
, constr
);
1516 /* Get the deduced wildcard from a DEDUCED placeholder. If the deduced
1517 wildcard is a pack, return the first argument of that pack. */
1520 get_deduced_wildcard (tree wildcard
)
1522 if (ARGUMENT_PACK_P (wildcard
))
1523 wildcard
= TREE_VEC_ELT (ARGUMENT_PACK_ARGS (wildcard
), 0);
1524 gcc_assert (TREE_CODE (wildcard
) == WILDCARD_DECL
);
1528 /* Returns the prototype parameter for the nth deduced wildcard. */
1531 get_introduction_prototype (tree wildcards
, int index
)
1533 return TREE_TYPE (get_deduced_wildcard (TREE_VEC_ELT (wildcards
, index
)));
1536 /* Introduce a type template parameter. */
1539 introduce_type_template_parameter (tree wildcard
, bool& non_type_p
)
1542 return finish_template_type_parm (class_type_node
, DECL_NAME (wildcard
));
1545 /* Introduce a template template parameter. */
1548 introduce_template_template_parameter (tree wildcard
, bool& non_type_p
)
1551 begin_template_parm_list ();
1552 current_template_parms
= DECL_TEMPLATE_PARMS (TREE_TYPE (wildcard
));
1553 end_template_parm_list ();
1554 return finish_template_template_parm (class_type_node
, DECL_NAME (wildcard
));
1557 /* Introduce a template non-type parameter. */
1560 introduce_nontype_template_parameter (tree wildcard
, bool& non_type_p
)
1563 tree parm
= copy_decl (TREE_TYPE (wildcard
));
1564 DECL_NAME (parm
) = DECL_NAME (wildcard
);
1568 /* Introduce a single template parameter. */
1571 build_introduced_template_parameter (tree wildcard
, bool& non_type_p
)
1573 tree proto
= TREE_TYPE (wildcard
);
1576 if (TREE_CODE (proto
) == TYPE_DECL
)
1577 parm
= introduce_type_template_parameter (wildcard
, non_type_p
);
1578 else if (TREE_CODE (proto
) == TEMPLATE_DECL
)
1579 parm
= introduce_template_template_parameter (wildcard
, non_type_p
);
1581 parm
= introduce_nontype_template_parameter (wildcard
, non_type_p
);
1583 /* Wrap in a TREE_LIST for process_template_parm. Note that introduced
1584 parameters do not retain the defaults from the source parameter. */
1585 return build_tree_list (NULL_TREE
, parm
);
1588 /* Introduce a single template parameter. */
1591 introduce_template_parameter (tree parms
, tree wildcard
)
1593 gcc_assert (!ARGUMENT_PACK_P (wildcard
));
1594 tree proto
= TREE_TYPE (wildcard
);
1595 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1597 /* Diagnose the case where we have C{...Args}. */
1598 if (WILDCARD_PACK_P (wildcard
))
1600 tree id
= DECL_NAME (wildcard
);
1601 error_at (loc
, "%qE cannot be introduced with an ellipsis %<...%>", id
);
1602 inform (DECL_SOURCE_LOCATION (proto
), "prototype declared here");
1606 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1607 return process_template_parm (parms
, loc
, parm
, non_type_p
, false);
1610 /* Introduce a template parameter pack. */
1613 introduce_template_parameter_pack (tree parms
, tree wildcard
)
1616 tree parm
= build_introduced_template_parameter (wildcard
, non_type_p
);
1617 location_t loc
= DECL_SOURCE_LOCATION (wildcard
);
1618 return process_template_parm (parms
, loc
, parm
, non_type_p
, true);
1621 /* Introduce the nth template parameter. */
1624 introduce_template_parameter (tree parms
, tree wildcards
, int& index
)
1626 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1627 return introduce_template_parameter (parms
, deduced
);
1630 /* Introduce either a template parameter pack or a list of template
1634 introduce_template_parameters (tree parms
, tree wildcards
, int& index
)
1636 /* If the prototype was a parameter, we better have deduced an
1637 argument pack, and that argument must be the last deduced value
1638 in the wildcard vector. */
1639 tree deduced
= TREE_VEC_ELT (wildcards
, index
++);
1640 gcc_assert (ARGUMENT_PACK_P (deduced
));
1641 gcc_assert (index
== TREE_VEC_LENGTH (wildcards
));
1643 /* Introduce each element in the pack. */
1644 tree args
= ARGUMENT_PACK_ARGS (deduced
);
1645 for (int i
= 0; i
< TREE_VEC_LENGTH (args
); ++i
)
1647 tree arg
= TREE_VEC_ELT (args
, i
);
1648 if (WILDCARD_PACK_P (arg
))
1649 parms
= introduce_template_parameter_pack (parms
, arg
);
1651 parms
= introduce_template_parameter (parms
, arg
);
1657 /* Builds the template parameter list PARMS by chaining introduced
1658 parameters from the WILDCARD vector. INDEX is the position of
1659 the current parameter. */
1662 process_introduction_parms (tree parms
, tree wildcards
, int& index
)
1664 tree proto
= get_introduction_prototype (wildcards
, index
);
1665 if (template_parameter_pack_p (proto
))
1666 return introduce_template_parameters (parms
, wildcards
, index
);
1668 return introduce_template_parameter (parms
, wildcards
, index
);
1671 /* Ensure that all template parameters have been introduced for the concept
1672 named in CHECK. If not, emit a diagnostic.
1674 Note that implicitly introducing a parameter with a default argument
1675 creates a case where a parameter is declared, but unnamed, making
1676 it unusable in the definition. */
1679 check_introduction_list (tree intros
, tree check
)
1681 check
= unpack_concept_check (check
);
1682 tree tmpl
= TREE_OPERAND (check
, 0);
1684 tmpl
= OVL_FIRST (tmpl
);
1686 tree parms
= DECL_INNERMOST_TEMPLATE_PARMS (tmpl
);
1687 if (TREE_VEC_LENGTH (intros
) < TREE_VEC_LENGTH (parms
))
1689 error_at (input_location
, "all template parameters of %qD must "
1690 "be introduced", tmpl
);
1697 /* Associates a constraint check to the current template based on the
1698 introduction parameters. INTRO_LIST must be a TREE_VEC of WILDCARD_DECLs
1699 containing a chained PARM_DECL which contains the identifier as well as
1700 the source location. TMPL_DECL is the decl for the concept being used.
1701 If we take a concept, C, this will form a check in the form of
1702 C<INTRO_LIST> filling in any extra arguments needed by the defaults
1705 Returns NULL_TREE if no concept could be matched and error_mark_node if
1706 an error occurred when matching. */
1709 finish_template_introduction (tree tmpl_decl
,
1711 location_t intro_loc
)
1713 /* Build a concept check to deduce the actual parameters. */
1714 tree expr
= build_concept_check (tmpl_decl
, intro_list
, tf_none
);
1715 if (expr
== error_mark_node
)
1717 error_at (intro_loc
, "cannot deduce template parameters from "
1718 "introduction list");
1719 return error_mark_node
;
1722 if (!check_introduction_list (intro_list
, expr
))
1723 return error_mark_node
;
1725 tree parms
= deduce_concept_introduction (expr
);
1729 /* Build template parameter scope for introduction. */
1730 tree parm_list
= NULL_TREE
;
1731 begin_template_parm_list ();
1732 int nargs
= MIN (TREE_VEC_LENGTH (parms
), TREE_VEC_LENGTH (intro_list
));
1733 for (int n
= 0; n
< nargs
; )
1734 parm_list
= process_introduction_parms (parm_list
, parms
, n
);
1735 parm_list
= end_template_parm_list (parm_list
);
1737 /* Update the number of arguments to reflect the number of deduced
1738 template parameter introductions. */
1739 nargs
= TREE_VEC_LENGTH (parm_list
);
1741 /* Determine if any errors occurred during matching. */
1742 for (int i
= 0; i
< TREE_VEC_LENGTH (parm_list
); ++i
)
1743 if (TREE_VALUE (TREE_VEC_ELT (parm_list
, i
)) == error_mark_node
)
1745 end_template_decl ();
1746 return error_mark_node
;
1749 /* Build a concept check for our constraint. */
1750 tree check_args
= make_tree_vec (nargs
);
1752 for (; n
< TREE_VEC_LENGTH (parm_list
); ++n
)
1754 tree parm
= TREE_VEC_ELT (parm_list
, n
);
1755 TREE_VEC_ELT (check_args
, n
) = template_parm_to_arg (parm
);
1757 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (check_args
, n
);
1759 /* If the template expects more parameters we should be able
1760 to use the defaults from our deduced concept. */
1761 for (; n
< TREE_VEC_LENGTH (parms
); ++n
)
1762 TREE_VEC_ELT (check_args
, n
) = TREE_VEC_ELT (parms
, n
);
1764 /* Associate the constraint. */
1765 tree check
= build_concept_check (tmpl_decl
,
1767 tf_warning_or_error
);
1768 TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
) = check
;
1774 /* Given the concept check T from a constrained-type-specifier, extract
1775 its TMPL and ARGS. FIXME why do we need two different forms of
1776 constrained-type-specifier? */
1779 placeholder_extract_concept_and_args (tree t
, tree
&tmpl
, tree
&args
)
1781 if (concept_check_p (t
))
1783 t
= unpack_concept_check (t
);
1784 tmpl
= TREE_OPERAND (t
, 0);
1785 if (TREE_CODE (tmpl
) == OVERLOAD
)
1786 tmpl
= OVL_FIRST (tmpl
);
1787 args
= TREE_OPERAND (t
, 1);
1791 if (TREE_CODE (t
) == TYPE_DECL
)
1793 /* A constrained parameter. Build a constraint check
1794 based on the prototype parameter and then extract the
1795 arguments from that. */
1796 tree proto
= CONSTRAINED_PARM_PROTOTYPE (t
);
1797 tree check
= finish_shorthand_constraint (proto
, t
);
1798 placeholder_extract_concept_and_args (check
, tmpl
, args
);
1803 /* Returns true iff the placeholders C1 and C2 are equivalent. C1
1804 and C2 can be either TEMPLATE_TYPE_PARM or template-ids. */
1807 equivalent_placeholder_constraints (tree c1
, tree c2
)
1809 if (c1
&& TREE_CODE (c1
) == TEMPLATE_TYPE_PARM
)
1810 /* A constrained auto. */
1811 c1
= PLACEHOLDER_TYPE_CONSTRAINTS (c1
);
1812 if (c2
&& TREE_CODE (c2
) == TEMPLATE_TYPE_PARM
)
1813 c2
= PLACEHOLDER_TYPE_CONSTRAINTS (c2
);
1819 if (c1
== error_mark_node
|| c2
== error_mark_node
)
1820 /* We get here during satisfaction; when a deduction constraint
1821 fails, substitution can produce an error_mark_node for the
1822 placeholder constraints. */
1825 tree t1
, t2
, a1
, a2
;
1826 placeholder_extract_concept_and_args (c1
, t1
, a1
);
1827 placeholder_extract_concept_and_args (c2
, t2
, a2
);
1832 int len1
= TREE_VEC_LENGTH (a1
);
1833 int len2
= TREE_VEC_LENGTH (a2
);
1837 /* Skip the first argument so we don't infinitely recurse.
1838 Also, they may differ in template parameter index. */
1839 for (int i
= 1; i
< len1
; ++i
)
1841 tree t1
= TREE_VEC_ELT (a1
, i
);
1842 tree t2
= TREE_VEC_ELT (a2
, i
);
1843 if (!template_args_equal (t1
, t2
))
1849 /* Return a hash value for the placeholder ATOMIC_CONSTR C. */
1852 hash_placeholder_constraint (tree c
)
1855 placeholder_extract_concept_and_args (c
, t
, a
);
1857 /* Like hash_tmpl_and_args, but skip the first argument. */
1858 hashval_t val
= iterative_hash_object (DECL_UID (t
), 0);
1860 for (int i
= TREE_VEC_LENGTH (a
)-1; i
> 0; --i
)
1861 val
= iterative_hash_template_arg (TREE_VEC_ELT (a
, i
), val
);
1866 /* Substitute through the simple requirement. */
1869 tsubst_valid_expression_requirement (tree t
, tree args
, subst_info info
)
1871 tree r
= tsubst_expr (t
, args
, info
.complain
, info
.in_decl
, false);
1872 if (convert_to_void (r
, ICV_STATEMENT
, info
.complain
) == error_mark_node
)
1873 return error_mark_node
;
1878 /* Substitute through the simple requirement. */
1881 tsubst_simple_requirement (tree t
, tree args
, subst_info info
)
1883 tree t0
= TREE_OPERAND (t
, 0);
1884 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
1885 if (expr
== error_mark_node
)
1886 return error_mark_node
;
1887 return finish_simple_requirement (EXPR_LOCATION (t
), expr
);
1890 /* Substitute through the type requirement. */
1893 tsubst_type_requirement (tree t
, tree args
, subst_info info
)
1895 tree t0
= TREE_OPERAND (t
, 0);
1896 tree type
= tsubst (t0
, args
, info
.complain
, info
.in_decl
);
1897 if (type
== error_mark_node
)
1898 return error_mark_node
;
1899 return finish_type_requirement (EXPR_LOCATION (t
), type
);
1902 /* True if TYPE can be deduced from EXPR. */
1905 type_deducible_p (tree expr
, tree type
, tree placeholder
, tree args
,
1908 /* Make sure deduction is performed against ( EXPR ), so that
1909 references are preserved in the result. */
1910 expr
= force_paren_expr_uneval (expr
);
1912 /* Replace the constraints with the instantiated constraints. This
1913 substitutes args into any template parameters in the trailing
1915 tree saved_constr
= PLACEHOLDER_TYPE_CONSTRAINTS (placeholder
);
1917 = tsubst_constraint (saved_constr
,
1919 info
.complain
| tf_partial
,
1922 if (subst_constr
== error_mark_node
)
1925 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder
) = subst_constr
;
1927 /* Temporarily unlink the canonical type. */
1928 tree saved_type
= TYPE_CANONICAL (placeholder
);
1929 TYPE_CANONICAL (placeholder
) = NULL_TREE
;
1932 = do_auto_deduction (type
,
1938 PLACEHOLDER_TYPE_CONSTRAINTS (placeholder
) = saved_constr
;
1939 TYPE_CANONICAL (placeholder
) = saved_type
;
1941 if (deduced_type
== error_mark_node
)
1947 /* True if EXPR can not be converted to TYPE. */
1950 expression_convertible_p (tree expr
, tree type
, subst_info info
)
1953 perform_direct_initialization_if_possible (type
, expr
, false,
1955 if (conv
== error_mark_node
)
1957 if (conv
== NULL_TREE
)
1959 if (info
.complain
& tf_error
)
1961 location_t loc
= EXPR_LOC_OR_LOC (expr
, input_location
);
1962 error_at (loc
, "cannot convert %qE to %qT", expr
, type
);
1970 /* Substitute through the compound requirement. */
1973 tsubst_compound_requirement (tree t
, tree args
, subst_info info
)
1975 tree t0
= TREE_OPERAND (t
, 0);
1976 tree t1
= TREE_OPERAND (t
, 1);
1977 tree expr
= tsubst_valid_expression_requirement (t0
, args
, info
);
1978 if (expr
== error_mark_node
)
1979 return error_mark_node
;
1981 /* Check the noexcept condition. */
1982 bool noexcept_p
= COMPOUND_REQ_NOEXCEPT_P (t
);
1983 if (noexcept_p
&& !expr_noexcept_p (expr
, tf_none
))
1984 return error_mark_node
;
1986 /* Substitute through the type expression, if any. */
1987 tree type
= tsubst (t1
, args
, info
.complain
, info
.in_decl
);
1988 if (type
== error_mark_node
)
1989 return error_mark_node
;
1991 subst_info
quiet (tf_none
, info
.in_decl
);
1993 /* Check expression against the result type. */
1996 if (tree placeholder
= type_uses_auto (type
))
1998 if (!type_deducible_p (expr
, type
, placeholder
, args
, quiet
))
1999 return error_mark_node
;
2001 else if (!expression_convertible_p (expr
, type
, quiet
))
2002 return error_mark_node
;
2005 return finish_compound_requirement (EXPR_LOCATION (t
),
2006 expr
, type
, noexcept_p
);
2010 tsubst_nested_requirement (tree t
, tree args
, subst_info info
)
2012 /* Ensure that we're in an evaluation context prior to satisfaction. */
2013 tree norm
= TREE_TYPE (t
);
2014 tree result
= satisfy_constraint (norm
, args
, info
);
2015 if (result
== error_mark_node
&& info
.quiet ())
2017 subst_info
noisy (tf_warning_or_error
, info
.in_decl
);
2018 satisfy_constraint (norm
, args
, noisy
);
2020 if (result
!= boolean_true_node
)
2021 return error_mark_node
;
2025 /* Substitute ARGS into the requirement T. */
2028 tsubst_requirement (tree t
, tree args
, subst_info info
)
2030 iloc_sentinel
loc_s (cp_expr_location (t
));
2031 switch (TREE_CODE (t
))
2034 return tsubst_simple_requirement (t
, args
, info
);
2036 return tsubst_type_requirement (t
, args
, info
);
2038 return tsubst_compound_requirement (t
, args
, info
);
2040 return tsubst_nested_requirement (t
, args
, info
);
2047 /* Substitute ARGS into the list of requirements T. Note that
2048 substitution failures here result in ill-formed programs. */
2051 tsubst_requirement_body (tree t
, tree args
, subst_info info
)
2053 tree result
= NULL_TREE
;
2056 tree req
= tsubst_requirement (TREE_VALUE (t
), args
, info
);
2057 if (req
== error_mark_node
)
2058 return error_mark_node
;
2059 result
= tree_cons (NULL_TREE
, req
, result
);
2062 return nreverse (result
);
2066 declare_constraint_vars (tree parms
, tree vars
)
2069 for (tree t
= parms
; t
; t
= DECL_CHAIN (t
))
2071 if (DECL_PACK_P (t
))
2073 tree pack
= extract_fnparm_pack (t
, &s
);
2074 register_local_specialization (pack
, t
);
2078 register_local_specialization (s
, t
);
2085 /* Substitute through as if checking function parameter types. This
2086 will diagnose common parameter type errors. Returns error_mark_node
2087 if an error occurred. */
2090 check_constaint_variables (tree t
, tree args
, subst_info info
)
2092 tree types
= NULL_TREE
;
2094 while (p
&& !VOID_TYPE_P (p
))
2096 types
= tree_cons (NULL_TREE
, TREE_TYPE (p
), types
);
2099 types
= chainon (nreverse (types
), void_list_node
);
2100 return tsubst_function_parms (types
, args
, info
.complain
, info
.in_decl
);
2103 /* A subroutine of tsubst_parameterized_constraint. Substitute ARGS
2104 into the parameter list T, producing a sequence of constraint
2105 variables, declared in the current scope.
2107 Note that the caller must establish a local specialization stack
2108 prior to calling this function since this substitution will
2109 declare the substituted parameters. */
2112 tsubst_constraint_variables (tree t
, tree args
, subst_info info
)
2114 /* Perform a trial substitution to check for type errors. */
2115 tree parms
= check_constaint_variables (t
, args
, info
);
2116 if (parms
== error_mark_node
)
2117 return error_mark_node
;
2119 /* Clear cp_unevaluated_operand across tsubst so that we get a proper chain
2121 int saved_unevaluated_operand
= cp_unevaluated_operand
;
2122 cp_unevaluated_operand
= 0;
2123 tree vars
= tsubst (t
, args
, info
.complain
, info
.in_decl
);
2124 cp_unevaluated_operand
= saved_unevaluated_operand
;
2125 if (vars
== error_mark_node
)
2126 return error_mark_node
;
2127 return declare_constraint_vars (t
, vars
);
2130 /* Substitute ARGS into the requires-expression T. [8.4.7]p6. The
2131 substitution of template arguments into a requires-expression
2132 may result in the formation of invalid types or expressions
2133 in its requirements ... In such cases, the expression evaluates
2134 to false; it does not cause the program to be ill-formed.
2136 However, there are cases where substitution must produce a
2137 new requires-expression, that is not a template constraint.
2140 template<typename T>
2142 template<typename U>
2143 static constexpr bool var = requires (U u) { T::fn(u); };
2146 In the instantiation of X<Y> (assuming Y defines fn), then the
2147 instantiated requires-expression would include Y::fn(u). If any
2148 substitution in the requires-expression fails, we can immediately
2149 fold the expression to false, as would be the case e.g., when
2150 instantiation X<int>. */
2153 tsubst_requires_expr (tree t
, tree args
,
2154 tsubst_flags_t complain
, tree in_decl
)
2156 local_specialization_stack
stack (lss_copy
);
2158 subst_info
info (complain
, in_decl
);
2160 /* A requires-expression is an unevaluated context. */
2163 tree parms
= TREE_OPERAND (t
, 0);
2166 parms
= tsubst_constraint_variables (parms
, args
, info
);
2167 if (parms
== error_mark_node
)
2168 return boolean_false_node
;
2171 tree reqs
= TREE_OPERAND (t
, 1);
2172 reqs
= tsubst_requirement_body (reqs
, args
, info
);
2173 if (reqs
== error_mark_node
)
2174 return boolean_false_node
;
2176 /* In certain cases, produce a new requires-expression.
2177 Otherwise the value of the expression is true. */
2178 if (processing_template_decl
&& uses_template_parms (args
))
2179 return finish_requires_expr (cp_expr_location (t
), parms
, reqs
);
2181 return boolean_true_node
;
2184 /* Substitute ARGS into the constraint information CI, producing a new
2185 constraint record. */
2188 tsubst_constraint_info (tree t
, tree args
,
2189 tsubst_flags_t complain
, tree in_decl
)
2191 if (!t
|| t
== error_mark_node
|| !check_constraint_info (t
))
2194 tree tr
= tsubst_constraint (CI_TEMPLATE_REQS (t
), args
, complain
, in_decl
);
2195 tree dr
= tsubst_constraint (CI_DECLARATOR_REQS (t
), args
, complain
, in_decl
);
2196 return build_constraints (tr
, dr
);
2199 /* Substitute through a parameter mapping, in order to get the actual
2200 arguments used to instantiate an atomic constraint. This may fail
2201 if the substitution into arguments produces something ill-formed. */
2204 tsubst_parameter_mapping (tree map
, tree args
, subst_info info
)
2209 tsubst_flags_t complain
= info
.complain
;
2210 tree in_decl
= info
.in_decl
;
2212 tree result
= NULL_TREE
;
2213 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2215 if (p
== error_mark_node
)
2216 return error_mark_node
;
2217 tree parm
= TREE_VALUE (p
);
2218 tree arg
= TREE_PURPOSE (p
);
2219 tree new_arg
= NULL_TREE
;
2222 /* If a template parameter is declared with a placeholder, we can
2223 get those in the argument list if decltype is applied to the
2224 placeholder. For example:
2227 requires C<decltype(T)>
2230 The normalized argument for C will be an auto type, so we'll
2231 need to deduce the actual argument from the corresponding
2232 initializer (whatever argument is provided for T), and use
2233 that result in the instantiated parameter mapping. */
2234 if (tree auto_node
= type_uses_auto (arg
))
2238 template_parm_level_and_index (parm
, &level
, &index
);
2239 tree init
= TMPL_ARG (args
, level
, index
);
2240 new_arg
= do_auto_deduction (arg
, init
, auto_node
,
2241 complain
, adc_variable_type
,
2245 else if (ARGUMENT_PACK_P (arg
))
2246 new_arg
= tsubst_argument_pack (arg
, args
, complain
, in_decl
);
2249 new_arg
= tsubst_template_arg (arg
, args
, complain
, in_decl
);
2250 if (TYPE_P (new_arg
))
2251 new_arg
= canonicalize_type_argument (new_arg
, complain
);
2253 if (new_arg
== error_mark_node
)
2254 return error_mark_node
;
2256 result
= tree_cons (new_arg
, parm
, result
);
2258 return nreverse (result
);
2262 tsubst_parameter_mapping (tree map
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2264 return tsubst_parameter_mapping (map
, args
, subst_info (complain
, in_decl
));
2267 /*---------------------------------------------------------------------------
2268 Constraint satisfaction
2269 ---------------------------------------------------------------------------*/
2271 /* Hash functions for satisfaction entries. */
2273 struct GTY((for_user
)) sat_entry
2280 struct sat_hasher
: ggc_ptr_hash
<sat_entry
>
2282 static hashval_t
hash (sat_entry
*e
)
2284 hashval_t value
= hash_atomic_constraint (e
->constr
);
2285 return iterative_hash_template_arg (e
->args
, value
);
2288 static bool equal (sat_entry
*e1
, sat_entry
*e2
)
2290 if (!atomic_constraints_identical_p (e1
->constr
, e2
->constr
))
2292 return template_args_equal (e1
->args
, e2
->args
);
2296 /* Cache the result of satisfy_atom. */
2297 static GTY((deletable
)) hash_table
<sat_hasher
> *sat_cache
;
2299 /* Cache the result of constraint_satisfaction_value. */
2300 static GTY((deletable
)) hash_map
<tree
, tree
> *decl_satisfied_cache
;
2303 get_satisfaction (tree constr
, tree args
)
2307 sat_entry elt
= { constr
, args
, NULL_TREE
};
2308 sat_entry
* found
= sat_cache
->find (&elt
);
2310 return found
->result
;
2316 save_satisfaction (tree constr
, tree args
, tree result
)
2319 sat_cache
= hash_table
<sat_hasher
>::create_ggc (31);
2320 sat_entry elt
= {constr
, args
, result
};
2321 sat_entry
** slot
= sat_cache
->find_slot (&elt
, INSERT
);
2322 sat_entry
* entry
= ggc_alloc
<sat_entry
> ();
2328 clear_satisfaction_cache ()
2331 sat_cache
->empty ();
2332 if (decl_satisfied_cache
)
2333 decl_satisfied_cache
->empty ();
2336 /* A tool to help manage satisfaction caching in satisfy_constraint_r.
2337 Note the cache is only used when not diagnosing errors. */
2339 struct satisfaction_cache
2341 satisfaction_cache (tree constr
, tree args
, tsubst_flags_t complain
)
2342 : constr(constr
), args(args
), complain(complain
)
2347 if (complain
== tf_none
)
2348 return get_satisfaction (constr
, args
);
2352 tree
save (tree result
)
2354 if (complain
== tf_none
)
2355 save_satisfaction (constr
, args
, result
);
2361 tsubst_flags_t complain
;
2364 static int satisfying_constraint
= 0;
2366 /* Returns true if we are currently satisfying a constraint.
2368 This is used to guard against recursive calls to evaluate_concept_check
2369 during template argument substitution.
2371 TODO: Do we need this now that we fully normalize prior to evaluation?
2375 satisfying_constraint_p ()
2377 return satisfying_constraint
;
2380 /* Substitute ARGS into constraint-expression T during instantiation of
2381 a member of a class template. */
2384 tsubst_constraint (tree t
, tree args
, tsubst_flags_t complain
, tree in_decl
)
2386 /* We also don't want to evaluate concept-checks when substituting the
2387 constraint-expressions of a declaration. */
2388 processing_constraint_expression_sentinel s
;
2389 tree expr
= tsubst_expr (t
, args
, complain
, in_decl
, false);
2393 static tree
satisfy_constraint_r (tree
, tree
, subst_info info
);
2395 /* Compute the satisfaction of a conjunction. */
2398 satisfy_conjunction (tree t
, tree args
, subst_info info
)
2400 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, info
);
2401 if (lhs
== error_mark_node
|| lhs
== boolean_false_node
)
2403 return satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, info
);
2406 /* The current depth at which we're replaying an error during recursive
2407 diagnosis of a constraint satisfaction failure. */
2409 static int current_constraint_diagnosis_depth
;
2411 /* Whether CURRENT_CONSTRAINT_DIAGNOSIS_DEPTH has ever exceeded
2412 CONCEPTS_DIAGNOSTICS_MAX_DEPTH during recursive diagnosis of a constraint
2413 satisfaction error. */
2415 static bool concepts_diagnostics_max_depth_exceeded_p
;
2417 /* Recursive subroutine of collect_operands_of_disjunction. T is a normalized
2418 subexpression of a constraint (composed of CONJ_CONSTRs and DISJ_CONSTRs)
2419 and E is the corresponding unnormalized subexpression (composed of
2420 TRUTH_ANDIF_EXPRs and TRUTH_ORIF_EXPRs). */
2423 collect_operands_of_disjunction_r (tree t
, tree e
,
2424 auto_vec
<tree_pair
> *operands
)
2426 if (TREE_CODE (e
) == TRUTH_ORIF_EXPR
)
2428 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 0),
2429 TREE_OPERAND (e
, 0), operands
);
2430 collect_operands_of_disjunction_r (TREE_OPERAND (t
, 1),
2431 TREE_OPERAND (e
, 1), operands
);
2435 tree_pair p
= std::make_pair (t
, e
);
2436 operands
->safe_push (p
);
2440 /* Recursively collect the normalized and unnormalized operands of the
2441 disjunction T and append them to OPERANDS in order. */
2444 collect_operands_of_disjunction (tree t
, auto_vec
<tree_pair
> *operands
)
2446 collect_operands_of_disjunction_r (t
, CONSTR_EXPR (t
), operands
);
2449 /* Compute the satisfaction of a disjunction. */
2452 satisfy_disjunction (tree t
, tree args
, subst_info info
)
2454 /* Evaluate the operands quietly. */
2455 subst_info
quiet (tf_none
, NULL_TREE
);
2457 /* Register the constraint for diagnostics, if needed. */
2458 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2460 tree lhs
= satisfy_constraint_r (TREE_OPERAND (t
, 0), args
, quiet
);
2461 if (lhs
== boolean_true_node
)
2462 return boolean_true_node
;
2463 tree rhs
= satisfy_constraint_r (TREE_OPERAND (t
, 1), args
, quiet
);
2464 if (rhs
!= boolean_true_node
&& info
.noisy ())
2466 cp_expr disj_expr
= CONSTR_EXPR (t
);
2467 inform (disj_expr
.get_location (),
2468 "no operand of the disjunction is satisfied");
2469 if (diagnosing_failed_constraint::replay_errors_p ())
2471 /* Replay the error in each branch of the disjunction. */
2472 auto_vec
<tree_pair
> operands
;
2473 collect_operands_of_disjunction (t
, &operands
);
2474 for (unsigned i
= 0; i
< operands
.length (); i
++)
2476 tree norm_op
= operands
[i
].first
;
2477 tree op
= operands
[i
].second
;
2478 location_t loc
= make_location (cp_expr_location (op
),
2479 disj_expr
.get_start (),
2480 disj_expr
.get_finish ());
2481 inform (loc
, "the operand %qE is unsatisfied because", op
);
2482 satisfy_constraint_r (norm_op
, args
, info
);
2489 /* Ensures that T is a truth value and not (accidentally, as sometimes
2490 happens) an integer value. */
2493 satisfaction_value (tree t
)
2495 if (t
== error_mark_node
)
2497 if (t
== boolean_true_node
|| t
== integer_one_node
)
2498 return boolean_true_node
;
2499 if (t
== boolean_false_node
|| t
== integer_zero_node
)
2500 return boolean_false_node
;
2502 /* Anything else should be invalid. */
2506 /* Build a new template argument list with template arguments corresponding
2507 to the parameters used in an atomic constraint. */
2510 get_mapped_args (tree map
)
2512 /* No map, no arguments. */
2516 /* Find the mapped parameter with the highest level. */
2518 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2522 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
2527 /* Place each argument at its corresponding position in the argument
2528 list. Note that the list will be sparse (not all arguments supplied),
2529 but instantiation is guaranteed to only use the parameters in the
2530 mapping, so null arguments would never be used. */
2531 auto_vec
< vec
<tree
> > lists (count
);
2532 lists
.quick_grow_cleared (count
);
2533 for (tree p
= map
; p
; p
= TREE_CHAIN (p
))
2537 template_parm_level_and_index (TREE_VALUE (p
), &level
, &index
);
2539 /* Insert the argument into its corresponding position. */
2540 vec
<tree
> &list
= lists
[level
- 1];
2541 if (index
>= (int)list
.length ())
2542 list
.safe_grow_cleared (index
+ 1);
2543 list
[index
] = TREE_PURPOSE (p
);
2546 /* Build the new argument list. */
2547 tree args
= make_tree_vec (lists
.length ());
2548 for (unsigned i
= 0; i
!= lists
.length (); ++i
)
2550 vec
<tree
> &list
= lists
[i
];
2551 tree level
= make_tree_vec (list
.length ());
2552 for (unsigned j
= 0; j
< list
.length(); ++j
)
2553 TREE_VEC_ELT (level
, j
) = list
[j
];
2554 SET_TMPL_ARGS_LEVEL (args
, i
+ 1, level
);
2557 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args
, 0);
2562 static void diagnose_atomic_constraint (tree
, tree
, tree
, subst_info
);
2564 /* Compute the satisfaction of an atomic constraint. */
2567 satisfy_atom (tree t
, tree args
, subst_info info
)
2569 satisfaction_cache
cache (t
, args
, info
.complain
);
2570 if (tree r
= cache
.get ())
2573 /* Perform substitution quietly. */
2574 subst_info
quiet (tf_none
, NULL_TREE
);
2576 /* In case there is a diagnostic, we want to establish the context
2577 prior to printing errors. If no errors occur, this context is
2578 removed before returning. */
2579 diagnosing_failed_constraint
failure (t
, args
, info
.noisy ());
2581 /* Instantiate the parameter mapping. */
2582 tree map
= tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, quiet
);
2583 if (map
== error_mark_node
)
2585 /* If instantiation of the parameter mapping fails, the program
2588 tsubst_parameter_mapping (ATOMIC_CONSTR_MAP (t
), args
, info
);
2589 return cache
.save (boolean_false_node
);
2592 /* Rebuild the argument vector from the parameter mapping. */
2593 args
= get_mapped_args (map
);
2595 /* Apply the parameter mapping (i.e., just substitute). */
2596 tree expr
= ATOMIC_CONSTR_EXPR (t
);
2597 tree result
= tsubst_expr (expr
, args
, quiet
.complain
, quiet
.in_decl
, false);
2598 if (result
== error_mark_node
)
2600 /* If substitution results in an invalid type or expression, the constraint
2601 is not satisfied. Replay the substitution. */
2603 tsubst_expr (expr
, args
, info
.complain
, info
.in_decl
, false);
2604 return cache
.save (boolean_false_node
);
2607 /* [17.4.1.2] ... lvalue-to-rvalue conversion is performed as necessary,
2608 and EXPR shall be a constant expression of type bool. */
2609 result
= force_rvalue (result
, info
.complain
);
2610 if (result
== error_mark_node
)
2611 return cache
.save (error_mark_node
);
2612 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
2615 diagnose_atomic_constraint (t
, map
, result
, info
);
2616 return cache
.save (error_mark_node
);
2619 /* Compute the value of the constraint. */
2621 result
= cxx_constant_value (result
);
2624 result
= maybe_constant_value (result
);
2625 if (!TREE_CONSTANT (result
))
2626 result
= error_mark_node
;
2628 result
= satisfaction_value (result
);
2629 if (result
== boolean_false_node
&& info
.noisy ())
2630 diagnose_atomic_constraint (t
, map
, result
, info
);
2632 return cache
.save (result
);
2635 /* Determine if the normalized constraint T is satisfied.
2636 Returns boolean_true_node if the expression/constraint is
2637 satisfied, boolean_false_node if not, and error_mark_node
2638 if the there was an error evaluating the constraint.
2640 The parameter mapping of atomic constraints is simply the
2641 set of template arguments that will be substituted into
2642 the expression, regardless of template parameters appearing
2643 withing. Whether a template argument is used in the atomic
2644 constraint only matters for subsumption. */
2647 satisfy_constraint_r (tree t
, tree args
, subst_info info
)
2649 if (t
== error_mark_node
)
2650 return error_mark_node
;
2652 switch (TREE_CODE (t
))
2655 return satisfy_conjunction (t
, args
, info
);
2657 return satisfy_disjunction (t
, args
, info
);
2659 return satisfy_atom (t
, args
, info
);
2665 /* Check that the normalized constraint T is satisfied for ARGS. */
2668 satisfy_constraint (tree t
, tree args
, subst_info info
)
2670 auto_timevar
time (TV_CONSTRAINT_SAT
);
2672 /* Turn off template processing. Constraint satisfaction only applies
2673 to non-dependent terms, so we want to ensure full checking here. */
2674 processing_template_decl_sentinel
proc (true);
2676 /* We need to check access during satisfaction. */
2677 deferring_access_check_sentinel
acs (dk_no_deferred
);
2679 return satisfy_constraint_r (t
, args
, info
);
2682 /* Check the normalized constraints T against ARGS, returning a satisfaction
2683 value (either true, false, or error). */
2686 satisfy_associated_constraints (tree t
, tree args
, subst_info info
)
2688 /* If there are no constraints then this is trivially satisfied. */
2690 return boolean_true_node
;
2692 /* If any arguments depend on template parameters, we can't
2693 check constraints. Pretend they're satisfied for now. */
2694 if (args
&& uses_template_parms (args
))
2695 return boolean_true_node
;
2697 return satisfy_constraint (t
, args
, info
);
2700 /* Evaluate EXPR as a constraint expression using ARGS, returning a
2701 satisfaction value. */
2704 satisfy_constraint_expression (tree t
, tree args
, subst_info info
)
2706 if (t
== error_mark_node
)
2707 return error_mark_node
;
2709 gcc_assert (EXPR_P (t
));
2711 /* Get the normalized constraints. */
2713 if (args
== NULL_TREE
&& concept_check_p (t
))
2715 tree id
= unpack_concept_check (t
);
2716 args
= TREE_OPERAND (id
, 1);
2717 tree tmpl
= get_concept_check_template (id
);
2718 norm
= normalize_concept_definition (tmpl
, info
.noisy ());
2721 norm
= normalize_constraint_expression (t
, info
.noisy ());
2723 /* Perform satisfaction. */
2724 return satisfy_constraint (norm
, args
, info
);
2727 /* Used only to evaluate requires-expressions during constant expression
2731 satisfy_constraint_expression (tree expr
)
2733 subst_info
info (tf_none
, NULL_TREE
);
2734 return satisfy_constraint_expression (expr
, NULL_TREE
, info
);
2738 satisfy_declaration_constraints (tree t
, subst_info info
)
2740 gcc_assert (DECL_P (t
));
2741 const tree saved_t
= t
;
2743 /* For inherited constructors, consider the original declaration;
2744 it has the correct template information attached. */
2745 t
= strip_inheriting_ctors (t
);
2746 tree inh_ctor_targs
= NULL_TREE
;
2748 if (tree ti
= DECL_TEMPLATE_INFO (saved_t
))
2749 /* The inherited constructor points to an instantiation of a constructor
2750 template; remember its template arguments. */
2751 inh_ctor_targs
= TI_ARGS (ti
);
2753 /* Update the declaration for diagnostics. */
2757 if (tree
*result
= hash_map_safe_get (decl_satisfied_cache
, saved_t
))
2760 /* Get the normalized constraints. */
2761 tree norm
= NULL_TREE
;
2762 tree args
= NULL_TREE
;
2763 if (tree ti
= DECL_TEMPLATE_INFO (t
))
2765 tree tmpl
= TI_TEMPLATE (ti
);
2766 norm
= normalize_template_requirements (tmpl
, info
.noisy ());
2768 /* The initial parameter mapping is the complete set of
2769 template arguments substituted into the declaration. */
2770 args
= TI_ARGS (ti
);
2772 args
= add_outermost_template_args (args
, inh_ctor_targs
);
2776 /* These should be empty until we allow constraints on non-templates. */
2777 norm
= normalize_nontemplate_requirements (t
, info
.noisy ());
2780 tree result
= boolean_true_node
;
2783 if (!push_tinst_level (t
))
2785 push_access_scope (t
);
2786 result
= satisfy_associated_constraints (norm
, args
, info
);
2787 pop_access_scope (t
);
2792 hash_map_safe_put
<hm_ggc
> (decl_satisfied_cache
, saved_t
, result
);
2798 satisfy_declaration_constraints (tree t
, tree args
, subst_info info
)
2800 /* Update the declaration for diagnostics. */
2803 gcc_assert (TREE_CODE (t
) == TEMPLATE_DECL
);
2804 if (tree norm
= normalize_template_requirements (t
, info
.noisy ()))
2806 tree pattern
= DECL_TEMPLATE_RESULT (t
);
2807 push_access_scope (pattern
);
2808 tree result
= satisfy_associated_constraints (norm
, args
, info
);
2809 pop_access_scope (pattern
);
2813 return boolean_true_node
;
2817 constraint_satisfaction_value (tree t
, tsubst_flags_t complain
)
2819 subst_info
info (complain
, NULL_TREE
);
2822 r
= satisfy_declaration_constraints (t
, info
);
2824 r
= satisfy_constraint_expression (t
, NULL_TREE
, info
);
2825 if (r
== error_mark_node
&& info
.quiet ()
2826 && !(DECL_P (t
) && TREE_NO_WARNING (t
)))
2828 constraint_satisfaction_value (t
, tf_warning_or_error
);
2830 /* Avoid giving these errors again. */
2831 TREE_NO_WARNING (t
) = true;
2837 constraint_satisfaction_value (tree t
, tree args
, tsubst_flags_t complain
)
2839 subst_info
info (complain
, NULL_TREE
);
2842 r
= satisfy_declaration_constraints (t
, args
, info
);
2844 r
= satisfy_constraint_expression (t
, args
, info
);
2845 if (r
== error_mark_node
&& info
.quiet ())
2846 constraint_satisfaction_value (t
, args
, tf_warning_or_error
);
2850 /* True iff the result of satisfying T is BOOLEAN_TRUE_NODE and false
2851 otherwise, even in the case of errors. */
2854 constraints_satisfied_p (tree t
)
2856 return constraint_satisfaction_value (t
, tf_none
) == boolean_true_node
;
2859 /* True iff the result of satisfying T with ARGS is BOOLEAN_TRUE_NODE
2860 and false otherwise, even in the case of errors. */
2863 constraints_satisfied_p (tree t
, tree args
)
2865 return constraint_satisfaction_value (t
, args
, tf_none
) == boolean_true_node
;
2868 /* Evaluate a concept check of the form C<ARGS>. This is only used for the
2869 evaluation of template-ids as id-expressions. */
2872 evaluate_concept_check (tree check
, tsubst_flags_t complain
)
2874 if (check
== error_mark_node
)
2875 return error_mark_node
;
2877 gcc_assert (concept_check_p (check
));
2879 /* Check for satisfaction without diagnostics. */
2880 subst_info
quiet (tf_none
, NULL_TREE
);
2881 tree result
= satisfy_constraint_expression (check
, NULL_TREE
, quiet
);
2882 if (result
== error_mark_node
&& (complain
& tf_error
))
2884 /* Replay the error with re-normalized requirements. */
2885 subst_info
noisy (tf_warning_or_error
, NULL_TREE
);
2886 satisfy_constraint_expression (check
, NULL_TREE
, noisy
);
2891 /*---------------------------------------------------------------------------
2892 Semantic analysis of requires-expressions
2893 ---------------------------------------------------------------------------*/
2895 /* Finish a requires expression for the given PARMS (possibly
2896 null) and the non-empty sequence of requirements. */
2899 finish_requires_expr (location_t loc
, tree parms
, tree reqs
)
2901 /* Modify the declared parameters by removing their context
2902 so they don't refer to the enclosing scope and explicitly
2903 indicating that they are constraint variables. */
2904 for (tree parm
= parms
; parm
; parm
= DECL_CHAIN (parm
))
2906 DECL_CONTEXT (parm
) = NULL_TREE
;
2907 CONSTRAINT_VAR_P (parm
) = true;
2910 /* Build the node. */
2911 tree r
= build_min (REQUIRES_EXPR
, boolean_type_node
, parms
, reqs
);
2912 TREE_SIDE_EFFECTS (r
) = false;
2913 TREE_CONSTANT (r
) = true;
2914 SET_EXPR_LOCATION (r
, loc
);
2918 /* Construct a requirement for the validity of EXPR. */
2921 finish_simple_requirement (location_t loc
, tree expr
)
2923 tree r
= build_nt (SIMPLE_REQ
, expr
);
2924 SET_EXPR_LOCATION (r
, loc
);
2928 /* Construct a requirement for the validity of TYPE. */
2931 finish_type_requirement (location_t loc
, tree type
)
2933 tree r
= build_nt (TYPE_REQ
, type
);
2934 SET_EXPR_LOCATION (r
, loc
);
2938 /* Construct a requirement for the validity of EXPR, along with
2939 its properties. if TYPE is non-null, then it specifies either
2940 an implicit conversion or argument deduction constraint,
2941 depending on whether any placeholders occur in the type name.
2942 NOEXCEPT_P is true iff the noexcept keyword was specified. */
2945 finish_compound_requirement (location_t loc
, tree expr
, tree type
, bool noexcept_p
)
2947 tree req
= build_nt (COMPOUND_REQ
, expr
, type
);
2948 SET_EXPR_LOCATION (req
, loc
);
2949 COMPOUND_REQ_NOEXCEPT_P (req
) = noexcept_p
;
2953 /* Finish a nested requirement. */
2956 finish_nested_requirement (location_t loc
, tree expr
)
2958 /* Currently open template headers have dummy arg vectors, so don't
2959 pass into normalization. */
2960 tree norm
= normalize_constraint_expression (expr
, NULL_TREE
, false);
2962 /* Build the constraint, saving its normalization as its type. */
2963 tree r
= build1 (NESTED_REQ
, norm
, expr
);
2964 SET_EXPR_LOCATION (r
, loc
);
2968 /* Check that FN satisfies the structural requirements of a
2969 function concept definition. */
2971 check_function_concept (tree fn
)
2973 /* Check that the function is comprised of only a return statement. */
2974 tree body
= DECL_SAVED_TREE (fn
);
2975 if (TREE_CODE (body
) == BIND_EXPR
)
2976 body
= BIND_EXPR_BODY (body
);
2978 /* Sometimes a function call results in the creation of clean up
2979 points. Allow these to be preserved in the body of the
2980 constraint, as we might actually need them for some constexpr
2982 if (TREE_CODE (body
) == CLEANUP_POINT_EXPR
)
2983 body
= TREE_OPERAND (body
, 0);
2985 /* Check that the definition is written correctly. */
2986 if (TREE_CODE (body
) != RETURN_EXPR
)
2988 location_t loc
= DECL_SOURCE_LOCATION (fn
);
2989 if (TREE_CODE (body
) == STATEMENT_LIST
&& !STATEMENT_LIST_HEAD (body
))
2992 /* The definition was probably erroneous, not empty. */;
2994 error_at (loc
, "definition of concept %qD is empty", fn
);
2997 error_at (loc
, "definition of concept %qD has multiple statements", fn
);
3004 // Check that a constrained friend declaration function declaration,
3005 // FN, is admissible. This is the case only when the declaration depends
3006 // on template parameters and does not declare a specialization.
3008 check_constrained_friend (tree fn
, tree reqs
)
3010 if (fn
== error_mark_node
)
3012 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
3014 // If there are not constraints, this cannot be an error.
3018 // Constrained friend functions that don't depend on template
3019 // arguments are effectively meaningless.
3020 if (!uses_template_parms (TREE_TYPE (fn
)))
3022 error_at (location_of (fn
),
3023 "constrained friend does not depend on template parameters");
3028 /*---------------------------------------------------------------------------
3029 Equivalence of constraints
3030 ---------------------------------------------------------------------------*/
3032 /* Returns true when A and B are equivalent constraints. */
3034 equivalent_constraints (tree a
, tree b
)
3036 gcc_assert (!a
|| TREE_CODE (a
) == CONSTRAINT_INFO
);
3037 gcc_assert (!b
|| TREE_CODE (b
) == CONSTRAINT_INFO
);
3038 return cp_tree_equal (a
, b
);
3041 /* Returns true if the template declarations A and B have equivalent
3042 constraints. This is the case when A's constraints subsume B's and
3043 when B's also constrain A's. */
3045 equivalently_constrained (tree d1
, tree d2
)
3047 gcc_assert (TREE_CODE (d1
) == TREE_CODE (d2
));
3048 return equivalent_constraints (get_constraints (d1
), get_constraints (d2
));
3051 /*---------------------------------------------------------------------------
3052 Partial ordering of constraints
3053 ---------------------------------------------------------------------------*/
3055 /* Returns true when the constraints in A subsume those in B. */
3058 subsumes_constraints (tree a
, tree b
)
3060 gcc_assert (!a
|| TREE_CODE (a
) == CONSTRAINT_INFO
);
3061 gcc_assert (!b
|| TREE_CODE (b
) == CONSTRAINT_INFO
);
3062 return subsumes (a
, b
);
3065 /* Returns true when the constraints in CI (with arguments
3066 ARGS) strictly subsume the associated constraints of TMPL. */
3069 strictly_subsumes (tree ci
, tree args
, tree tmpl
)
3071 tree n1
= get_normalized_constraints_from_info (ci
, args
, NULL_TREE
);
3072 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3074 return subsumes (n1
, n2
) && !subsumes (n2
, n1
);
3077 /* REturns true when the constraints in CI (with arguments ARGS) subsume
3078 the associated constraints of TMPL. */
3081 weakly_subsumes (tree ci
, tree args
, tree tmpl
)
3083 tree n1
= get_normalized_constraints_from_info (ci
, args
, NULL_TREE
);
3084 tree n2
= get_normalized_constraints_from_decl (tmpl
);
3086 return subsumes (n1
, n2
);
3089 /* Determines which of the declarations, A or B, is more constrained.
3090 That is, which declaration's constraints subsume but are not subsumed
3093 Returns 1 if D1 is more constrained than D2, -1 if D2 is more constrained
3094 than D1, and 0 otherwise. */
3097 more_constrained (tree d1
, tree d2
)
3099 tree n1
= get_normalized_constraints_from_decl (d1
);
3100 tree n2
= get_normalized_constraints_from_decl (d2
);
3103 if (subsumes (n1
, n2
))
3105 if (subsumes (n2
, n1
))
3110 /* Return whether D1 is at least as constrained as D2. */
3113 at_least_as_constrained (tree d1
, tree d2
)
3115 tree n1
= get_normalized_constraints_from_decl (d1
);
3116 tree n2
= get_normalized_constraints_from_decl (d2
);
3118 return subsumes (n1
, n2
);
3121 /*---------------------------------------------------------------------------
3122 Constraint diagnostics
3123 ---------------------------------------------------------------------------*/
3125 /* Returns the best location to diagnose a constraint error. */
3128 get_constraint_error_location (tree t
)
3130 if (location_t loc
= cp_expr_location (t
))
3133 /* If we have a specific location give it. */
3134 tree expr
= CONSTR_EXPR (t
);
3135 if (location_t loc
= cp_expr_location (expr
))
3138 /* If the constraint is normalized from a requires-clause, give
3139 the location as that of the constrained declaration. */
3140 tree cxt
= CONSTR_CONTEXT (t
);
3141 tree src
= cxt
? TREE_VALUE (cxt
) : NULL_TREE
;
3143 /* TODO: This only happens for constrained non-template declarations. */
3145 else if (DECL_P (src
))
3146 return DECL_SOURCE_LOCATION (src
);
3147 /* Otherwise, give the location as the defining concept. */
3148 else if (concept_check_p (src
))
3150 tree id
= unpack_concept_check (src
);
3151 tree tmpl
= TREE_OPERAND (id
, 0);
3153 tmpl
= OVL_FIRST (tmpl
);
3154 return DECL_SOURCE_LOCATION (tmpl
);
3157 return input_location
;
3160 /* Emit a diagnostic for a failed trait. */
3163 diagnose_trait_expr (tree expr
, tree map
)
3165 location_t loc
= cp_expr_location (expr
);
3166 tree args
= get_mapped_args (map
);
3168 /* Build a "fake" version of the instantiated trait, so we can
3169 get the instantiated types from result. */
3170 ++processing_template_decl
;
3171 expr
= tsubst_expr (expr
, args
, tf_none
, NULL_TREE
, false);
3172 --processing_template_decl
;
3174 tree t1
= TRAIT_EXPR_TYPE1 (expr
);
3175 tree t2
= TRAIT_EXPR_TYPE2 (expr
);
3176 switch (TRAIT_EXPR_KIND (expr
))
3178 case CPTK_HAS_NOTHROW_ASSIGN
:
3179 inform (loc
, " %qT is not %<nothrow%> copy assignable", t1
);
3181 case CPTK_HAS_NOTHROW_CONSTRUCTOR
:
3182 inform (loc
, " %qT is not %<nothrow%> default constructible", t1
);
3184 case CPTK_HAS_NOTHROW_COPY
:
3185 inform (loc
, " %qT is not %<nothrow%> copy constructible", t1
);
3187 case CPTK_HAS_TRIVIAL_ASSIGN
:
3188 inform (loc
, " %qT is not trivially copy assignable", t1
);
3190 case CPTK_HAS_TRIVIAL_CONSTRUCTOR
:
3191 inform (loc
, " %qT is not trivially default constructible", t1
);
3193 case CPTK_HAS_TRIVIAL_COPY
:
3194 inform (loc
, " %qT is not trivially copy constructible", t1
);
3196 case CPTK_HAS_TRIVIAL_DESTRUCTOR
:
3197 inform (loc
, " %qT is not trivially destructible", t1
);
3199 case CPTK_HAS_VIRTUAL_DESTRUCTOR
:
3200 inform (loc
, " %qT does not have a virtual destructor", t1
);
3202 case CPTK_IS_ABSTRACT
:
3203 inform (loc
, " %qT is not an abstract class", t1
);
3205 case CPTK_IS_BASE_OF
:
3206 inform (loc
, " %qT is not a base of %qT", t1
, t2
);
3209 inform (loc
, " %qT is not a class", t1
);
3212 inform (loc
, " %qT is not an empty class", t1
);
3215 inform (loc
, " %qT is not an enum", t1
);
3218 inform (loc
, " %qT is not a final class", t1
);
3220 case CPTK_IS_LITERAL_TYPE
:
3221 inform (loc
, " %qT is not a literal type", t1
);
3224 inform (loc
, " %qT is not a POD type", t1
);
3226 case CPTK_IS_POLYMORPHIC
:
3227 inform (loc
, " %qT is not a polymorphic type", t1
);
3229 case CPTK_IS_SAME_AS
:
3230 inform (loc
, " %qT is not the same as %qT", t1
, t2
);
3232 case CPTK_IS_STD_LAYOUT
:
3233 inform (loc
, " %qT is not an standard layout type", t1
);
3235 case CPTK_IS_TRIVIAL
:
3236 inform (loc
, " %qT is not a trivial type", t1
);
3239 inform (loc
, " %qT is not a union", t1
);
3247 diagnose_valid_expression (tree expr
, tree args
, tree in_decl
)
3249 tree result
= tsubst_expr (expr
, args
, tf_none
, in_decl
, false);
3250 if (result
!= error_mark_node
3251 && convert_to_void (result
, ICV_STATEMENT
, tf_none
) != error_mark_node
)
3254 location_t loc
= cp_expr_loc_or_input_loc (expr
);
3255 if (diagnosing_failed_constraint::replay_errors_p ())
3257 /* Replay the substitution error. */
3258 inform (loc
, "the required expression %qE is invalid, because", expr
);
3259 if (result
== error_mark_node
)
3260 tsubst_expr (expr
, args
, tf_error
, in_decl
, false);
3262 convert_to_void (result
, ICV_STATEMENT
, tf_error
);
3265 inform (loc
, "the required expression %qE is invalid", expr
);
3267 return error_mark_node
;
3271 diagnose_valid_type (tree type
, tree args
, tree in_decl
)
3273 tree result
= tsubst (type
, args
, tf_none
, in_decl
);
3274 if (result
!= error_mark_node
)
3277 location_t loc
= cp_expr_loc_or_input_loc (type
);
3278 if (diagnosing_failed_constraint::replay_errors_p ())
3280 /* Replay the substitution error. */
3281 inform (loc
, "the required type %qT is invalid, because", type
);
3282 tsubst (type
, args
, tf_error
, in_decl
);
3285 inform (loc
, "the required type %qT is invalid", type
);
3287 return error_mark_node
;
3291 diagnose_simple_requirement (tree req
, tree args
, tree in_decl
)
3293 diagnose_valid_expression (TREE_OPERAND (req
, 0), args
, in_decl
);
3297 diagnose_compound_requirement (tree req
, tree args
, tree in_decl
)
3299 tree expr
= TREE_OPERAND (req
, 0);
3300 expr
= diagnose_valid_expression (expr
, args
, in_decl
);
3301 if (expr
== error_mark_node
)
3304 location_t loc
= cp_expr_loc_or_input_loc (expr
);
3306 /* Check the noexcept condition. */
3307 if (COMPOUND_REQ_NOEXCEPT_P (req
) && !expr_noexcept_p (expr
, tf_none
))
3308 inform (loc
, "%qE is not %<noexcept%>", expr
);
3310 tree type
= TREE_OPERAND (req
, 1);
3311 type
= diagnose_valid_type (type
, args
, in_decl
);
3312 if (type
== error_mark_node
)
3317 subst_info
quiet (tf_none
, in_decl
);
3318 subst_info
noisy (tf_error
, in_decl
);
3320 /* Check the expression against the result type. */
3321 if (tree placeholder
= type_uses_auto (type
))
3323 if (!type_deducible_p (expr
, type
, placeholder
, args
, quiet
))
3325 tree orig_expr
= TREE_OPERAND (req
, 0);
3326 if (diagnosing_failed_constraint::replay_errors_p ())
3329 "%qE does not satisfy return-type-requirement, "
3330 "because", orig_expr
);
3331 /* Further explain the reason for the error. */
3332 type_deducible_p (expr
, type
, placeholder
, args
, noisy
);
3335 inform (loc
, "%qE does not satisfy return-type-requirement",
3339 else if (!expression_convertible_p (expr
, type
, quiet
))
3341 tree orig_expr
= TREE_OPERAND (req
, 0);
3342 if (diagnosing_failed_constraint::replay_errors_p ())
3344 inform (loc
, "cannot convert %qE to %qT because", orig_expr
, type
);
3345 /* Further explain the reason for the error. */
3346 expression_convertible_p (expr
, type
, noisy
);
3349 inform (loc
, "cannot convert %qE to %qT", orig_expr
, type
);
3355 diagnose_type_requirement (tree req
, tree args
, tree in_decl
)
3357 tree type
= TREE_OPERAND (req
, 0);
3358 diagnose_valid_type (type
, args
, in_decl
);
3362 diagnose_nested_requirement (tree req
, tree args
)
3364 /* Quietly check for satisfaction first. We can elaborate details
3366 tree norm
= TREE_TYPE (req
);
3367 subst_info
info (tf_none
, NULL_TREE
);
3368 tree result
= satisfy_constraint (norm
, args
, info
);
3369 if (result
== boolean_true_node
)
3372 tree expr
= TREE_OPERAND (req
, 0);
3373 location_t loc
= cp_expr_location (expr
);
3374 if (diagnosing_failed_constraint::replay_errors_p ())
3376 /* Replay the substitution error. */
3377 inform (loc
, "nested requirement %qE is not satisfied, because", expr
);
3378 subst_info
noisy (tf_warning_or_error
, NULL_TREE
);
3379 satisfy_constraint_expression (expr
, args
, noisy
);
3382 inform (loc
, "nested requirement %qE is not satisfied", expr
);
3387 diagnose_requirement (tree req
, tree args
, tree in_decl
)
3389 iloc_sentinel
loc_s (cp_expr_location (req
));
3390 switch (TREE_CODE (req
))
3393 return diagnose_simple_requirement (req
, args
, in_decl
);
3395 return diagnose_compound_requirement (req
, args
, in_decl
);
3397 return diagnose_type_requirement (req
, args
, in_decl
);
3399 return diagnose_nested_requirement (req
, args
);
3406 diagnose_requires_expr (tree expr
, tree map
, tree in_decl
)
3408 local_specialization_stack
stack (lss_copy
);
3409 tree parms
= TREE_OPERAND (expr
, 0);
3410 tree body
= TREE_OPERAND (expr
, 1);
3411 tree args
= get_mapped_args (map
);
3414 subst_info
info (tf_warning_or_error
, NULL_TREE
);
3415 tree vars
= tsubst_constraint_variables (parms
, args
, info
);
3416 if (vars
== error_mark_node
)
3422 tree req
= TREE_VALUE (p
);
3423 diagnose_requirement (req
, args
, in_decl
);
3428 /* Diagnose a substitution failure in the atomic constraint T when applied
3429 with the instantiated parameter mapping MAP. */
3432 diagnose_atomic_constraint (tree t
, tree map
, tree result
, subst_info info
)
3434 /* If the constraint is already ill-formed, we've previously diagnosed
3435 the reason. We should still say why the constraints aren't satisfied. */
3436 if (t
== error_mark_node
)
3440 loc
= DECL_SOURCE_LOCATION (info
.in_decl
);
3442 loc
= input_location
;
3443 inform (loc
, "invalid constraints");
3447 location_t loc
= get_constraint_error_location (t
);
3448 iloc_sentinel
loc_s (loc
);
3450 /* Generate better diagnostics for certain kinds of expressions. */
3451 tree expr
= ATOMIC_CONSTR_EXPR (t
);
3452 STRIP_ANY_LOCATION_WRAPPER (expr
);
3453 switch (TREE_CODE (expr
))
3456 diagnose_trait_expr (expr
, map
);
3459 diagnose_requires_expr (expr
, map
, info
.in_decl
);
3462 tree a
= copy_node (t
);
3463 ATOMIC_CONSTR_MAP (a
) = map
;
3464 if (!same_type_p (TREE_TYPE (result
), boolean_type_node
))
3465 error_at (loc
, "constraint %qE has type %qT, not %<bool%>",
3466 a
, TREE_TYPE (result
));
3468 inform (loc
, "the expression %qE evaluated to %<false%>", a
);
3473 GTY(()) tree current_failed_constraint
;
3475 diagnosing_failed_constraint::
3476 diagnosing_failed_constraint (tree t
, tree args
, bool diag
)
3477 : diagnosing_error (diag
)
3479 if (diagnosing_error
)
3481 current_failed_constraint
3482 = tree_cons (args
, t
, current_failed_constraint
);
3483 ++current_constraint_diagnosis_depth
;
3487 diagnosing_failed_constraint::
3488 ~diagnosing_failed_constraint ()
3490 if (diagnosing_error
)
3492 --current_constraint_diagnosis_depth
;
3493 if (current_failed_constraint
)
3494 current_failed_constraint
= TREE_CHAIN (current_failed_constraint
);
3499 /* Whether we are allowed to replay an error that underlies a constraint failure
3500 at the current diagnosis depth. */
3503 diagnosing_failed_constraint::replay_errors_p ()
3505 if (current_constraint_diagnosis_depth
>= concepts_diagnostics_max_depth
)
3507 concepts_diagnostics_max_depth_exceeded_p
= true;
3514 /* Emit diagnostics detailing the failure ARGS to satisfy the constraints
3515 of T. Here, T can be either a constraint or a declaration. */
3518 diagnose_constraints (location_t loc
, tree t
, tree args
)
3520 inform (loc
, "constraints not satisfied");
3522 if (concepts_diagnostics_max_depth
== 0)
3525 /* Replay satisfaction, but diagnose errors. */
3527 constraint_satisfaction_value (t
, tf_warning_or_error
);
3529 constraint_satisfaction_value (t
, args
, tf_warning_or_error
);
3531 static bool suggested_p
;
3532 if (concepts_diagnostics_max_depth_exceeded_p
3533 && current_constraint_diagnosis_depth
== 0
3536 inform (UNKNOWN_LOCATION
,
3537 "set %qs to at least %d for more detail",
3538 "-fconcepts-diagnostics-depth=",
3539 concepts_diagnostics_max_depth
+ 1);
3544 #include "gt-cp-constraint.h"