On Thu, 17 Oct 2024, Patrick Palka wrote:
> On Thu, 17 Oct 2024, Patrick Palka wrote:
>
> > On Tue, 15 Oct 2024, Patrick Palka wrote:
> >
> > > On Tue, 15 Oct 2024, Patrick Palka wrote:
> > >
> > > > According to [temp.param]/11, the constraint on an auto NTTP is an
> > > > associated constraint and so should be checked as part of satisfaction
> > > > of the overall associated constraints rather than checked individually
> > > > during coerion/deduction.
> > >
> > > By the way, I wonder if such associated constraints should be relevant for
> > > subsumption now?
> > >
> > > template<class T> concept C = true;
> > >
> > > template<class T> concept D = C<T> && true;
> > >
> > > template<C auto V> void f(); // #1
> > > template<D auto V> void f(); // #2
> > >
> > > int main() {
> > > f<0>(); // still ambiguous?
> > > }
> > >
> > > With this patch the above call is still ambiguous despite #2 now being
> > > more constrained than #1 because "more constrained" is only considered for
> > > function templates with the same signatures as per
> > > https://eel.is/c++draft/temp.func.order#6.2.2 and we deem their signatures
> > > to be different due to the different type-constraint.
> >
> > I think I convinced myself that this example should be accepted, and the
> > way to go about that is to replace the constrained auto in the NTTP type
> > with an ordinary auto once we set its TEMPLATE_PARM_CONSTRAINTS. That
> > way both templates have the same signature modulo associated constraints.
>
> Here is v2 which implements this in finish_constrained_parameter. Now
> we can assert that do_auto_deduction doesn't see a constrained auto
> during adc_unify deduction!
Ping.
>
> -- >8 --
>
> Subject: [PATCH v2 2/2] c++: constrained auto NTTP vs associated constraints
>
> According to [temp.param]/11, the constraint on an auto NTTP is an
> associated constraint and so should be checked as part of satisfaction
> of the overall associated constraints rather than checked individually
> during coerion/deduction.
>
> In order to implement this we mainly need to make handling of
> constrained auto NTTPs go through finish_constrained_parameter so that
> TEMPLATE_PARM_CONSTRAINTS gets set on them, and teach
> finish_shorthand_constraint how to build an associated constraint
> corresponding to the written type-constraint.
>
> gcc/cp/ChangeLog:
>
> * constraint.cc (finish_shorthand_constraint): Add is_non_type
> parameter for handling constrained (auto) NTTPS.
> * cp-tree.h (do_auto_deduction): Adjust declaration.
> (copy_template_args): Declare.
> (finish_shorthand_constraint): Adjust declaration.
> * mangle.cc (write_template_param_decl): Obtain constraints of
> an (auto) NTTP through TEMPLATE_PARM_CONSTRAINTS instead of
> PLACEHOLDER_TYPE_CONSTRAINTS.
> * parser.cc (cp_parser_constrained_type_template_parm): Inline
> into its only caller and remove.
> (cp_parser_constrained_non_type_template_parm): Likewise.
> (finish_constrained_parameter): Simplify after the above. Replace
> the type of a constrained (auto) NTTP with an ordinary auto.
> (cp_parser_template_parameter): Dispatch to
> finish_constrained_parameter for a constrained auto NTTP.
> * pt.cc (process_template_parm): Pass is_non_type to
> finish_shorthand_constraint.
> (convert_template_argument): Adjust call to do_auto_deduction.
> (copy_template_args): Remove static.
> (unify): Adjust call to do_auto_deduction.
> (make_constrained_placeholder_type): Return the type not the
> TYPE_NAME for consistency with make_auto etc.
> (do_auto_deduction): Remove now unused tmpl parameter. Assert
> we no longer see constrained autos during coercion/deduction.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/cpp2a/concepts-placeholder12.C: Adjust expected error
> upon constrained auto NTTP satisfaction failure.
> * g++.dg/cpp2a/concepts-pr97093.C: Likewise.
> * g++.dg/cpp2a/concepts-template-parm2.C: Likewise.
> * g++.dg/cpp2a/concepts-template-parm6.C: Likewise.
> * g++.dg/cpp2a/concepts-template-parm12.C: New test.
> ---
> gcc/cp/constraint.cc | 32 ++++++++--
> gcc/cp/cp-tree.h | 6 +-
> gcc/cp/mangle.cc | 2 +-
> gcc/cp/parser.cc | 64 ++++++++-----------
> gcc/cp/pt.cc | 38 +++++------
> .../g++.dg/cpp2a/concepts-placeholder12.C | 4 +-
> gcc/testsuite/g++.dg/cpp2a/concepts-pr97093.C | 2 +-
> .../g++.dg/cpp2a/concepts-template-parm12.C | 22 +++++++
> .../g++.dg/cpp2a/concepts-template-parm2.C | 2 +-
> .../g++.dg/cpp2a/concepts-template-parm6.C | 2 +-
> 10 files changed, 101 insertions(+), 73 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/cpp2a/concepts-template-parm12.C
>
> diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
> index 35be9cc2b41..9394bea8835 100644
> --- a/gcc/cp/constraint.cc
> +++ b/gcc/cp/constraint.cc
> @@ -1189,7 +1189,7 @@ build_constrained_parameter (tree cnc, tree proto, tree
> args)
> done only after the requires clause has been parsed (or not). */
>
> tree
> -finish_shorthand_constraint (tree decl, tree constr)
> +finish_shorthand_constraint (tree decl, tree constr, bool is_non_type)
> {
> /* No requirements means no constraints. */
> if (!constr)
> @@ -1198,9 +1198,22 @@ finish_shorthand_constraint (tree decl, tree constr)
> if (error_operand_p (constr))
> return NULL_TREE;
>
> - tree proto = CONSTRAINED_PARM_PROTOTYPE (constr);
> - tree con = CONSTRAINED_PARM_CONCEPT (constr);
> - tree args = CONSTRAINED_PARM_EXTRA_ARGS (constr);
> + tree proto, con, args;
> + if (is_non_type)
> + {
> + tree id = PLACEHOLDER_TYPE_CONSTRAINTS (constr);
> + tree tmpl = TREE_OPERAND (id, 0);
> + tree parms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
> + proto = TREE_VALUE (TREE_VEC_ELT (parms, 0));
> + con = DECL_TEMPLATE_RESULT (tmpl);
> + args = TREE_OPERAND (id, 1);
> + }
> + else
> + {
> + proto = CONSTRAINED_PARM_PROTOTYPE (constr);
> + con = CONSTRAINED_PARM_CONCEPT (constr);
> + args = CONSTRAINED_PARM_EXTRA_ARGS (constr);
> + }
>
> bool variadic_concept_p = template_parameter_pack_p (proto);
> bool declared_pack_p = template_parameter_pack_p (decl);
> @@ -1214,7 +1227,16 @@ finish_shorthand_constraint (tree decl, tree constr)
>
> /* Build the concept constraint-expression. */
> tree tmpl = DECL_TI_TEMPLATE (con);
> - tree check = build_concept_check (tmpl, arg, args, tf_warning_or_error);
> + tree check;
> + if (is_non_type)
> + {
> + arg = finish_decltype_type (arg, /*id_expr=*/true,
> tf_warning_or_error);
> + args = copy_template_args (args);
> + TREE_VEC_ELT (args, 0) = arg;
> + check = build_concept_check (tmpl, args, tf_warning_or_error);
> + }
> + else
> + check = build_concept_check (tmpl, arg, args, tf_warning_or_error);
>
> /* Make the check a fold-expression if needed.
> Use UNKNOWN_LOCATION so write_template_args can tell the
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 1864ab205ae..1e202e17658 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -7528,8 +7528,7 @@ extern tree do_auto_deduction (tree,
> tree, tree,
> auto_deduction_context
> = adc_unspecified,
> tree = NULL_TREE,
> - int = LOOKUP_NORMAL,
> - tree = NULL_TREE);
> + int = LOOKUP_NORMAL);
> extern tree type_uses_auto (tree);
> extern tree convert_generic_types_to_packs (tree, int, int);
> extern tree splice_late_return_type (tree, tree);
> @@ -7587,6 +7586,7 @@ extern bool is_specialization_of_friend (tree,
> tree);
> extern bool comp_template_args (tree, tree, tree * =
> NULL,
> tree * = NULL);
> extern int template_args_equal (tree, tree);
> +extern tree copy_template_args (tree);
> extern tree maybe_process_partial_specialization (tree);
> extern tree most_specialized_instantiation (tree);
> extern tree most_specialized_partial_spec (tree, tsubst_flags_t, bool
> = false);
> @@ -8598,7 +8598,7 @@ extern tree build_concept_check (tree,
> tree, tree, tsubst_flags_
> extern tree build_constrained_parameter (tree, tree, tree =
> NULL_TREE);
> extern bool equivalent_placeholder_constraints (tree, tree);
> extern hashval_t iterative_hash_placeholder_constraint (tree,
> hashval_t);
> -extern tree finish_shorthand_constraint (tree, tree);
> +extern tree finish_shorthand_constraint (tree, tree, bool);
> extern tree finish_requires_expr (location_t, tree, tree);
> extern tree finish_simple_requirement (location_t, tree);
> extern tree finish_type_requirement (location_t, tree);
> diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc
> index 17988d69e1e..d016622526f 100644
> --- a/gcc/cp/mangle.cc
> +++ b/gcc/cp/mangle.cc
> @@ -1896,7 +1896,7 @@ write_template_param_decl (tree parm)
>
> tree type = TREE_TYPE (decl);
> if (tree c = (is_auto (type)
> - ? PLACEHOLDER_TYPE_CONSTRAINTS (type)
> + ? TEMPLATE_PARM_CONSTRAINTS (parm)
> : NULL_TREE))
> {
> if (AUTO_IS_DECLTYPE (type))
> diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
> index 856508e3e4f..0bad62978dc 100644
> --- a/gcc/cp/parser.cc
> +++ b/gcc/cp/parser.cc
> @@ -18599,34 +18599,6 @@ cp_parser_check_constrained_type_parm (cp_parser
> *parser,
> return true;
> }
>
> -/* Finish parsing/processing a template type parameter and checking
> - various restrictions. */
> -
> -static inline tree
> -cp_parser_constrained_type_template_parm (cp_parser *parser,
> - tree id,
> - cp_parameter_declarator* parmdecl)
> -{
> - if (cp_parser_check_constrained_type_parm (parser, parmdecl))
> - return finish_template_type_parm (class_type_node, id);
> - else
> - return error_mark_node;
> -}
> -
> -/* Create a new non-type template parameter from the given PARM
> - declarator. */
> -
> -static tree
> -cp_parser_constrained_non_type_template_parm (bool *is_non_type,
> - cp_parameter_declarator *parm)
> -{
> - *is_non_type = true;
> - cp_declarator *decl = parm->declarator;
> - cp_decl_specifier_seq *specs = &parm->decl_specifiers;
> - specs->type = TREE_TYPE (DECL_INITIAL (specs->type));
> - return grokdeclarator (decl, specs, TPARM, 0, NULL);
> -}
> -
> /* Build a constrained template parameter based on the PARMDECL
> declarator. The type of PARMDECL is the constrained type, which
> refers to the prototype template parameter that ultimately
> @@ -18637,24 +18609,43 @@ finish_constrained_parameter (cp_parser *parser,
> cp_parameter_declarator *parmdecl,
> bool *is_non_type)
> {
> - tree decl = parmdecl->decl_specifiers.type;
> + tree constr = parmdecl->decl_specifiers.type;
> tree id = get_unqualified_id (parmdecl->declarator);
> tree def = parmdecl->default_argument;
> - tree proto = DECL_INITIAL (decl);
>
> /* Build the parameter. Return an error if the declarator was invalid. */
> tree parm;
> - if (TREE_CODE (proto) == TYPE_DECL)
> - parm = cp_parser_constrained_type_template_parm (parser, id, parmdecl);
> + if (is_constrained_auto (constr))
> + {
> + /* Constrained non-type parameter. */
> + *is_non_type = true;
> + parm = grokdeclarator (parmdecl->declarator,
> + &parmdecl->decl_specifiers,
> + TPARM, /*initialized=*/0, /*attrlist=*/NULL);
> + /* Replace the type of this constrained (auto) NTTP with an ordinary
> + auto; its constraint gets saved in TEMPLATE_PARM_CONSTRAINTS to be
> + associated with the template. */
> + if (parm != error_mark_node)
> + TREE_TYPE (parm) = (AUTO_IS_DECLTYPE (constr)
> + ? make_decltype_auto ()
> + : make_auto ());
> + }
> else
> - parm = cp_parser_constrained_non_type_template_parm (is_non_type,
> parmdecl);
> + {
> + /* Constrained type parameter. */
> + gcc_checking_assert (CONSTRAINED_PARM_CONCEPT (constr));
> + if (cp_parser_check_constrained_type_parm (parser, parmdecl))
> + parm = finish_template_type_parm (class_type_node, id);
> + else
> + parm = error_mark_node;
> + }
> if (parm == error_mark_node)
> return error_mark_node;
>
> /* Finish the parameter decl and create a node attaching the
> default argument and constraint. */
> parm = build_tree_list (def, parm);
> - TEMPLATE_PARM_CONSTRAINTS (parm) = decl;
> + TEMPLATE_PARM_CONSTRAINTS (parm) = constr;
>
> return parm;
> }
> @@ -18841,9 +18832,10 @@ cp_parser_template_parameter (cp_parser* parser,
> bool *is_non_type,
> cp_lexer_consume_token (parser->lexer);
> }
>
> - /* The parameter may have been constrained type parameter. */
> + /* The parameter may be constrained (type or non-type). */
> tree type = parameter_declarator->decl_specifiers.type;
> - if (declares_constrained_type_template_parameter (type))
> + if (declares_constrained_type_template_parameter (type)
> + || (type && is_constrained_auto (type)))
> return finish_constrained_parameter (parser,
> parameter_declarator,
> is_non_type);
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index f716a98f840..8b183a139d7 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -183,7 +183,6 @@ static int template_decl_level (tree);
> static int check_cv_quals_for_unify (int, tree, tree);
> static int unify_pack_expansion (tree, tree, tree,
> tree, unification_kind_t, bool, bool);
> -static tree copy_template_args (tree);
> static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
> static void tsubst_each_template_parm_constraints (tree, tree,
> tsubst_flags_t);
> static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
> @@ -4736,7 +4735,7 @@ process_template_parm (tree list, location_t parm_loc,
> tree parm,
> /* Build requirements for the type/template parameter.
> This must be done after SET_DECL_TEMPLATE_PARM_P or
> process_template_parm could fail. */
> - tree reqs = finish_shorthand_constraint (parm, constr);
> + tree reqs = finish_shorthand_constraint (parm, constr, is_non_type);
>
> decl = pushdecl (decl);
> if (!is_non_type)
> @@ -8831,7 +8830,7 @@ convert_template_argument (tree parm,
> else if (tree a = type_uses_auto (t))
> {
> t = do_auto_deduction (t, arg, a, complain, adc_unify, args,
> - LOOKUP_IMPLICIT, /*tmpl=*/in_decl);
> + LOOKUP_IMPLICIT);
> if (t == error_mark_node)
> return error_mark_node;
> }
> @@ -13972,7 +13971,7 @@ make_argument_pack (tree vec)
> /* Return an exact copy of template args T that can be modified
> independently. */
>
> -static tree
> +tree
> copy_template_args (tree t)
> {
> if (t == error_mark_node)
> @@ -25049,8 +25048,7 @@ unify (tree tparms, tree targs, tree parm, tree arg,
> int strict,
> {
> tparm = do_auto_deduction (tparm, arg, a,
> complain, adc_unify, targs,
> - LOOKUP_NORMAL,
> - TPARMS_PRIMARY_TEMPLATE (tparms));
> + LOOKUP_NORMAL);
> if (tparm == error_mark_node)
> return 1;
> }
> @@ -29572,8 +29570,7 @@ make_constrained_placeholder_type (tree type, tree
> con, tree args)
> /* Our canonical type depends on the constraint. */
> TYPE_CANONICAL (type) = canonical_type_parameter (type);
>
> - /* Attach the constraint to the type declaration. */
> - return TYPE_NAME (type);
> + return type;
> }
>
> /* Make a "constrained auto" type-specifier. */
> @@ -31193,10 +31190,7 @@ unparenthesized_id_or_class_member_access_p (tree
> init)
> adc_requirement contexts to communicate the necessary template arguments
> to satisfaction. OUTER_TARGS is ignored in other contexts.
>
> - Additionally for adc_unify contexts TMPL is the template for which TYPE
> - is a template parameter type.
> -
> - For partial-concept-ids, extra args from OUTER_TARGS, TMPL and the current
> + For partial-concept-ids, extra args from OUTER_TARGS and the current
> scope may be appended to the list of deduced template arguments prior to
> determining constraint satisfaction as appropriate. */
>
> @@ -31205,8 +31199,7 @@ do_auto_deduction (tree type, tree init, tree
> auto_node,
> tsubst_flags_t complain /* = tf_warning_or_error */,
> auto_deduction_context context /* = adc_unspecified */,
> tree outer_targs /* = NULL_TREE */,
> - int flags /* = LOOKUP_NORMAL */,
> - tree tmpl /* = NULL_TREE */)
> + int flags /* = LOOKUP_NORMAL */)
> {
> if (type == error_mark_node || init == error_mark_node)
> return error_mark_node;
> @@ -31354,10 +31347,13 @@ do_auto_deduction (tree type, tree init, tree
> auto_node,
> }
>
> /* Check any placeholder constraints against the deduced type. */
> - if (processing_template_decl && context == adc_unify)
> - /* Constraints will be checked after deduction. */;
> - else if (tree constr = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS
> (auto_node)))
> + if (tree constr = NON_ERROR (PLACEHOLDER_TYPE_CONSTRAINTS (auto_node)))
> {
> + /* Constrained auto NTTPs get replaced by an ordinary auto once
> processed
> + and their constraints get associated with the corresponding template,
> + so we shouldn't see any during coercion/deduction. */
> + gcc_checking_assert (context != adc_unify);
> +
> if (processing_template_decl)
> {
> gcc_checking_assert (context == adc_variable_type
> @@ -31389,10 +31385,7 @@ do_auto_deduction (tree type, tree init, tree
> auto_node,
> }
> }
>
> - tree full_targs = outer_targs;
> - if (context == adc_unify && tmpl)
> - full_targs = add_outermost_template_args (tmpl, full_targs);
> - full_targs = add_to_template_args (full_targs, targs);
> + tree full_targs = add_to_template_args (outer_targs, targs);
>
> /* HACK: Compensate for callers not always communicating all levels of
> outer template arguments by filling in the outermost missing levels
> @@ -31417,8 +31410,7 @@ do_auto_deduction (tree type, tree init, tree
> auto_node,
> auto_diagnostic_group d;
> switch (context)
> {
> - case adc_unspecified:
> - case adc_unify:
> + default:
> error_at (loc, "placeholder constraints not satisfied");
> break;
> case adc_variable_type:
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-placeholder12.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-placeholder12.C
> index 22f0ac5e26a..edca8f7199b 100644
> --- a/gcc/testsuite/g++.dg/cpp2a/concepts-placeholder12.C
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-placeholder12.C
> @@ -22,8 +22,8 @@ int main() {
> A<false>::g(X<0>{}); // { dg-error "no match|constraints" }
>
> bool v1 = A<true>::value<0>;
> - bool v2 = A<false>::value<0>; // { dg-error "constraints" }
> + bool v2 = A<false>::value<0>; // { dg-error "invalid variable template" }
>
> A<true>::D<0> d1;
> - A<false>::D<0> d2; // { dg-error "constraints" }
> + A<false>::D<0> d2; // { dg-error "constraint failure" }
> }
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-pr97093.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-pr97093.C
> index d662552614e..355f195ac0a 100644
> --- a/gcc/testsuite/g++.dg/cpp2a/concepts-pr97093.C
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-pr97093.C
> @@ -29,4 +29,4 @@ struct pc
> };
>
> constexpr auto cc = pc {};
> -constexpr auto mmcc = m <cc> {}; // { dg-error "not satisfied" }
> +constexpr auto mmcc = m <cc> {}; // { dg-error "constraint failure" }
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm12.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm12.C
> new file mode 100644
> index 00000000000..f2c260adbdd
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm12.C
> @@ -0,0 +1,22 @@
> +// { dg-do compile { target c++20 } }
> +// Verify partial ordering with respect to associated constraints
> +// works in the presence of constrained NTTPs.
> +
> +template<class T> concept C = true;
> +
> +template<class T> concept D = C<T> && true;
> +
> +template<C auto V> void f() = delete;
> +template<D auto V> void f(); // more constrained
> +
> +template<C auto V> void g();
> +template<C auto V> void g(); // redeclaration
> +
> +template<C auto V> struct A;
> +template<D auto V> struct A<V> { };
> +
> +int main() {
> + f<0>();
> + g<0>();
> + A<0> a;
> +}
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm2.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm2.C
> index 3bb2f576a87..a9b15dabc0c 100644
> --- a/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm2.C
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm2.C
> @@ -12,4 +12,4 @@ template<Int T = char> struct S1 { };
> template<Int auto X = false> struct S2 { };
>
> S1<> s1; // { dg-error "constraint failure" }
> -S2<> s2; // { dg-error "placeholder constraints not satisfied" }
> +S2<> s2; // { dg-error "constraint failure" }
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm6.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm6.C
> index c7d9964f738..04c2e1c70ba 100644
> --- a/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm6.C
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-template-parm6.C
> @@ -40,5 +40,5 @@ template<Int... Ts> struct S3 { }; // requires (C<Ts> &&
> ...)
> S3<int, int, char> x0; // { dg-error "template constraint failure" }
>
> template<Int auto... Xs> struct S4 { }; // requires (C<X> && ...) with each
> X deduced
> -S4<0, 1, 2, 'a'> x1; // { dg-error "placeholder constraints not satisfied" }
> +S4<0, 1, 2, 'a'> x1; // { dg-error "template constraint failure" }
>
> --
> 2.47.0.86.g15030f9556
>
>
