/* Processing rules for constraints.
- Copyright (C) 2013-2021 Free Software Foundation, Inc.
+ Copyright (C) 2013-2024 Free Software Foundation, Inc.
Contributed by Andrew Sutton (andrew.n.sutton@gmail.com)
This file is part of GCC.
/* Provides additional context for satisfaction.
- The flag noisy() controls whether to diagnose ill-formed satisfaction,
- such as the satisfaction value of an atom being non-bool or non-constant.
-
- The flag diagnose_unsatisfaction_p() controls whether to explain why
- a constraint is not satisfied.
-
- The entrypoints to satisfaction for which we set noisy+unsat are
- diagnose_constraints and diagnose_nested_requirement. The entrypoint for
- which we set noisy-unsat is the replay inside constraint_satisfaction_value.
- From constraints_satisfied_p, we enter satisfaction quietly (both flags
- cleared). */
+ During satisfaction:
+ - The flag noisy() controls whether to diagnose ill-formed satisfaction,
+ such as the satisfaction value of an atom being non-bool or non-constant.
+ - The flag diagnose_unsatisfaction_p() controls whether to additionally
+ explain why a constraint is not satisfied.
+ - We enter satisfaction with noisy+unsat from diagnose_constraints.
+ - We enter satisfaction with noisy-unsat from the replay inside
+ constraint_satisfaction_value.
+ - We enter satisfaction quietly (both flags cleared) from
+ constraints_satisfied_p.
+
+ During evaluation of a requires-expression:
+ - The flag noisy() controls whether to diagnose ill-formed types and
+ expressions inside its requirements.
+ - The flag diagnose_unsatisfaction_p() controls whether to additionally
+ explain why the requires-expression evaluates to false.
+ - We enter tsubst_requires_expr with noisy+unsat from
+ diagnose_atomic_constraint and potentially from
+ satisfy_nondeclaration_constraints.
+ - We enter tsubst_requires_expr with noisy-unsat from
+ cp_parser_requires_expression when processing a requires-expression that
+ appears outside a template.
+ - We enter tsubst_requires_expr quietly (both flags cleared) when
+ substituting through a requires-expression as part of template
+ instantiation. */
struct sat_info : subst_info
{
return error_mark_node;
if (!check_constraint_operands (loc, lhs, rhs))
return error_mark_node;
- tree overload;
- cp_expr expr = build_x_binary_op (loc, code,
- lhs, TREE_CODE (lhs),
- rhs, TREE_CODE (rhs),
- &overload, tf_none);
- /* When either operand is dependent, the overload set may be non-empty. */
- if (expr == error_mark_node)
- return error_mark_node;
- expr.set_location (loc);
+ cp_expr expr
+ = build_min_nt_loc (loc, code, lhs.get_value (), rhs.get_value ());
expr.set_range (lhs.get_start (), rhs.get_finish ());
return expr;
}
return rhs;
if (!rhs)
return lhs;
- return finish_constraint_and_expr (input_location, lhs, rhs);
+ /* Use UNKNOWN_LOCATION so write_template_args can tell the difference
+ between this and a && the user wrote. */
+ return finish_constraint_and_expr (UNKNOWN_LOCATION, lhs, rhs);
}
/* Extract the template-id from a concept check. For standard and variable
return tmpl;
}
-/* Returns true if any of the arguments in the template argument list is
- a wildcard or wildcard pack. */
-
-bool
-contains_wildcard_p (tree args)
-{
- for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
- {
- tree arg = TREE_VEC_ELT (args, i);
- if (TREE_CODE (arg) == WILDCARD_DECL)
- return true;
- }
- return false;
-}
-
/*---------------------------------------------------------------------------
Resolution of qualified concept names
---------------------------------------------------------------------------*/
/* Remember the candidate if we can deduce a substitution. */
++processing_template_decl;
tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
- if (tree subst = coerce_template_parms (parms, args, tmpl))
+ if (tree subst = coerce_template_parms (parms, args, tmpl, tf_none))
{
if (subst == error_mark_node)
++nerrs;
tree args = TREE_OPERAND (id, 1);
tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
++processing_template_decl;
- tree result = coerce_template_parms (parms, args, tmpl);
+ tree result = coerce_template_parms (parms, args, tmpl, tf_none);
--processing_template_decl;
if (result == error_mark_node)
return error_mark_node;
/* Build a constrained placeholder type where SPEC is a type-constraint.
SPEC can be anything were concept_definition_p is true.
- If DECLTYPE_P is true, then the placeholder is decltype(auto).
-
Returns a pair whose FIRST is the concept being checked and whose
SECOND is the prototype parameter. */
return build2 (c, ci, t0, t1);
}
+/* Data types and hash functions for caching the normal form of a concept-id.
+ This essentially memoizes calls to normalize_concept_check. */
+
+struct GTY((for_user)) norm_entry
+{
+ /* The CONCEPT_DECL of the concept-id. */
+ tree tmpl;
+ /* The arguments of the concept-id. */
+ tree args;
+ /* The normal form of the concept-id. */
+ tree norm;
+};
+
+struct norm_hasher : ggc_ptr_hash<norm_entry>
+{
+ static hashval_t hash (norm_entry *e)
+ {
+ ++comparing_specializations;
+ hashval_t val = iterative_hash_template_arg (e->tmpl, 0);
+ val = iterative_hash_template_arg (e->args, val);
+ --comparing_specializations;
+ return val;
+ }
+
+ static bool equal (norm_entry *e1, norm_entry *e2)
+ {
+ ++comparing_specializations;
+ bool eq = e1->tmpl == e2->tmpl
+ && template_args_equal (e1->args, e2->args);
+ --comparing_specializations;
+ return eq;
+ }
+};
+
+static GTY((deletable)) hash_table<norm_hasher> *norm_cache;
+
+/* Normalize the concept check CHECK where ARGS are the
+ arguments to be substituted into CHECK's arguments. */
+
static tree
normalize_concept_check (tree check, tree args, norm_info info)
{
targs = tsubst_template_args (targs, args, info.complain, info.in_decl);
if (targs == error_mark_node)
return error_mark_node;
+ if (template_args_equal (targs, generic_targs_for (tmpl)))
+ /* Canonicalize generic arguments as NULL_TREE, as an optimization. */
+ targs = NULL_TREE;
/* Build the substitution for the concept definition. */
tree parms = TREE_VALUE (DECL_TEMPLATE_PARMS (tmpl));
- /* Turn on template processing; coercing non-type template arguments
- will automatically assume they're non-dependent. */
- ++processing_template_decl;
- tree subst = coerce_template_parms (parms, targs, tmpl);
- --processing_template_decl;
- if (subst == error_mark_node)
+ if (targs && args)
+ /* As an optimization, coerce the arguments only if necessary
+ (i.e. if they were substituted). */
+ targs = coerce_template_parms (parms, targs, tmpl, tf_none);
+ if (targs == error_mark_node)
return error_mark_node;
- /* The concept may have been ill-formed. */
- tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
- if (def == error_mark_node)
- return error_mark_node;
+ if (!norm_cache)
+ norm_cache = hash_table<norm_hasher>::create_ggc (31);
+ norm_entry *entry = nullptr;
+ if (!info.generate_diagnostics ())
+ {
+ /* Cache the normal form of the substituted concept-id (when not
+ diagnosing). */
+ norm_entry elt = {tmpl, targs, NULL_TREE};
+ norm_entry **slot = norm_cache->find_slot (&elt, INSERT);
+ if (*slot)
+ return (*slot)->norm;
+ entry = ggc_alloc<norm_entry> ();
+ *entry = elt;
+ *slot = entry;
+ }
+ tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
info.update_context (check, args);
- return normalize_expression (def, subst, info);
+ tree norm = normalize_expression (def, targs, info);
+ if (entry)
+ entry->norm = norm;
+ return norm;
}
/* Used by normalize_atom to cache ATOMIC_CONSTRs. */
tree ci = build_tree_list (t, info.context);
tree atom = build1 (ATOMIC_CONSTR, ci, map);
+
+ /* Remember whether the expression of this atomic constraint belongs to
+ a concept definition by inspecting in_decl, which should always be set
+ in this case either by norm_info::update_context (when recursing into a
+ concept-id during normalization) or by normalize_concept_definition
+ (when starting out with a concept-id). */
+ if (info.in_decl && concept_definition_p (info.in_decl))
+ ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (atom) = true;
+
if (!info.generate_diagnostics ())
{
/* Cache the ATOMIC_CONSTRs that we return, so that sat_hasher::equal
it has the correct template information attached. */
d = strip_inheriting_ctors (d);
+ if (regenerated_lambda_fn_p (d))
+ {
+ /* If this lambda was regenerated, DECL_TEMPLATE_PARMS doesn't contain
+ all in-scope template parameters, but the lambda from which it was
+ ultimately regenerated does, so use that instead. */
+ tree lambda = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (d));
+ lambda = most_general_lambda (lambda);
+ d = lambda_function (lambda);
+ }
+
if (TREE_CODE (d) == TEMPLATE_DECL)
{
tmpl = d;
tmpl = most_general_template (tmpl);
}
+ d = tmpl ? tmpl : decl;
+
/* If we're not diagnosing errors, use cached constraints, if any. */
if (!diag)
- if (tree *p = hash_map_safe_get (normalized_map, tmpl))
+ if (tree *p = hash_map_safe_get (normalized_map, d))
return *p;
tree norm = NULL_TREE;
- if (tree ci = get_constraints (decl))
+ if (tree ci = get_constraints (d))
{
- push_nested_class_guard pncs (DECL_CONTEXT (d));
-
- temp_override<tree> ovr (current_function_decl);
- if (TREE_CODE (decl) == FUNCTION_DECL)
- current_function_decl = decl;
-
+ push_access_scope_guard pas (decl);
norm = get_normalized_constraints_from_info (ci, tmpl, diag);
}
if (!diag)
- hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm);
+ hash_map_safe_put<hm_ggc> (normalized_map, d, norm);
return norm;
}
/* Returns the normal form of TMPL's definition. */
static tree
-normalize_concept_definition (tree tmpl, bool diag = false)
+normalize_concept_definition (tree tmpl, bool diag)
{
+ if (!norm_cache)
+ norm_cache = hash_table<norm_hasher>::create_ggc (31);
+ norm_entry entry = {tmpl, NULL_TREE, NULL_TREE};
+
if (!diag)
- if (tree *p = hash_map_safe_get (normalized_map, tmpl))
- return *p;
+ if (norm_entry *found = norm_cache->find (&entry))
+ return found->norm;
- gcc_assert (concept_definition_p (tmpl));
- if (OVL_P (tmpl))
- tmpl = OVL_FIRST (tmpl);
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
tree def = get_concept_definition (DECL_TEMPLATE_RESULT (tmpl));
++processing_template_decl;
--processing_template_decl;
if (!diag)
- hash_map_safe_put<hm_ggc> (normalized_map, tmpl, norm);
+ {
+ norm_entry **slot = norm_cache->find_slot (&entry, INSERT);
+ entry.norm = norm;
+ *slot = ggc_alloc<norm_entry> ();
+ **slot = entry;
+ }
return norm;
}
for declaration matching. */
tree
-maybe_substitute_reqs_for (tree reqs, const_tree decl_)
+maybe_substitute_reqs_for (tree reqs, const_tree decl)
{
if (reqs == NULL_TREE)
return NULL_TREE;
- tree decl = CONST_CAST_TREE (decl_);
- tree result = STRIP_TEMPLATE (decl);
-
- if (DECL_UNIQUE_FRIEND_P (result))
+ decl = STRIP_TEMPLATE (decl);
+ if (DECL_UNIQUE_FRIEND_P (decl) && DECL_TEMPLATE_INFO (decl))
{
- tree tmpl = decl;
- if (TREE_CODE (decl) != TEMPLATE_DECL)
- tmpl = DECL_TI_TEMPLATE (result);
-
- tree gargs = generic_targs_for (tmpl);
+ tree tmpl = DECL_TI_TEMPLATE (decl);
+ tree outer_args = outer_template_args (decl);
processing_template_decl_sentinel s;
- if (uses_template_parms (gargs))
+ if (PRIMARY_TEMPLATE_P (tmpl)
+ || uses_template_parms (outer_args))
++processing_template_decl;
- reqs = tsubst_constraint (reqs, gargs,
+ reqs = tsubst_constraint (reqs, outer_args,
tf_warning_or_error, NULL_TREE);
}
return reqs;
}
-/* Returns the template-head requires clause for the template
- declaration T or NULL_TREE if none. */
-
-tree
-get_template_head_requirements (tree t)
-{
- tree ci = get_constraints (t);
- if (!ci)
- return NULL_TREE;
- return CI_TEMPLATE_REQS (ci);
-}
-
/* Returns the trailing requires clause of the declarator of
a template declaration T or NULL_TREE if none. */
{
gcc_assert (standard_concept_p (tmpl));
gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
+ if (TREE_DEPRECATED (DECL_TEMPLATE_RESULT (tmpl)))
+ warn_deprecated_use (DECL_TEMPLATE_RESULT (tmpl), NULL_TREE);
tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
args = coerce_template_parms (parms, args, tmpl, complain);
if (args == error_mark_node)
check = ovl_make (tmpl);
check = build_concept_check (check, arg, args, tf_warning_or_error);
- /* Make the check a fold-expression if needed. */
+ /* Make the check a fold-expression if needed.
+ Use UNKNOWN_LOCATION so write_template_args can tell the
+ difference between this and a fold the user wrote. */
if (apply_to_each_p && declared_pack_p)
- check = finish_left_unary_fold_expr (check, TRUTH_ANDIF_EXPR);
+ check = finish_left_unary_fold_expr (UNKNOWN_LOCATION,
+ check, TRUTH_ANDIF_EXPR);
return check;
}
return val;
}
-/* Substitute through the simple requirement. */
+/* Substitute through the expression of a simple requirement or
+ compound requirement. */
static tree
-tsubst_valid_expression_requirement (tree t, tree args, subst_info info)
+tsubst_valid_expression_requirement (tree t, tree args, sat_info info)
{
- tree r = tsubst_expr (t, args, info.complain, info.in_decl, false);
- if (convert_to_void (r, ICV_STATEMENT, info.complain) == error_mark_node)
- return error_mark_node;
- return r;
+ tree r = tsubst_expr (t, args, tf_none, info.in_decl);
+ if (convert_to_void (r, ICV_STATEMENT, tf_none) != error_mark_node)
+ return r;
+
+ if (info.diagnose_unsatisfaction_p ())
+ {
+ location_t loc = cp_expr_loc_or_input_loc (t);
+ if (diagnosing_failed_constraint::replay_errors_p ())
+ {
+ inform (loc, "the required expression %qE is invalid, because", t);
+ if (r == error_mark_node)
+ tsubst_expr (t, args, info.complain, info.in_decl);
+ else
+ convert_to_void (r, ICV_STATEMENT, info.complain);
+ }
+ else
+ inform (loc, "the required expression %qE is invalid", t);
+ }
+ else if (info.noisy ())
+ {
+ r = tsubst_expr (t, args, info.complain, info.in_decl);
+ convert_to_void (r, ICV_STATEMENT, info.complain);
+ }
+
+ return error_mark_node;
}
/* Substitute through the simple requirement. */
static tree
-tsubst_simple_requirement (tree t, tree args, subst_info info)
+tsubst_simple_requirement (tree t, tree args, sat_info info)
{
tree t0 = TREE_OPERAND (t, 0);
tree expr = tsubst_valid_expression_requirement (t0, args, info);
return boolean_true_node;
}
+/* Subroutine of tsubst_type_requirement that performs the actual substitution
+ and diagnosing. Also used by tsubst_compound_requirement. */
+
+static tree
+tsubst_type_requirement_1 (tree t, tree args, sat_info info, location_t loc)
+{
+ tree r = tsubst (t, args, tf_none, info.in_decl);
+ if (r != error_mark_node)
+ return r;
+
+ if (info.diagnose_unsatisfaction_p ())
+ {
+ if (diagnosing_failed_constraint::replay_errors_p ())
+ {
+ /* Replay the substitution error. */
+ inform (loc, "the required type %qT is invalid, because", t);
+ tsubst (t, args, info.complain, info.in_decl);
+ }
+ else
+ inform (loc, "the required type %qT is invalid", t);
+ }
+ else if (info.noisy ())
+ tsubst (t, args, info.complain, info.in_decl);
+
+ return error_mark_node;
+}
+
+
/* Substitute through the type requirement. */
static tree
-tsubst_type_requirement (tree t, tree args, subst_info info)
+tsubst_type_requirement (tree t, tree args, sat_info info)
{
tree t0 = TREE_OPERAND (t, 0);
- tree type = tsubst (t0, args, info.complain, info.in_decl);
+ tree type = tsubst_type_requirement_1 (t0, args, info, EXPR_LOCATION (t));
if (type == error_mark_node)
return error_mark_node;
return boolean_true_node;
references are preserved in the result. */
expr = force_paren_expr_uneval (expr);
- /* When args is NULL, we're evaluating a non-templated requires expression,
- but even those are parsed under processing_template_decl == 1, and so the
- placeholder 'auto' inside this return-type-requirement has level 2. In
- order to have all parms and arguments match up for satisfaction, we need
- to pass an empty level of OUTER_TARGS in this case. */
- if (!args)
- args = make_tree_vec (0);
-
tree deduced_type = do_auto_deduction (type, expr, placeholder,
info.complain, adc_requirement,
/*outer_targs=*/args);
/* Substitute through the compound requirement. */
static tree
-tsubst_compound_requirement (tree t, tree args, subst_info info)
+tsubst_compound_requirement (tree t, tree args, sat_info info)
{
tree t0 = TREE_OPERAND (t, 0);
tree t1 = TREE_OPERAND (t, 1);
if (expr == error_mark_node)
return error_mark_node;
+ location_t loc = cp_expr_loc_or_input_loc (expr);
+
/* Check the noexcept condition. */
bool noexcept_p = COMPOUND_REQ_NOEXCEPT_P (t);
if (noexcept_p && !expr_noexcept_p (expr, tf_none))
- return error_mark_node;
+ {
+ if (info.diagnose_unsatisfaction_p ())
+ inform (loc, "%qE is not %<noexcept%>", expr);
+ else
+ return error_mark_node;
+ }
/* Substitute through the type expression, if any. */
- tree type = tsubst (t1, args, info.complain, info.in_decl);
+ tree type = tsubst_type_requirement_1 (t1, args, info, EXPR_LOCATION (t));
if (type == error_mark_node)
return error_mark_node;
if (tree placeholder = type_uses_auto (type))
{
if (!type_deducible_p (expr, type, placeholder, args, quiet))
- return error_mark_node;
+ {
+ if (info.diagnose_unsatisfaction_p ())
+ {
+ if (diagnosing_failed_constraint::replay_errors_p ())
+ {
+ inform (loc,
+ "%qE does not satisfy return-type-requirement, "
+ "because", t0);
+ /* Further explain the reason for the error. */
+ type_deducible_p (expr, type, placeholder, args, info);
+ }
+ else
+ inform (loc,
+ "%qE does not satisfy return-type-requirement", t0);
+ }
+ return error_mark_node;
+ }
}
else if (!expression_convertible_p (expr, type, quiet))
- return error_mark_node;
+ {
+ if (info.diagnose_unsatisfaction_p ())
+ {
+ if (diagnosing_failed_constraint::replay_errors_p ())
+ {
+ inform (loc, "cannot convert %qE to %qT because", t0, type);
+ /* Further explain the reason for the error. */
+ expression_convertible_p (expr, type, info);
+ }
+ else
+ inform (loc, "cannot convert %qE to %qT", t0, type);
+ }
+ return error_mark_node;
+ }
}
return boolean_true_node;
}
+/* Substitute through the nested requirement. */
+
static tree
-tsubst_nested_requirement (tree t, tree args, subst_info info)
+tsubst_nested_requirement (tree t, tree args, sat_info info)
{
sat_info quiet (tf_none, info.in_decl);
tree result = constraint_satisfaction_value (t, args, quiet);
- if (result != boolean_true_node)
- return error_mark_node;
- return boolean_true_node;
+ if (result == boolean_true_node)
+ return boolean_true_node;
+
+ if (result == boolean_false_node
+ && info.diagnose_unsatisfaction_p ())
+ {
+ tree expr = TREE_OPERAND (t, 0);
+ location_t loc = cp_expr_location (t);
+ if (diagnosing_failed_constraint::replay_errors_p ())
+ {
+ /* Replay the substitution error. */
+ inform (loc, "nested requirement %qE is not satisfied, because", expr);
+ constraint_satisfaction_value (t, args, info);
+ }
+ else
+ inform (loc, "nested requirement %qE is not satisfied", expr);
+ }
+
+ return error_mark_node;
}
/* Substitute ARGS into the requirement T. */
static tree
-tsubst_requirement (tree t, tree args, subst_info info)
+tsubst_requirement (tree t, tree args, sat_info info)
{
iloc_sentinel loc_s (cp_expr_location (t));
switch (TREE_CODE (t))
in its requirements ... In such cases, the expression evaluates
to false; it does not cause the program to be ill-formed.
- However, there are cases where substitution must produce a
- new requires-expression, that is not a template constraint.
- For example:
+ When substituting through a REQUIRES_EXPR as part of template
+ instantiation, we call this routine with info.quiet() true.
- template<typename T>
- class X {
- template<typename U>
- static constexpr bool var = requires (U u) { T::fn(u); };
- };
+ When evaluating a REQUIRES_EXPR that appears outside a template in
+ cp_parser_requires_expression, we call this routine with
+ info.noisy() true.
- In the instantiation of X<Y> (assuming Y defines fn), then the
- instantiated requires-expression would include Y::fn(u). If any
- substitution in the requires-expression fails, we can immediately
- fold the expression to false, as would be the case e.g., when
- instantiation X<int>. */
+ Finally, when diagnosing unsatisfaction from diagnose_atomic_constraint
+ and when diagnosing a false REQUIRES_EXPR via diagnose_constraints,
+ we call this routine with info.diagnose_unsatisfaction_p() true. */
-tree
-tsubst_requires_expr (tree t, tree args,
- tsubst_flags_t complain, tree in_decl)
+static tree
+tsubst_requires_expr (tree t, tree args, sat_info info)
{
local_specialization_stack stack (lss_copy);
- subst_info info (complain, in_decl);
+ /* We need to check access during the substitution. */
+ deferring_access_check_sentinel acs (dk_no_deferred);
/* A requires-expression is an unevaluated context. */
cp_unevaluated u;
- args = add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t), args);
+ args = add_extra_args (REQUIRES_EXPR_EXTRA_ARGS (t), args,
+ info.complain, info.in_decl);
if (processing_template_decl)
{
/* We're partially instantiating a generic lambda. Substituting into
checked out of order, so instead just remember the template
arguments and wait until we can substitute them all at once. */
t = copy_node (t);
- REQUIRES_EXPR_EXTRA_ARGS (t) = build_extra_args (t, args, complain);
+ REQUIRES_EXPR_EXTRA_ARGS (t) = build_extra_args (t, args, info.complain);
return t;
}
return boolean_false_node;
}
+ tree result = boolean_true_node;
for (tree reqs = REQUIRES_EXPR_REQS (t); reqs; reqs = TREE_CHAIN (reqs))
{
tree req = TREE_VALUE (reqs);
- tree result = tsubst_requirement (req, args, info);
- if (result == error_mark_node)
- return boolean_false_node;
+ if (tsubst_requirement (req, args, info) == error_mark_node)
+ {
+ result = boolean_false_node;
+ if (info.diagnose_unsatisfaction_p ())
+ /* Keep going so that we diagnose all failed requirements. */;
+ else
+ break;
+ }
}
- return boolean_true_node;
+ return result;
+}
+
+/* Public wrapper for the above. */
+
+tree
+tsubst_requires_expr (tree t, tree args,
+ tsubst_flags_t complain, tree in_decl)
+{
+ sat_info info (complain, in_decl);
+ return tsubst_requires_expr (t, args, info);
}
/* Substitute ARGS into the constraint information CI, producing a new
if (TREE_CODE (new_arg) == TYPE_ARGUMENT_PACK)
{
tree pack_args = ARGUMENT_PACK_ARGS (new_arg);
- for (int i = 0; i < TREE_VEC_LENGTH (pack_args); i++)
- {
- tree& pack_arg = TREE_VEC_ELT (pack_args, i);
- if (TYPE_P (pack_arg))
- pack_arg = canonicalize_type_argument (pack_arg, complain);
- }
+ for (tree& pack_arg : tree_vec_range (pack_args))
+ if (TYPE_P (pack_arg))
+ pack_arg = canonicalize_type_argument (pack_arg, complain);
}
if (new_arg == error_mark_node)
return error_mark_node;
{
static hashval_t hash (sat_entry *e)
{
+ auto cso = make_temp_override (comparing_specializations);
+ ++comparing_specializations;
+
if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e->atom))
{
/* Atoms with instantiated mappings are built during satisfaction.
static bool equal (sat_entry *e1, sat_entry *e2)
{
+ auto cso = make_temp_override (comparing_specializations);
+ ++comparing_specializations;
+
if (ATOMIC_CONSTR_MAP_INSTANTIATED_P (e1->atom)
!= ATOMIC_CONSTR_MAP_INSTANTIATED_P (e2->atom))
return false;
*slot = entry;
}
else
- /* We shouldn't get here, but if we do, let's just leave 'entry'
- empty, effectively disabling the cache. */
- return;
+ {
+ /* We're evaluating this atom for the first time, and doing so noisily.
+ This shouldn't happen outside of error recovery situations involving
+ unstable satisfaction. Let's just leave 'entry' empty, effectively
+ disabling the cache, and remove the empty slot. */
+ gcc_checking_assert (seen_error ());
+ /* Appease hash_table::check_complete_insertion. */
+ *slot = ggc_alloc<sat_entry> ();
+ sat_cache->clear_slot (slot);
+ }
}
/* Returns the cached satisfaction result if we have one and we're not
if (entry->evaluating)
{
/* If we get here, it means satisfaction is self-recursive. */
- gcc_checking_assert (!entry->result);
+ gcc_checking_assert (!entry->result || seen_error ());
if (info.noisy ())
error_at (EXPR_LOCATION (ATOMIC_CONSTR_EXPR (entry->atom)),
"satisfaction of atomic constraint %qE depends on itself",
/* We also don't want to evaluate concept-checks when substituting the
constraint-expressions of a declaration. */
processing_constraint_expression_sentinel s;
- tree expr = tsubst_expr (t, args, complain, in_decl, false);
+ cp_unevaluated u;
+ tree expr = tsubst_expr (t, args, complain, in_decl);
return expr;
}
return t;
gcc_assert (TREE_CODE (t) == INTEGER_CST
- && same_type_p (TREE_TYPE (t), boolean_type_node));
+ && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (t),
+ boolean_type_node));
if (integer_zerop (t))
return boolean_false_node;
else
return boolean_true_node;
}
-/* Build a new template argument list with template arguments corresponding
- to the parameters used in an atomic constraint. */
+/* Build a new template argument vector corresponding to the parameter
+ mapping of the atomic constraint T, using arguments from ARGS. */
-tree
-get_mapped_args (tree map)
+static tree
+get_mapped_args (tree t, tree args)
{
+ tree map = ATOMIC_CONSTR_MAP (t);
+
/* No map, no arguments. */
if (!map)
return NULL_TREE;
- /* Find the mapped parameter with the highest level. */
- int count = 0;
- for (tree p = map; p; p = TREE_CHAIN (p))
- {
- int level;
- int index;
- template_parm_level_and_index (TREE_VALUE (p), &level, &index);
- if (level > count)
- count = level;
- }
+ /* Determine the depth of the resulting argument vector. */
+ int depth;
+ if (ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (t))
+ /* The expression of this atomic constraint comes from a concept definition,
+ whose template depth is always one, so the resulting argument vector
+ will also have depth one. */
+ depth = 1;
+ else
+ /* Otherwise, the expression of this atomic constraint comes from
+ the context of the constrained entity, whose template depth is that
+ of ARGS. */
+ depth = TMPL_ARGS_DEPTH (args);
/* Place each argument at its corresponding position in the argument
list. Note that the list will be sparse (not all arguments supplied),
but instantiation is guaranteed to only use the parameters in the
mapping, so null arguments would never be used. */
- auto_vec< vec<tree> > lists (count);
- lists.quick_grow_cleared (count);
+ auto_vec< vec<tree> > lists (depth);
+ lists.quick_grow_cleared (depth);
for (tree p = map; p; p = TREE_CHAIN (p))
{
int level;
/* Insert the argument into its corresponding position. */
vec<tree> &list = lists[level - 1];
if (index >= (int)list.length ())
- list.safe_grow_cleared (index + 1, true);
+ list.safe_grow_cleared (index + 1, /*exact=*/false);
list[index] = TREE_PURPOSE (p);
}
/* Build the new argument list. */
- tree args = make_tree_vec (lists.length ());
+ args = make_tree_vec (lists.length ());
for (unsigned i = 0; i != lists.length (); ++i)
{
vec<tree> &list = lists[i];
}
SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (args, 0);
+ if (TMPL_ARGS_HAVE_MULTIPLE_LEVELS (args)
+ && TMPL_ARGS_DEPTH (args) == 1)
+ {
+ /* Get rid of the redundant outer TREE_VEC. */
+ tree level = TMPL_ARGS_LEVEL (args, 1);
+ ggc_free (args);
+ args = level;
+ }
+
return args;
}
-static void diagnose_atomic_constraint (tree, tree, tree, subst_info);
+static void diagnose_atomic_constraint (tree, tree, tree, sat_info);
/* Compute the satisfaction of an atomic constraint. */
}
/* Rebuild the argument vector from the parameter mapping. */
- args = get_mapped_args (map);
+ args = get_mapped_args (t, args);
/* Apply the parameter mapping (i.e., just substitute). */
tree expr = ATOMIC_CONSTR_EXPR (t);
- tree result = tsubst_expr (expr, args, quiet.complain, quiet.in_decl, false);
+ tree result = tsubst_expr (expr, args, quiet.complain, quiet.in_decl);
if (result == error_mark_node)
{
/* If substitution results in an invalid type or expression, the constraint
is not satisfied. Replay the substitution. */
if (info.diagnose_unsatisfaction_p ())
- tsubst_expr (expr, args, info.complain, info.in_decl, false);
+ tsubst_expr (expr, args, info.complain, info.in_decl);
return cache.save (inst_cache.save (boolean_false_node));
}
if (!same_type_p (TREE_TYPE (result), boolean_type_node))
{
if (info.noisy ())
- diagnose_atomic_constraint (t, map, result, info);
+ diagnose_atomic_constraint (t, args, result, info);
return cache.save (inst_cache.save (error_mark_node));
}
/* Compute the value of the constraint. */
if (info.noisy ())
- result = cxx_constant_value (result);
+ {
+ iloc_sentinel ils (EXPR_LOCATION (result));
+ result = cxx_constant_value (result);
+ }
else
{
- result = maybe_constant_value (result, NULL_TREE,
- /*manifestly_const_eval=*/true);
+ result = maybe_constant_value (result, NULL_TREE, mce_true);
if (!TREE_CONSTANT (result))
result = error_mark_node;
}
result = satisfaction_value (result);
if (result == boolean_false_node && info.diagnose_unsatisfaction_p ())
- diagnose_atomic_constraint (t, map, result, info);
+ diagnose_atomic_constraint (t, args, result, info);
return cache.save (inst_cache.save (result));
}
/* We need to check access during satisfaction. */
deferring_access_check_sentinel acs (dk_no_deferred);
+ /* Constraints are unevaluated operands. */
+ cp_unevaluated u;
+
return satisfy_constraint_r (t, args, info);
}
scope for this placeholder type; use them as the initial template
parameters for normalization. */
tree initial_parms = TREE_PURPOSE (ci);
+
/* The 'auto' itself is used as the first argument in its own constraints,
and its level is one greater than its template depth. So in order to
capture all used template parameters, we need to add an extra level of
/* Handle REQUIRES_EXPR directly, bypassing satisfaction. */
if (TREE_CODE (t) == REQUIRES_EXPR)
{
- /* TODO: Remove this assert and the special casing of REQUIRES_EXPRs
- from diagnose_constraints once we merge tsubst_requires_expr and
- diagnose_requires_expr. */
- gcc_assert (!info.diagnose_unsatisfaction_p ());
auto ovr = make_temp_override (current_constraint_diagnosis_depth);
if (info.noisy ())
++current_constraint_diagnosis_depth;
- return tsubst_requires_expr (t, args, info.complain, info.in_decl);
+ return tsubst_requires_expr (t, args, info);
}
/* Get the normalized constraints. */
args = TI_ARGS (ti);
if (inh_ctor_targs)
args = add_outermost_template_args (args, inh_ctor_targs);
-
- /* If any arguments depend on template parameters, we can't
- check constraints. Pretend they're satisfied for now. */
- if (uses_template_parms (args))
- return boolean_true_node;
}
+ if (regenerated_lambda_fn_p (t))
+ {
+ /* The TI_ARGS of a regenerated lambda contains only the innermost
+ set of template arguments. Augment this with the outer template
+ arguments that were used to regenerate the lambda. */
+ gcc_assert (!args || TMPL_ARGS_DEPTH (args) == 1);
+ tree regen_args = lambda_regenerating_args (t);
+ if (args)
+ args = add_to_template_args (regen_args, args);
+ else
+ args = regen_args;
+ }
+
+ /* If the innermost arguments are dependent, or if the outer arguments
+ are dependent and are needed by the constraints, we can't check
+ satisfaction yet so pretend they're satisfied for now. */
+ if (uses_template_parms (args)
+ && ((DECL_TEMPLATE_INFO (t)
+ && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (t))
+ && (TMPL_ARGS_DEPTH (args) == 1
+ || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args))))
+ || uses_outer_template_parms_in_constraints (t)))
+ return boolean_true_node;
+
/* Get the normalized constraints. */
tree norm = get_normalized_constraints_from_decl (t, info.noisy ());
{
if (!push_tinst_level (t))
return result;
+ push_to_top_level ();
push_access_scope (t);
result = satisfy_normalized_constraints (norm, args, info);
pop_access_scope (t);
+ pop_from_top_level ();
pop_tinst_level ();
}
gcc_assert (TREE_CODE (t) == TEMPLATE_DECL);
- args = add_outermost_template_args (t, args);
-
- /* If any arguments depend on template parameters, we can't
- check constraints. Pretend they're satisfied for now. */
- if (uses_template_parms (args))
+ if (regenerated_lambda_fn_p (t))
+ {
+ /* As in the two-parameter version of this function. */
+ gcc_assert (TMPL_ARGS_DEPTH (args) == 1);
+ tree lambda = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (t));
+ tree outer_args = TI_ARGS (LAMBDA_EXPR_REGEN_INFO (lambda));
+ args = add_to_template_args (outer_args, args);
+ }
+ else
+ args = add_outermost_template_args (t, args);
+
+ /* If the innermost arguments are dependent, or if the outer arguments
+ are dependent and are needed by the constraints, we can't check
+ satisfaction yet so pretend they're satisfied for now. */
+ if (uses_template_parms (args)
+ && (TMPL_ARGS_DEPTH (args) == 1
+ || uses_template_parms (INNERMOST_TEMPLATE_ARGS (args))
+ || uses_outer_template_parms_in_constraints (t)))
return boolean_true_node;
tree result = boolean_true_node;
if (!push_tinst_level (t, args))
return result;
tree pattern = DECL_TEMPLATE_RESULT (t);
+ push_to_top_level ();
push_access_scope (pattern);
result = satisfy_normalized_constraints (norm, args, info);
pop_access_scope (pattern);
+ pop_from_top_level ();
pop_tinst_level ();
}
else
r = satisfy_nondeclaration_constraints (t, args, info);
if (r == error_mark_node && info.quiet ()
- && !(DECL_P (t) && TREE_NO_WARNING (t)))
+ && !(DECL_P (t) && warning_suppressed_p (t)))
{
/* Replay the error noisily. */
sat_info noisy (tf_warning_or_error, info.in_decl);
constraint_satisfaction_value (t, args, noisy);
if (DECL_P (t) && !args)
/* Avoid giving these errors again. */
- TREE_NO_WARNING (t) = true;
+ suppress_warning (t);
}
return r;
}
}
/* Evaluate the requires-expression T, returning either boolean_true_node
- or boolean_false_node. This is used during gimplification and constexpr
+ or boolean_false_node. This is used during folding and constexpr
evaluation. */
tree
return NULL_TREE;
}
-
-// Check that a constrained friend declaration function declaration,
-// FN, is admissible. This is the case only when the declaration depends
-// on template parameters and does not declare a specialization.
-void
-check_constrained_friend (tree fn, tree reqs)
-{
- if (fn == error_mark_node)
- return;
- gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
-
- // If there are not constraints, this cannot be an error.
- if (!reqs)
- return;
-
- // Constrained friend functions that don't depend on template
- // arguments are effectively meaningless.
- if (!uses_template_parms (TREE_TYPE (fn)))
- {
- error_at (location_of (fn),
- "constrained friend does not depend on template parameters");
- return;
- }
-}
-
/*---------------------------------------------------------------------------
Equivalence of constraints
---------------------------------------------------------------------------*/
Partial ordering of constraints
---------------------------------------------------------------------------*/
-/* Returns true when the constraints in A subsume those in B. */
-
-bool
-subsumes_constraints (tree a, tree b)
-{
- gcc_assert (!a || TREE_CODE (a) == CONSTRAINT_INFO);
- gcc_assert (!b || TREE_CODE (b) == CONSTRAINT_INFO);
- return subsumes (a, b);
-}
-
/* Returns true when the constraints in CI strictly subsume
the associated constraints of TMPL. */
/* Emit a diagnostic for a failed trait. */
-void
-diagnose_trait_expr (tree expr, tree map)
+static void
+diagnose_trait_expr (tree expr, tree args)
{
location_t loc = cp_expr_location (expr);
- tree args = get_mapped_args (map);
/* Build a "fake" version of the instantiated trait, so we can
get the instantiated types from result. */
++processing_template_decl;
- expr = tsubst_expr (expr, args, tf_none, NULL_TREE, false);
+ expr = tsubst_expr (expr, args, tf_none, NULL_TREE);
--processing_template_decl;
tree t1 = TRAIT_EXPR_TYPE1 (expr);
tree t2 = TRAIT_EXPR_TYPE2 (expr);
+ if (t2 && TREE_CODE (t2) == TREE_VEC)
+ {
+ /* Convert the TREE_VEC of arguments into a TREE_LIST, since we can't
+ directly print a TREE_VEC but we can a TREE_LIST via the E format
+ specifier. */
+ tree list = NULL_TREE;
+ for (tree t : tree_vec_range (t2))
+ list = tree_cons (NULL_TREE, t, list);
+ t2 = nreverse (list);
+ }
switch (TRAIT_EXPR_KIND (expr))
{
case CPTK_HAS_NOTHROW_ASSIGN:
- inform (loc, " %qT is not %<nothrow%> copy assignable", t1);
+ inform (loc, " %qT is not nothrow copy assignable", t1);
break;
case CPTK_HAS_NOTHROW_CONSTRUCTOR:
- inform (loc, " %qT is not %<nothrow%> default constructible", t1);
+ inform (loc, " %qT is not nothrow default constructible", t1);
break;
case CPTK_HAS_NOTHROW_COPY:
- inform (loc, " %qT is not %<nothrow%> copy constructible", t1);
+ inform (loc, " %qT is not nothrow copy constructible", t1);
break;
case CPTK_HAS_TRIVIAL_ASSIGN:
inform (loc, " %qT is not trivially copy assignable", t1);
case CPTK_HAS_TRIVIAL_DESTRUCTOR:
inform (loc, " %qT is not trivially destructible", t1);
break;
+ case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
+ inform (loc, " %qT does not have unique object representations", t1);
+ break;
case CPTK_HAS_VIRTUAL_DESTRUCTOR:
inform (loc, " %qT does not have a virtual destructor", t1);
break;
case CPTK_IS_ABSTRACT:
inform (loc, " %qT is not an abstract class", t1);
break;
+ case CPTK_IS_AGGREGATE:
+ inform (loc, " %qT is not an aggregate", t1);
+ break;
+ case CPTK_IS_ARRAY:
+ inform (loc, " %qT is not an array", t1);
+ break;
+ case CPTK_IS_ASSIGNABLE:
+ inform (loc, " %qT is not assignable from %qT", t1, t2);
+ break;
case CPTK_IS_BASE_OF:
inform (loc, " %qT is not a base of %qT", t1, t2);
break;
+ case CPTK_IS_BOUNDED_ARRAY:
+ inform (loc, " %qT is not a bounded array", t1);
+ break;
case CPTK_IS_CLASS:
inform (loc, " %qT is not a class", t1);
break;
+ case CPTK_IS_CONSTRUCTIBLE:
+ if (!t2)
+ inform (loc, " %qT is not default constructible", t1);
+ else
+ inform (loc, " %qT is not constructible from %qE", t1, t2);
+ break;
+ case CPTK_IS_CONVERTIBLE:
+ inform (loc, " %qT is not convertible from %qE", t2, t1);
+ break;
case CPTK_IS_EMPTY:
inform (loc, " %qT is not an empty class", t1);
break;
case CPTK_IS_FINAL:
inform (loc, " %qT is not a final class", t1);
break;
+ case CPTK_IS_FUNCTION:
+ inform (loc, " %qT is not a function", t1);
+ break;
+ case CPTK_IS_LAYOUT_COMPATIBLE:
+ inform (loc, " %qT is not layout compatible with %qT", t1, t2);
+ break;
case CPTK_IS_LITERAL_TYPE:
inform (loc, " %qT is not a literal type", t1);
break;
+ case CPTK_IS_MEMBER_FUNCTION_POINTER:
+ inform (loc, " %qT is not a member function pointer", t1);
+ break;
+ case CPTK_IS_MEMBER_OBJECT_POINTER:
+ inform (loc, " %qT is not a member object pointer", t1);
+ break;
+ case CPTK_IS_MEMBER_POINTER:
+ inform (loc, " %qT is not a member pointer", t1);
+ break;
+ case CPTK_IS_NOTHROW_ASSIGNABLE:
+ inform (loc, " %qT is not nothrow assignable from %qT", t1, t2);
+ break;
+ case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
+ if (!t2)
+ inform (loc, " %qT is not nothrow default constructible", t1);
+ else
+ inform (loc, " %qT is not nothrow constructible from %qE", t1, t2);
+ break;
+ case CPTK_IS_NOTHROW_CONVERTIBLE:
+ inform (loc, " %qT is not nothrow convertible from %qE", t2, t1);
+ break;
+ case CPTK_IS_OBJECT:
+ inform (loc, " %qT is not an object type", t1);
+ break;
+ case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
+ inform (loc, " %qT is not pointer-interconvertible base of %qT",
+ t1, t2);
+ break;
case CPTK_IS_POD:
inform (loc, " %qT is not a POD type", t1);
break;
case CPTK_IS_POLYMORPHIC:
inform (loc, " %qT is not a polymorphic type", t1);
break;
- case CPTK_IS_SAME_AS:
+ case CPTK_IS_REFERENCE:
+ inform (loc, " %qT is not a reference", t1);
+ break;
+ case CPTK_IS_SAME:
inform (loc, " %qT is not the same as %qT", t1, t2);
break;
+ case CPTK_IS_SCOPED_ENUM:
+ inform (loc, " %qT is not a scoped enum", t1);
+ break;
case CPTK_IS_STD_LAYOUT:
inform (loc, " %qT is not an standard layout type", t1);
break;
case CPTK_IS_TRIVIAL:
inform (loc, " %qT is not a trivial type", t1);
break;
+ case CPTK_IS_TRIVIALLY_ASSIGNABLE:
+ inform (loc, " %qT is not trivially assignable from %qT", t1, t2);
+ break;
+ case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
+ if (!t2)
+ inform (loc, " %qT is not trivially default constructible", t1);
+ else
+ inform (loc, " %qT is not trivially constructible from %qE", t1, t2);
+ break;
+ case CPTK_IS_TRIVIALLY_COPYABLE:
+ inform (loc, " %qT is not trivially copyable", t1);
+ break;
case CPTK_IS_UNION:
inform (loc, " %qT is not a union", t1);
break;
- default:
+ case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY:
+ inform (loc, " %qT is not a reference that binds to a temporary "
+ "object of type %qT (direct-initialization)", t1, t2);
+ break;
+ case CPTK_REF_CONVERTS_FROM_TEMPORARY:
+ inform (loc, " %qT is not a reference that binds to a temporary "
+ "object of type %qT (copy-initialization)", t1, t2);
+ break;
+ case CPTK_IS_DEDUCIBLE:
+ inform (loc, " %qD is not deducible from %qT", t1, t2);
+ break;
+#define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
+ case CPTK_##CODE:
+#include "cp-trait.def"
+#undef DEFTRAIT_TYPE
+ /* Type-yielding traits aren't expressions. */
gcc_unreachable ();
+ /* We deliberately omit the default case so that when adding a new
+ trait we'll get reminded (by way of a warning) to handle it here. */
}
}
-static tree
-diagnose_valid_expression (tree expr, tree args, tree in_decl)
-{
- tree result = tsubst_expr (expr, args, tf_none, in_decl, false);
- if (result != error_mark_node
- && convert_to_void (result, ICV_STATEMENT, tf_none) != error_mark_node)
- return result;
-
- location_t loc = cp_expr_loc_or_input_loc (expr);
- if (diagnosing_failed_constraint::replay_errors_p ())
- {
- /* Replay the substitution error. */
- inform (loc, "the required expression %qE is invalid, because", expr);
- if (result == error_mark_node)
- tsubst_expr (expr, args, tf_error, in_decl, false);
- else
- convert_to_void (result, ICV_STATEMENT, tf_error);
- }
- else
- inform (loc, "the required expression %qE is invalid", expr);
-
- return error_mark_node;
-}
-
-static tree
-diagnose_valid_type (tree type, tree args, tree in_decl)
-{
- tree result = tsubst (type, args, tf_none, in_decl);
- if (result != error_mark_node)
- return result;
-
- location_t loc = cp_expr_loc_or_input_loc (type);
- if (diagnosing_failed_constraint::replay_errors_p ())
- {
- /* Replay the substitution error. */
- inform (loc, "the required type %qT is invalid, because", type);
- tsubst (type, args, tf_error, in_decl);
- }
- else
- inform (loc, "the required type %qT is invalid", type);
-
- return error_mark_node;
-}
+/* Diagnose a substitution failure in the atomic constraint T using ARGS. */
static void
-diagnose_simple_requirement (tree req, tree args, tree in_decl)
-{
- diagnose_valid_expression (TREE_OPERAND (req, 0), args, in_decl);
-}
-
-static void
-diagnose_compound_requirement (tree req, tree args, tree in_decl)
-{
- tree expr = TREE_OPERAND (req, 0);
- expr = diagnose_valid_expression (expr, args, in_decl);
- if (expr == error_mark_node)
- return;
-
- location_t loc = cp_expr_loc_or_input_loc (expr);
-
- /* Check the noexcept condition. */
- if (COMPOUND_REQ_NOEXCEPT_P (req) && !expr_noexcept_p (expr, tf_none))
- inform (loc, "%qE is not %<noexcept%>", expr);
-
- tree type = TREE_OPERAND (req, 1);
- type = diagnose_valid_type (type, args, in_decl);
- if (type == error_mark_node)
- return;
-
- if (type)
- {
- subst_info quiet (tf_none, in_decl);
- subst_info noisy (tf_error, in_decl);
-
- /* Check the expression against the result type. */
- if (tree placeholder = type_uses_auto (type))
- {
- if (!type_deducible_p (expr, type, placeholder, args, quiet))
- {
- tree orig_expr = TREE_OPERAND (req, 0);
- if (diagnosing_failed_constraint::replay_errors_p ())
- {
- inform (loc,
- "%qE does not satisfy return-type-requirement, "
- "because", orig_expr);
- /* Further explain the reason for the error. */
- type_deducible_p (expr, type, placeholder, args, noisy);
- }
- else
- inform (loc, "%qE does not satisfy return-type-requirement",
- orig_expr);
- }
- }
- else if (!expression_convertible_p (expr, type, quiet))
- {
- tree orig_expr = TREE_OPERAND (req, 0);
- if (diagnosing_failed_constraint::replay_errors_p ())
- {
- inform (loc, "cannot convert %qE to %qT because", orig_expr, type);
- /* Further explain the reason for the error. */
- expression_convertible_p (expr, type, noisy);
- }
- else
- inform (loc, "cannot convert %qE to %qT", orig_expr, type);
- }
- }
-}
-
-static void
-diagnose_type_requirement (tree req, tree args, tree in_decl)
-{
- tree type = TREE_OPERAND (req, 0);
- diagnose_valid_type (type, args, in_decl);
-}
-
-static void
-diagnose_nested_requirement (tree req, tree args)
-{
- /* Quietly check for satisfaction first. */
- sat_info quiet (tf_none, NULL_TREE);
- tree result = satisfy_nondeclaration_constraints (req, args, quiet);
- if (result == boolean_true_node)
- return;
-
- tree expr = TREE_OPERAND (req, 0);
- location_t loc = cp_expr_location (expr);
- if (diagnosing_failed_constraint::replay_errors_p ())
- {
- /* Replay the substitution error with re-normalized requirements. */
- inform (loc, "nested requirement %qE is not satisfied, because", expr);
-
- sat_info noisy (tf_warning_or_error, NULL_TREE, /*diag_unsat=*/true);
- satisfy_nondeclaration_constraints (req, args, noisy);
- }
- else
- inform (loc, "nested requirement %qE is not satisfied", expr);
-
-}
-
-static void
-diagnose_requirement (tree req, tree args, tree in_decl)
-{
- iloc_sentinel loc_s (cp_expr_location (req));
- switch (TREE_CODE (req))
- {
- case SIMPLE_REQ:
- return diagnose_simple_requirement (req, args, in_decl);
- case COMPOUND_REQ:
- return diagnose_compound_requirement (req, args, in_decl);
- case TYPE_REQ:
- return diagnose_type_requirement (req, args, in_decl);
- case NESTED_REQ:
- return diagnose_nested_requirement (req, args);
- default:
- gcc_unreachable ();
- }
-}
-
-static void
-diagnose_requires_expr (tree expr, tree map, tree in_decl)
-{
- local_specialization_stack stack (lss_copy);
- tree parms = TREE_OPERAND (expr, 0);
- tree body = TREE_OPERAND (expr, 1);
- tree args = get_mapped_args (map);
-
- cp_unevaluated u;
- subst_info info (tf_warning_or_error, NULL_TREE);
- tree vars = tsubst_constraint_variables (parms, args, info);
- if (vars == error_mark_node)
- return;
-
- tree p = body;
- while (p)
- {
- tree req = TREE_VALUE (p);
- diagnose_requirement (req, args, in_decl);
- p = TREE_CHAIN (p);
- }
-}
-
-/* Diagnose a substitution failure in the atomic constraint T when applied
- with the instantiated parameter mapping MAP. */
-
-static void
-diagnose_atomic_constraint (tree t, tree map, tree result, subst_info info)
+diagnose_atomic_constraint (tree t, tree args, tree result, sat_info info)
{
/* If the constraint is already ill-formed, we've previously diagnosed
the reason. We should still say why the constraints aren't satisfied. */
switch (TREE_CODE (expr))
{
case TRAIT_EXPR:
- diagnose_trait_expr (expr, map);
+ diagnose_trait_expr (expr, args);
break;
case REQUIRES_EXPR:
- diagnose_requires_expr (expr, map, info.in_decl);
+ gcc_checking_assert (info.diagnose_unsatisfaction_p ());
+ /* Clear in_decl before replaying the substitution to avoid emitting
+ seemingly unhelpful "in declaration ..." notes that follow some
+ substitution failure error messages. */
+ info.in_decl = NULL_TREE;
+ tsubst_requires_expr (expr, args, info);
break;
default:
if (!same_type_p (TREE_TYPE (result), boolean_type_node))
/* Replay satisfaction, but diagnose unsatisfaction. */
sat_info noisy (tf_warning_or_error, NULL_TREE, /*diag_unsat=*/true);
- if (TREE_CODE (t) == REQUIRES_EXPR)
- {
- gcc_assert (!args);
- ++current_constraint_diagnosis_depth;
- diagnose_requires_expr (t, /*map=*/NULL_TREE, /*in_decl=*/NULL_TREE);
- --current_constraint_diagnosis_depth;
- }
- else
- constraint_satisfaction_value (t, args, noisy);
+ constraint_satisfaction_value (t, args, noisy);
static bool suggested_p;
if (concepts_diagnostics_max_depth_exceeded_p
projects / thirdparty / gcc.git / blobdiff