Bootstrapped/regtested on x86_64-pc-linux-gnu. Comments?
-- >8 --
This patch removes vestigial Concepts TS code as discussed in
<https://gcc.gnu.org/pipermail/gcc-patches/2024-July/657937.html>.
In particular, it removes code related to function/variable concepts.
That includes variable_concept_p and function_concept_p, which then
cascades into removing DECL_DECLARED_CONCEPT_P etc. So I think we
no longer need to say "standard concept" since there are no non-standard
ones anymore.
I've added two new errors saying that "variable/function concepts are
no longer supported".
gcc/cp/ChangeLog:
* constexpr.cc (cxx_eval_constant_expression): Don't call
unpack_concept_check. Add a concept_check_p assert. Remove
function_concept_p code.
* constraint.cc (check_constraint_atom): Remove function concepts code.
(unpack_concept_check): Remove.
(get_concept_check_template): Remove Concepts TS code.
(resolve_function_concept_overload): Remove.
(resolve_function_concept_check): Remove.
(resolve_concept_check): Remove Concepts TS code.
(get_returned_expression): Remove.
(get_variable_initializer): Remove.
(get_concept_definition): Remove Concepts TS code.
(normalize_concept_check): Likewise.
(build_function_check): Remove.
(build_variable_check): Remove.
(build_standard_check): Use concept_definition_p instead of
standard_concept_p.
(build_concept_check): Remove variable_concept_p/function_concept_p
code.
(build_concept_id): Simplify.
(build_type_constraint): Likewise.
(placeholder_extract_concept_and_args): Likewise.
(satisfy_nondeclaration_constraints): Likewise.
(check_function_concept): Remove.
(get_constraint_error_location): Remove Concepts TS code.
* cp-tree.h (DECL_DECLARED_CONCEPT_P): Remove.
(check_function_concept): Remove.
(unpack_concept_check): Remove.
(standard_concept_p): Remove.
(variable_concept_p): Remove.
(function_concept_p): Remove.
(concept_definition_p): Simplify.
(concept_check_p): Don't check for CALL_EXPR.
* decl.cc (check_concept_refinement): Remove.
(duplicate_decls): Remove check_concept_refinement code.
(is_concept_var): Remove.
(cp_finish_decl): Remove is_concept_var.
(check_concept_fn): Remove.
(grokfndecl): Give an error about function concepts not being supported
anymore. Remove unused code.
(grokvardecl): Give an error about variable concepts not being
supported anymore.
(finish_function): Remove DECL_DECLARED_CONCEPT_P code.
* decl2.cc (min_vis_expr_r): Use concept_definition_p instead of
standard_concept_p.
(maybe_instantiate_decl): Remove DECL_DECLARED_CONCEPT_P check.
(mark_used): Likewise.
* error.cc (dump_simple_decl): Use concept_definition_p instead of
standard_concept_p.
(dump_function_decl): Remove DECL_DECLARED_CONCEPT_P code.
(print_concept_check_info): Don't call unpack_concept_check.
* mangle.cc (write_type_constraint): Likewise.
* parser.cc (cp_parser_nested_name_specifier_opt): Remove
function_concept_p code. Only check concept_definition_p, not
variable_concept_p/standard_concept_p.
(add_debug_begin_stmt): Remove DECL_DECLARED_CONCEPT_P code.
(cp_parser_template_declaration_after_parameters): Remove a stale
comment.
* pt.cc (check_explicit_specialization): Remove
DECL_DECLARED_CONCEPT_P code.
(process_partial_specialization): Remove variable_concept_p code.
(lookup_template_variable): Likewise.
(tsubst_expr) <case CALL_EXPR>: Remove Concepts TS code and simplify.
(do_decl_instantiation): Remove DECL_DECLARED_CONCEPT_P code.
(instantiate_decl): Likewise.
(placeholder_type_constraint_dependent_p): Don't call
unpack_concept_check. Add a concept_check_p assert.
(convert_generic_types_to_packs): Likewise.
* semantics.cc (finish_call_expr): Remove Concepts TS code and simplify.
gcc/testsuite/ChangeLog:
* g++.dg/concepts/decl-diagnose.C: Adjust dg-error.
* g++.dg/concepts/fn-concept2.C: Likewise.
* g++.dg/concepts/pr71128.C: Likewise.
* g++.dg/concepts/var-concept6.C: Likewise.
* g++.dg/cpp2a/concepts.C: Likewise.
---
gcc/cp/constexpr.cc | 13 +-
gcc/cp/constraint.cc | 346 +-----------------
gcc/cp/cp-tree.h | 71 +---
gcc/cp/decl.cc | 118 +-----
gcc/cp/decl2.cc | 4 +-
gcc/cp/error.cc | 10 +-
gcc/cp/mangle.cc | 4 +-
gcc/cp/parser.cc | 16 +-
gcc/cp/pt.cc | 60 +--
gcc/cp/semantics.cc | 17 +-
gcc/testsuite/g++.dg/concepts/decl-diagnose.C | 8 +-
gcc/testsuite/g++.dg/concepts/fn-concept2.C | 4 +-
gcc/testsuite/g++.dg/concepts/pr71128.C | 8 +-
gcc/testsuite/g++.dg/concepts/var-concept6.C | 2 +-
gcc/testsuite/g++.dg/cpp2a/concepts.C | 4 +-
15 files changed, 65 insertions(+), 620 deletions(-)
diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
index 8277b3b79ba..b079be1b3d5 100644
--- a/gcc/cp/constexpr.cc
+++ b/gcc/cp/constexpr.cc
@@ -8508,20 +8508,11 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx,
tree t,
{
/* We can evaluate template-id that refers to a concept only if
the template arguments are non-dependent. */
- tree id = unpack_concept_check (t);
- tree tmpl = TREE_OPERAND (id, 0);
+ gcc_assert (concept_check_p (t));
+ tree tmpl = TREE_OPERAND (t, 0);
if (!concept_definition_p (tmpl))
internal_error ("unexpected template-id %qE", t);
- if (function_concept_p (tmpl))
- {
- if (!ctx->quiet)
- error_at (cp_expr_loc_or_input_loc (t),
- "function concept must be called");
- r = error_mark_node;
- break;
- }
-
if (!value_dependent_expression_p (t)
&& !uid_sensitive_constexpr_evaluation_p ())
r = evaluate_concept_check (t);
diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
index 853ea8c4b93..2da482cc93d 100644
--- a/gcc/cp/constraint.cc
+++ b/gcc/cp/constraint.cc
@@ -167,19 +167,6 @@ check_constraint_atom (cp_expr expr)
return false;
}
- /* Check that we're using function concepts correctly. */
- if (concept_check_p (expr))
- {
- tree id = unpack_concept_check (expr);
- tree tmpl = TREE_OPERAND (id, 0);
- if (OVL_P (tmpl) && TREE_CODE (expr) == TEMPLATE_ID_EXPR)
- {
- error_at (EXPR_LOC_OR_LOC (expr, input_location),
- "function concept must be called");
- return false;
- }
- }
-
return true;
}
@@ -245,32 +232,13 @@ combine_constraint_expressions (tree lhs, tree rhs)
return finish_constraint_and_expr (UNKNOWN_LOCATION, lhs, rhs);
}
-/* Extract the template-id from a concept check. For standard and variable
- checks, this is simply T. For function concept checks, this is the
- called function. */
-
-tree
-unpack_concept_check (tree t)
-{
- gcc_assert (concept_check_p (t));
-
- if (TREE_CODE (t) == CALL_EXPR)
- t = CALL_EXPR_FN (t);
-
- gcc_assert (TREE_CODE (t) == TEMPLATE_ID_EXPR);
- return t;
-}
-
/* Extract the TEMPLATE_DECL from a concept check. */
tree
get_concept_check_template (tree t)
{
- tree id = unpack_concept_check (t);
- tree tmpl = TREE_OPERAND (id, 0);
- if (OVL_P (tmpl))
- tmpl = OVL_FIRST (tmpl);
- return tmpl;
+ gcc_assert (concept_check_p (t));
+ return TREE_OPERAND (t, 0);
}
/*---------------------------------------------------------------------------
@@ -285,101 +253,6 @@ get_concept_check_template (tree t)
matched declaration, and whose purpose contains the coerced template
arguments that can be substituted into the call. */
-/* Given an overload set OVL, try to find a unique definition that can be
- instantiated by the template arguments ARGS.
-
- This function is not called for arbitrary call expressions. In particular,
- the call expression must be written with explicit template arguments
- and no function arguments. For example:
-
- f<T, U>()
-
- If a single match is found, this returns a TREE_LIST whose VALUE
- is the constraint function (not the template), and its PURPOSE is
- the complete set of arguments substituted into the parameter list. */
-
-static tree
-resolve_function_concept_overload (tree ovl, tree args)
-{
- int nerrs = 0;
- tree cands = NULL_TREE;
- for (lkp_iterator iter (ovl); iter; ++iter)
- {
- tree tmpl = *iter;
- if (TREE_CODE (tmpl) != TEMPLATE_DECL)
- continue;
-
- /* Don't try to deduce checks for non-concepts. We often end up trying
- to resolve constraints in functional casts as part of a
- postfix-expression. We can save time and headaches by not
- instantiating those declarations.
-
- NOTE: This masks a potential error, caused by instantiating
- non-deduced contexts using placeholder arguments. */
- tree fn = DECL_TEMPLATE_RESULT (tmpl);
- if (DECL_ARGUMENTS (fn))
- continue;
- if (!DECL_DECLARED_CONCEPT_P (fn))
- continue;
-
- /* 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, tf_none))
- {
- if (subst == error_mark_node)
- ++nerrs;
- else
- cands = tree_cons (subst, fn, cands);
- }
- --processing_template_decl;
- }
-
- if (!cands)
- /* We either had no candidates or failed deductions. */
- return nerrs ? error_mark_node : NULL_TREE;
- else if (TREE_CHAIN (cands))
- /* There are multiple candidates. */
- return error_mark_node;
-
- return cands;
-}
-
-/* Determine if the call expression CALL is a constraint check, and
- return the concept declaration and arguments being checked. If CALL
- does not denote a constraint check, return NULL. */
-
-tree
-resolve_function_concept_check (tree call)
-{
- gcc_assert (TREE_CODE (call) == CALL_EXPR);
-
- /* A constraint check must be only a template-id expression.
- If it's a call to a base-link, its function(s) should be a
- template-id expression. If this is not a template-id, then
- it cannot be a concept-check. */
- tree target = CALL_EXPR_FN (call);
- if (BASELINK_P (target))
- target = BASELINK_FUNCTIONS (target);
- if (TREE_CODE (target) != TEMPLATE_ID_EXPR)
- return NULL_TREE;
-
- /* Get the overload set and template arguments and try to
- resolve the target. */
- tree ovl = TREE_OPERAND (target, 0);
-
- /* This is a function call of a variable concept... ill-formed. */
- if (TREE_CODE (ovl) == TEMPLATE_DECL)
- {
- error_at (location_of (call),
- "function call of variable concept %qE", call);
- return error_mark_node;
- }
-
- tree args = TREE_OPERAND (target, 1);
- return resolve_function_concept_overload (ovl, args);
-}
-
/* Returns a pair containing the checked concept and its associated
prototype parameter. The result is a TREE_LIST whose TREE_VALUE
is the concept (non-template) and whose TREE_PURPOSE contains
@@ -390,20 +263,8 @@ tree
resolve_concept_check (tree check)
{
gcc_assert (concept_check_p (check));
- tree id = unpack_concept_check (check);
- tree tmpl = TREE_OPERAND (id, 0);
-
- /* If this is an overloaded function concept, perform overload
- resolution (this only happens when deducing prototype parameters
- and template introductions). */
- if (TREE_CODE (tmpl) == OVERLOAD)
- {
- if (OVL_CHAIN (tmpl))
- return resolve_function_concept_check (check);
- tmpl = OVL_FIRST (tmpl);
- }
-
- tree args = TREE_OPERAND (id, 1);
+ tree tmpl = TREE_OPERAND (check, 0);
+ tree args = TREE_OPERAND (check, 1);
tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
++processing_template_decl;
tree result = coerce_template_parms (parms, args, tmpl, tf_none);
@@ -466,55 +327,13 @@ finish_type_constraints (tree spec, tree args,
tsubst_flags_t complain)
Expansion of concept definitions
---------------------------------------------------------------------------*/
-/* Returns the expression of a function concept. */
-
-static tree
-get_returned_expression (tree fn)
-{
- /* Extract the body of the function minus the return expression. */
- tree body = DECL_SAVED_TREE (fn);
- if (!body)
- return error_mark_node;
- if (TREE_CODE (body) == BIND_EXPR)
- body = BIND_EXPR_BODY (body);
- if (TREE_CODE (body) != RETURN_EXPR)
- return error_mark_node;
-
- return TREE_OPERAND (body, 0);
-}
-
-/* Returns the initializer of a variable concept. */
-
-static tree
-get_variable_initializer (tree var)
-{
- tree init = DECL_INITIAL (var);
- if (!init)
- return error_mark_node;
- if (BRACE_ENCLOSED_INITIALIZER_P (init)
- && CONSTRUCTOR_NELTS (init) == 1)
- init = CONSTRUCTOR_ELT (init, 0)->value;
- return init;
-}
-
-/* Returns the definition of a variable or function concept. */
+/* Returns the definition of a concept. */
static tree
get_concept_definition (tree decl)
{
- if (TREE_CODE (decl) == OVERLOAD)
- decl = OVL_FIRST (decl);
-
- if (TREE_CODE (decl) == TEMPLATE_DECL)
- decl = DECL_TEMPLATE_RESULT (decl);
-
- if (TREE_CODE (decl) == CONCEPT_DECL)
- return DECL_INITIAL (decl);
- if (VAR_P (decl))
- return get_variable_initializer (decl);
- if (TREE_CODE (decl) == FUNCTION_DECL)
- return get_returned_expression (decl);
- gcc_unreachable ();
+ gcc_assert (TREE_CODE (decl) == CONCEPT_DECL);
+ return DECL_INITIAL (decl);
}
/*---------------------------------------------------------------------------
@@ -729,19 +548,9 @@ static GTY((deletable)) hash_table<norm_hasher>
*norm_cache;
static tree
normalize_concept_check (tree check, tree args, norm_info info)
{
- tree id = unpack_concept_check (check);
- tree tmpl = TREE_OPERAND (id, 0);
- tree targs = TREE_OPERAND (id, 1);
-
- /* A function concept is wrapped in an overload. */
- if (TREE_CODE (tmpl) == OVERLOAD)
- {
- /* TODO: Can we diagnose this error during parsing? */
- if (TREE_CODE (check) == TEMPLATE_ID_EXPR)
- error_at (EXPR_LOC_OR_LOC (check, input_location),
- "function concept must be called");
- tmpl = OVL_FIRST (tmpl);
- }
+ gcc_assert (concept_check_p (check));
+ tree tmpl = TREE_OPERAND (check, 0);
+ tree targs = TREE_OPERAND (check, 1);
/* Substitute through the arguments of the concept check. */
if (args)
@@ -789,11 +598,7 @@ normalize_concept_check (tree check, tree args, norm_info
info)
static GTY((deletable)) hash_table<atom_hasher> *atom_cache;
-/* The normal form of an atom depends on the expression. The normal
- form of a function call to a function concept is a check constraint
- for that concept. The normal form of a reference to a variable
- concept is a check constraint for that concept. Otherwise, the
- constraint is a predicate constraint. */
+/* The normal form of an atom is a predicate constraint. */
static tree
normalize_atom (tree t, tree args, norm_info info)
@@ -1378,77 +1183,13 @@ build_concept_check_arguments (tree arg, tree rest)
return args;
}
-/* Builds an id-expression of the form `C<Args...>()` where C is a function
- concept. */
-
-static tree
-build_function_check (tree tmpl, tree args, tsubst_flags_t /*complain*/)
-{
- if (TREE_CODE (tmpl) == TEMPLATE_DECL)
- {
- /* If we just got a template, wrap it in an overload so it looks like any
- other template-id. */
- tmpl = ovl_make (tmpl);
- TREE_TYPE (tmpl) = boolean_type_node;
- }
-
- /* Perform function concept resolution now so we always have a single
- function of the overload set (even if we started with only one; the
- resolution function converts template arguments). Note that we still
- wrap this in an overload set so we don't upset other parts of the
- compiler that expect template-ids referring to function concepts
- to have an overload set. */
- tree info = resolve_function_concept_overload (tmpl, args);
- if (info == error_mark_node)
- return error_mark_node;
- if (!info)
- {
- error ("no matching concepts for %qE", tmpl);
- return error_mark_node;
- }
- args = TREE_PURPOSE (info);
- tmpl = DECL_TI_TEMPLATE (TREE_VALUE (info));
-
- /* Rebuild the singleton overload set; mark the type bool. */
- tmpl = ovl_make (tmpl, NULL_TREE);
- TREE_TYPE (tmpl) = boolean_type_node;
-
- /* Build the id-expression around the overload set. */
- tree id = build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
-
- /* Finally, build the call expression around the overload. */
- ++processing_template_decl;
- vec<tree, va_gc> *fargs = make_tree_vector ();
- tree call = build_min_nt_call_vec (id, fargs);
- TREE_TYPE (call) = boolean_type_node;
- release_tree_vector (fargs);
- --processing_template_decl;
-
- return call;
-}
-
-/* Builds an id-expression of the form `C<Args...>` where C is a variable
- concept. */
-
-static tree
-build_variable_check (tree tmpl, tree args, tsubst_flags_t complain)
-{
- gcc_assert (variable_concept_p (tmpl));
- gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
- tree parms = INNERMOST_TEMPLATE_PARMS (DECL_TEMPLATE_PARMS (tmpl));
- args = coerce_template_parms (parms, args, tmpl, complain);
- if (args == error_mark_node)
- return error_mark_node;
- return build2 (TEMPLATE_ID_EXPR, boolean_type_node, tmpl, args);
-}
-
/* Builds an id-expression of the form `C<Args...>` where C is a standard
concept. */
static tree
build_standard_check (tree tmpl, tree args, tsubst_flags_t complain)
{
- gcc_assert (standard_concept_p (tmpl));
+ gcc_assert (concept_definition_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);
@@ -1475,12 +1216,8 @@ build_concept_check (tree decl, tree arg, tree rest,
tsubst_flags_t complain)
{
tree args = build_concept_check_arguments (arg, rest);
- if (standard_concept_p (decl))
+ if (concept_definition_p (decl))
return build_standard_check (decl, args, complain);
- if (variable_concept_p (decl))
- return build_variable_check (decl, args, complain);
- if (function_concept_p (decl))
- return build_function_check (decl, args, complain);
return error_mark_node;
}
@@ -1490,10 +1227,7 @@ build_concept_check (tree decl, tree arg, tree rest,
tsubst_flags_t complain)
static tree
build_concept_id (tree decl, tree args)
{
- tree check = build_concept_check (decl, args, tf_warning_or_error);
- if (check == error_mark_node)
- return error_mark_node;
- return unpack_concept_check (check);
+ return build_concept_check (decl, args, tf_warning_or_error);
}
/* Build a template-id that can participate in a concept check, preserving
@@ -1521,9 +1255,7 @@ build_type_constraint (tree decl, tree args,
tsubst_flags_t complain)
++processing_template_decl;
tree check = build_concept_check (decl, wildcard, args, complain);
--processing_template_decl;
- if (check == error_mark_node)
- return error_mark_node;
- return unpack_concept_check (check);
+ return check;
}
/* Returns a TYPE_DECL that contains sufficient information to
@@ -1621,10 +1353,7 @@ placeholder_extract_concept_and_args (tree t, tree
&tmpl, tree &args)
{
if (concept_check_p (t))
{
- t = unpack_concept_check (t);
tmpl = TREE_OPERAND (t, 0);
- if (TREE_CODE (tmpl) == OVERLOAD)
- tmpl = OVL_FIRST (tmpl);
args = TREE_OPERAND (t, 1);
return;
}
@@ -2938,9 +2667,8 @@ satisfy_nondeclaration_constraints (tree t, tree args,
sat_info info)
if (concept_check_p (t))
{
gcc_assert (!args);
- tree id = unpack_concept_check (t);
- args = TREE_OPERAND (id, 1);
- tree tmpl = get_concept_check_template (id);
+ args = TREE_OPERAND (t, 1);
+ tree tmpl = get_concept_check_template (t);
norm = normalize_concept_definition (tmpl, info.noisy ());
}
else if (TREE_CODE (t) == NESTED_REQ)
@@ -3255,41 +2983,6 @@ finish_nested_requirement (location_t loc, tree expr)
return r;
}
-/* Check that FN satisfies the structural requirements of a
- function concept definition. */
-tree
-check_function_concept (tree fn)
-{
- /* Check that the function is comprised of only a return statement. */
- tree body = DECL_SAVED_TREE (fn);
- if (TREE_CODE (body) == BIND_EXPR)
- body = BIND_EXPR_BODY (body);
-
- /* Sometimes a function call results in the creation of clean up
- points. Allow these to be preserved in the body of the
- constraint, as we might actually need them for some constexpr
- evaluations. */
- if (TREE_CODE (body) == CLEANUP_POINT_EXPR)
- body = TREE_OPERAND (body, 0);
-
- /* Check that the definition is written correctly. */
- if (TREE_CODE (body) != RETURN_EXPR)
- {
- location_t loc = DECL_SOURCE_LOCATION (fn);
- if (TREE_CODE (body) == STATEMENT_LIST && !STATEMENT_LIST_HEAD (body))
- {
- if (seen_error ())
- /* The definition was probably erroneous, not empty. */;
- else
- error_at (loc, "definition of concept %qD is empty", fn);
- }
- else
- error_at (loc, "definition of concept %qD has multiple statements",
fn);
- }
-
- return NULL_TREE;
-}
-
/*---------------------------------------------------------------------------
Equivalence of constraints
---------------------------------------------------------------------------*/
@@ -3403,10 +3096,7 @@ get_constraint_error_location (tree t)
/* Otherwise, give the location as the defining concept. */
else if (concept_check_p (src))
{
- tree id = unpack_concept_check (src);
- tree tmpl = TREE_OPERAND (id, 0);
- if (OVL_P (tmpl))
- tmpl = OVL_FIRST (tmpl);
+ tree tmpl = TREE_OPERAND (src, 0);
return DECL_SOURCE_LOCATION (tmpl);
}
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 238d786b067..c92ff707e3f 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3524,12 +3524,6 @@ struct GTY(()) lang_decl {
(retrofit_lang_decl (FUNCTION_DECL_CHECK (NODE)), \
LANG_DECL_FN_CHECK (NODE)->immediate_fn_p = true)
-// True if NODE was declared as 'concept'. The flag implies that the
-// declaration is constexpr, that the declaration cannot be specialized or
-// refined, and that the result type must be convertible to bool.
-#define DECL_DECLARED_CONCEPT_P(NODE) \
- (DECL_LANG_SPECIFIC (NODE)->u.base.concept_p)
-
/* Nonzero if this DECL is the __PRETTY_FUNCTION__ variable in a
template function. */
#define DECL_PRETTY_FUNCTION_P(NODE) \
@@ -8582,7 +8576,6 @@ extern bool equivalent_placeholder_constraints (tree,
tree);
extern hashval_t iterative_hash_placeholder_constraint (tree, hashval_t);
extern bool deduce_constrained_parameter (tree, tree&, tree&);
extern tree resolve_constraint_check (tree);
-extern tree check_function_concept (tree);
extern bool valid_requirements_p (tree);
extern tree finish_concept_name (tree);
extern tree finish_shorthand_constraint (tree, tree);
@@ -8605,7 +8598,6 @@ struct processing_constraint_expression_sentinel
extern bool processing_constraint_expression_p ();
-extern tree unpack_concept_check (tree);
extern tree get_concept_check_template (tree);
extern tree evaluate_concept_check (tree);
extern bool constraints_satisfied_p (tree, tree = NULL_TREE);
@@ -8867,69 +8859,12 @@ variable_template_p (tree t)
return false;
}
-/* True iff T is a standard concept definition. This will return
- true for both the template and underlying declaration. */
-
-inline bool
-standard_concept_p (tree t)
-{
- if (TREE_CODE (t) == TEMPLATE_DECL)
- t = DECL_TEMPLATE_RESULT (t);
- return TREE_CODE (t) == CONCEPT_DECL;
-}
-
-/* True iff T is a variable concept definition. This will return
- true for both the template and the underlying declaration. */
-
-inline bool
-variable_concept_p (tree t)
-{
- if (TREE_CODE (t) == TEMPLATE_DECL)
- t = DECL_TEMPLATE_RESULT (t);
- return VAR_P (t) && DECL_DECLARED_CONCEPT_P (t);
-}
-
-/* True iff T is a function concept definition or an overload set
- containing multiple function concepts. This will return true for
- both the template and the underlying declaration. */
-
-inline bool
-function_concept_p (tree t)
-{
- if (TREE_CODE (t) == OVERLOAD)
- t = OVL_FIRST (t);
- if (TREE_CODE (t) == TEMPLATE_DECL)
- t = DECL_TEMPLATE_RESULT (t);
- return TREE_CODE (t) == FUNCTION_DECL && DECL_DECLARED_CONCEPT_P (t);
-}
-
-/* True iff T is a standard, variable, or function concept. */
+/* True iff T is a concept. */
inline bool
concept_definition_p (tree t)
{
- if (t == error_mark_node)
- return false;
-
- /* Adjust for function concept overloads. */
- if (TREE_CODE (t) == OVERLOAD)
- t = OVL_FIRST (t);
-
- /* See through templates. */
- if (TREE_CODE (t) == TEMPLATE_DECL)
- t = DECL_TEMPLATE_RESULT (t);
-
- /* The obvious and easy case. */
- if (TREE_CODE (t) == CONCEPT_DECL)
- return true;
-
- /* Definitely not a concept. */
- if (!VAR_OR_FUNCTION_DECL_P (t))
- return false;
- if (!DECL_LANG_SPECIFIC (t))
- return false;
-
- return DECL_DECLARED_CONCEPT_P (t);
+ return TREE_CODE (STRIP_TEMPLATE (t)) == CONCEPT_DECL;
}
/* Same as above, but for const trees. */
@@ -8945,8 +8880,6 @@ concept_definition_p (const_tree t)
inline bool
concept_check_p (const_tree t)
{
- if (TREE_CODE (t) == CALL_EXPR)
- t = CALL_EXPR_FN (t);
if (t && TREE_CODE (t) == TEMPLATE_ID_EXPR)
return concept_definition_p (TREE_OPERAND (t, 0));
return false;
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 687ae6937f5..04877087dc7 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -1467,36 +1467,6 @@ validate_constexpr_redeclaration (tree old_decl, tree
new_decl)
return true;
}
-// If OLDDECL and NEWDECL are concept declarations with the same type
-// (i.e., and template parameters), but different requirements,
-// emit diagnostics and return true. Otherwise, return false.
-static inline bool
-check_concept_refinement (tree olddecl, tree newdecl)
-{
- if (!DECL_DECLARED_CONCEPT_P (olddecl) || !DECL_DECLARED_CONCEPT_P (newdecl))
- return false;
-
- tree d1 = DECL_TEMPLATE_RESULT (olddecl);
- tree d2 = DECL_TEMPLATE_RESULT (newdecl);
- if (TREE_CODE (d1) != TREE_CODE (d2))
- return false;
-
- tree t1 = TREE_TYPE (d1);
- tree t2 = TREE_TYPE (d2);
- if (TREE_CODE (d1) == FUNCTION_DECL)
- {
- if (compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))
- && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl),
- DECL_TEMPLATE_PARMS (newdecl))
- && !equivalently_constrained (olddecl, newdecl))
- {
- error ("cannot specialize concept %q#D", olddecl);
- return true;
- }
- }
- return false;
-}
-
/* DECL is a redeclaration of a function or function template. If
it does have default arguments issue a diagnostic. Note: this
function is used to enforce the requirements in C++11 8.3.6 about
@@ -1990,8 +1960,6 @@ duplicate_decls (tree newdecl, tree olddecl, bool hiding,
bool was_hidden)
return error_mark_node;
return NULL_TREE;
}
- else if (check_concept_refinement (olddecl, newdecl))
- return error_mark_node;
return NULL_TREE;
}
if (TREE_CODE (newdecl) == FUNCTION_DECL)
@@ -8224,16 +8192,6 @@ value_dependent_init_p (tree init)
return false;
}
-// Returns true if a DECL is VAR_DECL with the concept specifier.
-static inline bool
-is_concept_var (tree decl)
-{
- return (VAR_P (decl)
- // Not all variables have DECL_LANG_SPECIFIC.
- && DECL_LANG_SPECIFIC (decl)
- && DECL_DECLARED_CONCEPT_P (decl));
-}
-
/* A helper function to be called via walk_tree. If any label exists
under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
@@ -8751,11 +8709,6 @@ cp_finish_decl (tree decl, tree init, bool
init_const_expr_p,
if (!VAR_P (decl) || type_dependent_p)
/* We can't do anything if the decl has dependent type. */;
- else if (!init && is_concept_var (decl))
- {
- error ("variable concept has no initializer");
- init = boolean_true_node;
- }
else if (init
&& (init_const_expr_p || DECL_DECLARED_CONSTEXPR_P (decl))
&& !TYPE_REF_P (type)
@@ -10547,26 +10500,6 @@ check_static_quals (tree decl, cp_cv_quals quals)
decl);
}
-// Check that FN takes no arguments and returns bool.
-static void
-check_concept_fn (tree fn)
-{
- // A constraint is nullary.
- if (DECL_ARGUMENTS (fn))
- error_at (DECL_SOURCE_LOCATION (fn),
- "concept %q#D declared with function parameters", fn);
-
- // The declared return type of the concept shall be bool, and
- // it shall not be deduced from it definition.
- tree type = TREE_TYPE (TREE_TYPE (fn));
- if (is_auto (type))
- error_at (DECL_SOURCE_LOCATION (fn),
- "concept %q#D declared with a deduced return type", fn);
- else if (type != boolean_type_node)
- error_at (DECL_SOURCE_LOCATION (fn),
- "concept %q#D with non-%<bool%> return type %qT", fn, type);
-}
-
/* Helper function. Replace the temporary this parameter injected
during cp_finish_omp_declare_simd with the real this parameter. */
@@ -10637,10 +10570,9 @@ grokfndecl (tree ctype,
/* Was the concept specifier present? */
bool concept_p = inlinep & 4;
- /* Concept declarations must have a corresponding definition. */
- if (concept_p && !funcdef_flag)
+ if (concept_p)
{
- error_at (location, "concept %qD has no definition", declarator);
+ error_at (location, "function concepts are no longer supported");
return NULL_TREE;
}
@@ -10667,11 +10599,6 @@ grokfndecl (tree ctype,
tmpl_reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
}
tree ci = build_constraints (tmpl_reqs, decl_reqs);
- if (concept_p && ci)
- {
- error_at (location, "a function concept cannot be constrained");
- ci = NULL_TREE;
- }
/* C++20 CA378: Remove non-templated constrained functions. */
/* [temp.friend]/9 A non-template friend declaration with a
requires-clause shall be a definition. A friend function template with
@@ -10903,14 +10830,6 @@ grokfndecl (tree ctype,
SET_DECL_IMMEDIATE_FUNCTION_P (decl);
}
- // If the concept declaration specifier was found, check
- // that the declaration satisfies the necessary requirements.
- if (concept_p)
- {
- DECL_DECLARED_CONCEPT_P (decl) = true;
- check_concept_fn (decl);
- }
-
DECL_EXTERNAL (decl) = 1;
if (TREE_CODE (type) == FUNCTION_TYPE)
{
@@ -11072,8 +10991,7 @@ grokfndecl (tree ctype,
decl = check_explicit_specialization (orig_declarator, decl,
template_count,
2 * funcdef_flag +
- 4 * (friendp != 0) +
- 8 * concept_p,
+ 4 * (friendp != 0),
*attrlist);
if (decl == error_mark_node)
return NULL_TREE;
@@ -11365,29 +11283,19 @@ grokvardecl (tree type,
"C language linkage");
}
- /* Check that the variable can be safely declared as a concept.
- Note that this also forbids explicit specializations. */
+ /* Check if a variable is being declared as a concept. */
if (conceptp)
{
if (!processing_template_decl)
- {
- error_at (declspecs->locations[ds_concept],
- "a non-template variable cannot be %<concept%>");
- return NULL_TREE;
- }
+ error_at (declspecs->locations[ds_concept],
+ "a non-template variable cannot be %<concept%>");
else if (!at_namespace_scope_p ())
- {
- error_at (declspecs->locations[ds_concept],
- "concept must be defined at namespace scope");
- return NULL_TREE;
- }
+ error_at (declspecs->locations[ds_concept],
+ "concept must be defined at namespace scope");
else
- DECL_DECLARED_CONCEPT_P (decl) = true;
- if (TEMPLATE_PARMS_CONSTRAINTS (current_template_parms))
- {
- error_at (location, "a variable concept cannot be constrained");
- TEMPLATE_PARMS_CONSTRAINTS (current_template_parms) = NULL_TREE;
- }
+ error_at (declspecs->locations[ds_concept],
+ "variable concepts are no longer supported");
+ return NULL_TREE;
}
else if (flag_concepts
&& current_template_depth > template_class_depth (scope))
@@ -18808,10 +18716,6 @@ finish_function (bool inline_p)
goto cleanup;
}
- // If this is a concept, check that the definition is reasonable.
- if (DECL_DECLARED_CONCEPT_P (fndecl))
- check_function_concept (fndecl);
-
if (flag_openmp)
if (tree attr = lookup_attribute ("omp declare variant base",
DECL_ATTRIBUTES (fndecl)))
diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc
index 6d674684931..695d5f8d790 100644
--- a/gcc/cp/decl2.cc
+++ b/gcc/cp/decl2.cc
@@ -2723,7 +2723,7 @@ min_vis_expr_r (tree *tp, int */*walk_subtrees*/, void
*data)
break;
case TEMPLATE_DECL:
- if (DECL_ALIAS_TEMPLATE_P (t) || standard_concept_p (t))
+ if (DECL_ALIAS_TEMPLATE_P (t) || concept_definition_p (t))
/* FIXME: We don't maintain TREE_PUBLIC / DECL_VISIBILITY for
alias templates so we can't trust it here (PR107906). Ditto
for concepts. */
@@ -5687,7 +5687,6 @@ maybe_instantiate_decl (tree decl)
if (VAR_OR_FUNCTION_DECL_P (decl)
&& DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INFO (decl)
- && !DECL_DECLARED_CONCEPT_P (decl)
&& !uses_template_parms (DECL_TI_ARGS (decl)))
{
/* Instantiating a function will result in garbage collection. We
@@ -6084,7 +6083,6 @@ mark_used (tree decl, tsubst_flags_t complain /* =
tf_warning_or_error */)
}
else if (VAR_OR_FUNCTION_DECL_P (decl)
&& DECL_TEMPLATE_INFO (decl)
- && !DECL_DECLARED_CONCEPT_P (decl)
&& (!DECL_EXPLICIT_INSTANTIATION (decl)
|| always_instantiate_p (decl)))
/* If this is a function or variable that is an instance of some
diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
index d80bac822ba..aecbc4ff0d9 100644
--- a/gcc/cp/error.cc
+++ b/gcc/cp/error.cc
@@ -1163,7 +1163,7 @@ dump_simple_decl (cxx_pretty_printer *pp, tree t, tree
type, int flags)
else if (VAR_P (t) && DECL_DECLARED_CONSTEXPR_P (t))
pp_cxx_ws_string (pp, "constexpr");
- if (!standard_concept_p (t))
+ if (!concept_definition_p (t))
dump_type_prefix (pp, type, flags & ~TFF_UNQUALIFIED_NAME);
pp_maybe_space (pp);
}
@@ -1806,9 +1806,7 @@ dump_function_decl (cxx_pretty_printer *pp, tree t, int
flags)
if (constexpr_p)
{
- if (DECL_DECLARED_CONCEPT_P (t))
- pp_cxx_ws_string (pp, "concept");
- else if (DECL_IMMEDIATE_FUNCTION_P (t))
+ if (DECL_IMMEDIATE_FUNCTION_P (t))
pp_cxx_ws_string (pp, "consteval");
else
pp_cxx_ws_string (pp, "constexpr");
@@ -3952,8 +3950,8 @@ print_concept_check_info (diagnostic_context *context,
tree expr, tree map, tree
{
gcc_assert (concept_check_p (expr));
- tree id = unpack_concept_check (expr);
- tree tmpl = TREE_OPERAND (id, 0);
+ tree tmpl = TREE_OPERAND (expr, 0);
+ // ??? Can this go now that fn/var concepts have been removed?
if (OVL_P (tmpl))
tmpl = OVL_FIRST (tmpl);
diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
index e7391220234..46dc6923add 100644
--- a/gcc/cp/mangle.cc
+++ b/gcc/cp/mangle.cc
@@ -901,9 +901,9 @@ write_tparms_constraints (tree constraints)
static void
write_type_constraint (tree cnst)
{
- if (!cnst) return;
+ if (!cnst)
+ return;
- cnst = unpack_concept_check (cnst);
gcc_checking_assert (TREE_CODE (cnst) == TEMPLATE_ID_EXPR);
tree concept_decl = get_concept_check_template (cnst);
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index eb102dea829..f625b0a310c 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -7161,18 +7161,13 @@ cp_parser_nested_name_specifier_opt (cp_parser *parser,
tree fns = get_fns (tid);
if (OVL_SINGLE_P (fns))
tmpl = OVL_FIRST (fns);
- if (function_concept_p (fns))
- error_at (token->location, "concept-id %qD "
- "in nested-name-specifier", tid);
- else
- error_at (token->location, "function template-id "
- "%qD in nested-name-specifier", tid);
+ error_at (token->location, "function template-id "
+ "%qD in nested-name-specifier", tid);
}
else
{
tmpl = TREE_OPERAND (tid, 0);
- if (variable_concept_p (tmpl)
- || standard_concept_p (tmpl))
+ if (concept_definition_p (tmpl))
error_at (token->location, "concept-id %qD "
"in nested-name-specifier", tid);
else
@@ -12224,9 +12219,6 @@ add_debug_begin_stmt (location_t loc)
{
if (!MAY_HAVE_DEBUG_MARKER_STMTS)
return;
- if (DECL_DECLARED_CONCEPT_P (current_function_decl))
- /* A concept is never expanded normally. */
- return;
tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_node);
SET_EXPR_LOCATION (stmt, loc);
@@ -33087,8 +33079,6 @@ cp_parser_template_declaration_after_parameters
(cp_parser* parser,
else if (flag_concepts
&& cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT)
&& cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
- /* -fconcept-ts 'concept bool' syntax is handled below, in
- cp_parser_single_declaration. */
decl = cp_parser_concept_definition (parser);
else
{
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 77fa5907c3d..35a9c5619f9 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -3232,14 +3232,6 @@ check_explicit_specialization (tree declarator,
tree tmpl_func = DECL_TEMPLATE_RESULT (gen_tmpl);
gcc_assert (TREE_CODE (tmpl_func) == FUNCTION_DECL);
- /* A concept cannot be specialized. */
- if (DECL_DECLARED_CONCEPT_P (tmpl_func))
- {
- error ("explicit specialization of function concept %qD",
- gen_tmpl);
- return error_mark_node;
- }
-
/* This specialization has the same linkage and visibility as
the function template it specializes. */
TREE_PUBLIC (decl) = TREE_PUBLIC (tmpl_func);
@@ -5150,13 +5142,6 @@ process_partial_specialization (tree decl)
gcc_assert (current_template_parms);
- /* A concept cannot be specialized. */
- if (flag_concepts && variable_concept_p (maintmpl))
- {
- error ("specialization of variable concept %q#D", maintmpl);
- return error_mark_node;
- }
-
inner_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
ntparms = TREE_VEC_LENGTH (inner_parms);
@@ -10532,9 +10517,6 @@ lookup_template_class (tree d1, tree arglist, tree
in_decl, tree context,
tree
lookup_template_variable (tree templ, tree arglist, tsubst_flags_t complain)
{
- if (flag_concepts && variable_concept_p (templ))
- return build_concept_check (templ, arglist, tf_none);
-
tree gen_templ = most_general_template (templ);
tree parms = DECL_INNERMOST_TEMPLATE_PARMS (gen_templ);
arglist = add_outermost_template_args (templ, arglist);
@@ -20119,14 +20101,6 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
complain, tree in_decl)
tree check = build_concept_check (templ, targs, complain);
if (check == error_mark_node)
RETURN (error_mark_node);
-
- tree id = unpack_concept_check (check);
-
- /* If we built a function concept check, return the underlying
- template-id. So we can evaluate it as a function call. */
- if (function_concept_p (TREE_OPERAND (id, 0)))
- RETURN (id);
-
RETURN (check);
}
@@ -21096,19 +21070,8 @@ tsubst_expr (tree t, tree args, tsubst_flags_t
complain, tree in_decl)
ret = build_offset_ref_call_from_tree (function, &call_args,
complain);
else if (concept_check_p (function))
- {
- /* FUNCTION is a template-id referring to a concept definition. */
- tree id = unpack_concept_check (function);
- tree tmpl = TREE_OPERAND (id, 0);
- tree args = TREE_OPERAND (id, 1);
-
- /* Calls to standard and variable concepts should have been
- previously diagnosed. */
- gcc_assert (function_concept_p (tmpl));
-
- /* Ensure the result is wrapped as a call expression. */
- ret = build_concept_check (tmpl, args, tf_warning_or_error);
- }
+ /* Calls to concepts should have been previously diagnosed. */
+ gcc_assert (false);
else
ret = finish_call_expr (function, &call_args,
/*disallow_virtual=*/qualified_p,
@@ -26414,14 +26377,6 @@ do_decl_instantiation (tree decl, tree storage)
error ("explicit instantiation of non-template %q#D", decl);
return;
}
- else if (DECL_DECLARED_CONCEPT_P (decl))
- {
- if (VAR_P (decl))
- error ("explicit instantiation of variable concept %q#D", decl);
- else
- error ("explicit instantiation of function concept %q#D", decl);
- return;
- }
bool var_templ = (DECL_TEMPLATE_INFO (decl)
&& variable_template_p (DECL_TI_TEMPLATE (decl)));
@@ -27211,9 +27166,6 @@ instantiate_decl (tree d, bool defer_ok, bool
expl_inst_class_mem_p)
functions and static member variables. */
gcc_assert (VAR_OR_FUNCTION_DECL_P (d));
- /* A concept is never instantiated. */
- gcc_assert (!DECL_DECLARED_CONCEPT_P (d));
-
gcc_checking_assert (!DECL_FUNCTION_SCOPE_P (d));
if (modules_p ())
@@ -29492,8 +29444,8 @@ make_constrained_decltype_auto (tree con, tree args)
static bool
placeholder_type_constraint_dependent_p (tree t)
{
- tree id = unpack_concept_check (t);
- tree args = TREE_OPERAND (id, 1);
+ gcc_assert (concept_check_p (t));
+ tree args = TREE_OPERAND (t, 1);
tree first = TREE_VEC_ELT (args, 0);
if (ARGUMENT_PACK_P (first))
{
@@ -31452,8 +31404,8 @@ convert_generic_types_to_packs (tree parm, int
start_idx, int end_idx)
requirements. */
if (tree constr = TEMPLATE_PARM_CONSTRAINTS (node))
{
- tree id = unpack_concept_check (constr);
- TREE_VEC_ELT (TREE_OPERAND (id, 1), 0) = t;
+ gcc_assert (concept_check_p (constr));
+ TREE_VEC_ELT (TREE_OPERAND (constr, 1), 0) = t;
/* Use UNKNOWN_LOCATION so write_template_args can tell the
difference between this and a fold the user wrote. */
location_t loc = UNKNOWN_LOCATION;
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 669da4ad969..e58612660c9 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -3067,20 +3067,9 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool
disallow_virtual,
}
else if (concept_check_p (fn))
{
- /* FN is actually a template-id referring to a concept definition. */
- tree id = unpack_concept_check (fn);
- tree tmpl = TREE_OPERAND (id, 0);
- tree args = TREE_OPERAND (id, 1);
-
- if (!function_concept_p (tmpl))
- {
- error_at (EXPR_LOC_OR_LOC (fn, input_location),
- "cannot call a concept as a function");
- return error_mark_node;
- }
-
- /* Ensure the result is wrapped as a call expression. */
- result = build_concept_check (tmpl, args, tf_warning_or_error);
+ error_at (EXPR_LOC_OR_LOC (fn, input_location),
+ "cannot call a concept as a function");
+ return error_mark_node;
}
else if (is_overloaded_fn (fn))
{
diff --git a/gcc/testsuite/g++.dg/concepts/decl-diagnose.C
b/gcc/testsuite/g++.dg/concepts/decl-diagnose.C
index 0d10ce1ea9f..2bf1cd5ab17 100644
--- a/gcc/testsuite/g++.dg/concepts/decl-diagnose.C
+++ b/gcc/testsuite/g++.dg/concepts/decl-diagnose.C
@@ -7,8 +7,8 @@ typedef concept int CINT; // { dg-error "'concept' cannot
appear in a typedef de
void f(concept int); // { dg-error "a parameter cannot be declared 'concept'" }
template<typename T>
-concept int f2() { return 0; } // { dg-error "return type" }
-concept bool f3(); // { dg-error "14:concept .f3. has no definition" }
+concept int f2() { return 0; } // { dg-error "function concepts are no longer
supported" }
+concept bool f3(); // { dg-error "14:function concepts are no longer
supported" }
// { dg-error "keyword is not allowed" "" { target *-*-* }
.-1 }
struct X
@@ -26,11 +26,11 @@ struct X
concept X(); // { dg-error "a constructor cannot be 'concept'" }
};
-concept bool X2; // { dg-error "non-template variable" }
+concept bool X2; // { dg-error "variable" }
// { dg-error "keyword is not allowed" "" { target *-*-* } .-1
}
template<typename T>
- concept bool X3; // { dg-error "has no initializer" }
+ concept bool X3; // { dg-error "variable concepts" }
// { dg-error "keyword is not allowed" "" { target *-*-* }
.-1 }
struct S {
diff --git a/gcc/testsuite/g++.dg/concepts/fn-concept2.C
b/gcc/testsuite/g++.dg/concepts/fn-concept2.C
index 799e85de955..52ca8245c76 100644
--- a/gcc/testsuite/g++.dg/concepts/fn-concept2.C
+++ b/gcc/testsuite/g++.dg/concepts/fn-concept2.C
@@ -3,7 +3,7 @@
// { dg-prune-output "concept definition syntax is" }
template<typename T>
- concept auto C1() { return 0; } // { dg-error "16:concept .concept auto
C1\\(\\). declared with a deduced return type" }
+ concept auto C1() { return 0; } // { dg-error "16:function concepts are no
longer supported" }
template<typename T>
- concept int C2() { return 0; } // { dg-error "15:concept .concept int
C2\\(\\). with non-.bool. return type .int." }
+ concept int C2() { return 0; } // { dg-error "15:function concepts are no
longer supported" }
diff --git a/gcc/testsuite/g++.dg/concepts/pr71128.C
b/gcc/testsuite/g++.dg/concepts/pr71128.C
index 63b3d1dff78..a3d5357d432 100644
--- a/gcc/testsuite/g++.dg/concepts/pr71128.C
+++ b/gcc/testsuite/g++.dg/concepts/pr71128.C
@@ -2,9 +2,9 @@
// { dg-options "-fconcepts" }
template<typename T>
-concept bool C() { return true; } // { dg-error "the .bool. keyword" }
-template bool C<int>(); // { dg-error "explicit instantiation of function
concept" }
+concept bool C() { return true; } // { dg-error "the .bool. keyword|function
concepts" }
+template bool C<int>(); // { dg-error "template function|not a function
template|expected" }
template<typename T>
-concept bool D = true; // { dg-error "the .bool. keyword" }
-template bool D<int>; // { dg-error "explicit instantiation of variable
concept" }
+concept bool D = true; // { dg-error "the .bool. keyword|variable concepts are
no longer supported" }
+template bool D<int>; // { dg-error "not a template function|expected" }
diff --git a/gcc/testsuite/g++.dg/concepts/var-concept6.C
b/gcc/testsuite/g++.dg/concepts/var-concept6.C
index 04298f47a92..062007a1291 100644
--- a/gcc/testsuite/g++.dg/concepts/var-concept6.C
+++ b/gcc/testsuite/g++.dg/concepts/var-concept6.C
@@ -2,4 +2,4 @@
// { dg-options "-fconcepts" }
template <class T>
-concept int C = true; // { dg-error "concept definition syntax" }
+concept int C = true; // { dg-error "concept definition
syntax|variable concepts are no longer supported" }
diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts.C
b/gcc/testsuite/g++.dg/cpp2a/concepts.C
index ebeeebf60bb..1b7a708659b 100644
--- a/gcc/testsuite/g++.dg/cpp2a/concepts.C
+++ b/gcc/testsuite/g++.dg/cpp2a/concepts.C
@@ -18,9 +18,9 @@ void f3(T)
{ }
template<typename T>
-concept bool C1 = true; // { dg-error "bool" }
+concept bool C1 = true; // { dg-error "bool|variable concepts" }
template<typename T>
-bool concept C2 = true; // { dg-error "concept definition syntax" }
+bool concept C2 = true; // { dg-error "concept definition syntax|variable
concepts" }
template<typename T>
concept C3 = true; // OK
base-commit: a10436a8404ad2f0cc5aa4d6a0cc850abe5ef49e
--
2.45.2
