From: Jason Merrill <jason@redhat.com>
To: Patrick Palka <ppalka@redhat.com>, gcc-patches@gcc.gnu.org
Subject: Re: [PATCH] c++: dependence of constrained memfn from current inst [PR105842]
Date: Tue, 12 Jul 2022 12:05:08 -0400 [thread overview]
Message-ID: <70652dd1-1600-f4a9-1f64-3a5779d72439@redhat.com> (raw)
In-Reply-To: <20220711133304.4107913-1-ppalka@redhat.com>
On 7/11/22 09:33, Patrick Palka wrote:
> Here we incorrectly deem the calls to func1, func2 and tmpl2 as
> ambiguous ahead of time ultimately because we mishandle dependence
> of a constrained member function from the current instantiation.
>
> In type_dependent_expression_p, we consider the dependence of a
> TEMPLATE_DECL's constraints (via uses_outer_template_parms), but
> neglect to do the same for a FUNCTION_DECL such as func1.
>
> And in satisfy_declaration_constraints, we give up if _any_ template
> argument is dependent, but for non-dependent member functions from
> the current instantiation such as func2 and tmpl2, we can and must
> check constraints as long as the innermost arguments aren't dependent.
>
> Tested on x86_64-pc-linux-gnu, does this look OK for trunk/12?
>
> PR c++/105842
>
> gcc/cp/ChangeLog:
>
> * constraint.cc (satisfy_declaration_constraints): Refine
> early exit test for argument dependence.
> * cp-tree.h (uses_outer_template_parms_in_constraints): Declare.
> * pt.cc (template_class_depth): Handle TI_TEMPLATE being a
> FIELD_DECL.
> (usse_outer_template_parms): Factor out constraint dependence
> check to ...
> (uses_outer_template_parms_in_constraints): ... here.
> (type_dependent_expression_p): Use it for FUNCTION_DECL.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/cpp2a/concepts-memtmpl6.C: New test.
> ---
> gcc/cp/constraint.cc | 20 +++++++----
> gcc/cp/cp-tree.h | 1 +
> gcc/cp/pt.cc | 34 ++++++++++++++++---
> .../g++.dg/cpp2a/concepts-memtmpl6.C | 34 +++++++++++++++++++
> 4 files changed, 79 insertions(+), 10 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/cpp2a/concepts-memtmpl6.C
>
> diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
> index 591155cee22..99b97d24eae 100644
> --- a/gcc/cp/constraint.cc
> +++ b/gcc/cp/constraint.cc
> @@ -3176,9 +3176,13 @@ satisfy_declaration_constraints (tree t, sat_info info)
> args = regen_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 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;
>
> /* Get the normalized constraints. */
> @@ -3240,9 +3244,13 @@ satisfy_declaration_constraints (tree t, tree args, sat_info info)
> else
> 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 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;
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 2fde4f83b41..bec98aa2ac3 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -7297,6 +7297,7 @@ extern tree lookup_template_function (tree, tree);
> extern tree lookup_template_variable (tree, tree);
> extern bool uses_template_parms (tree);
> extern bool uses_template_parms_level (tree, int);
> +extern bool uses_outer_template_parms_in_constraints (tree);
> extern bool in_template_function (void);
> extern bool need_generic_capture (void);
> extern tree instantiate_class_template (tree);
> diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
> index 59ee50c152d..de5d3a5cd78 100644
> --- a/gcc/cp/pt.cc
> +++ b/gcc/cp/pt.cc
> @@ -391,7 +391,9 @@ template_class_depth (tree type)
> {
> tree tinfo = get_template_info (type);
>
> - if (tinfo && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
> + if (tinfo
> + && TREE_CODE (TI_TEMPLATE (tinfo)) == TEMPLATE_DECL
> + && PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo))
> && uses_template_parms (INNERMOST_TEMPLATE_ARGS (TI_ARGS (tinfo))))
> ++depth;
>
> @@ -11011,7 +11013,7 @@ uses_template_parms_level (tree t, int level)
> /* Returns true if the signature of DECL depends on any template parameter from
> its enclosing class. */
>
> -bool
> +static bool
> uses_outer_template_parms (tree decl)
> {
> int depth = template_class_depth (CP_DECL_CONTEXT (decl));
> @@ -11042,11 +11044,27 @@ uses_outer_template_parms (tree decl)
> return true;
> }
> }
> + if (uses_outer_template_parms_in_constraints (decl))
> + return true;
> + return false;
> +}
> +
> +/* Returns true if the constraints of DECL depend on any template parameters
> + from its enclosing scope. */
> +
> +bool
> +uses_outer_template_parms_in_constraints (tree decl)
> +{
> tree ci = get_constraints (decl);
> if (ci)
> ci = CI_ASSOCIATED_CONSTRAINTS (ci);
> - if (ci && for_each_template_parm (ci, template_parm_outer_level,
> - &depth, NULL, /*nondeduced*/true))
> + if (!ci)
> + return false;
> + int depth = template_class_depth (CP_DECL_CONTEXT (decl));
> + if (depth == 0)
> + return false;
> + if (for_each_template_parm (ci, template_parm_outer_level,
> + &depth, NULL, /*nondeduced*/true))
> return true;
> return false;
> }
> @@ -28103,6 +28121,14 @@ type_dependent_expression_p (tree expression)
> return false;
> }
>
> + /* Otherwise, its constraints could still depend on outer template parameters
> + from its (dependent) scope. */
> + if (TREE_CODE (expression) == FUNCTION_DECL
> + /* Check this sufficient condition first, as a minor optimization. */
> + && !dependent_type_p (TREE_TYPE (expression))
> + && uses_outer_template_parms_in_constraints (expression))
> + return true;
Hmm, the call to dependent_type_p seemed questionable given how we've
been avoiding it just above, but I guess at this point we've established
that we're looking at a member of a dependent class, so it makes sense
to start treating undeduced auto fns as dependent here. Please add a
comment to that effect.
OK with that change.
> +
> /* Always dependent, on the number of arguments if nothing else. */
> if (TREE_CODE (expression) == EXPR_PACK_EXPANSION)
> return true;
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-memtmpl6.C b/gcc/testsuite/g++.dg/cpp2a/concepts-memtmpl6.C
> new file mode 100644
> index 00000000000..0e09ae6ed4c
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-memtmpl6.C
> @@ -0,0 +1,34 @@
> +// PR c++/105842
> +// { dg-do compile { target c++20 } }
> +
> +template<class T>
> +struct S {
> + static void func1() requires __is_same(T, int);
> + static void func1() requires (!__is_same(T, int));
> +
> + static void func2() requires false && false;
> + static void func2() requires false;
> +
> + template<class...> static void tmpl1() requires __is_same(T, int);
> + template<class...> static void tmpl1() requires (!__is_same(T, int));
> +
> + template<class... Us> static void tmpl2() requires (sizeof...(Us) == 1);
> + template<class... Us> static void tmpl2() requires (sizeof...(Us) == 2);
> +
> + static void foo() {
> + // Both calls resolve to the first overload at instantiation time.
> + func1();
> + tmpl1();
> + }
> +
> + static void bar() {
> + // We can check and reject both calls ahead of time since the functions'
> + // constraints don't depend on outer template parameters.
> + func2(); // { dg-error "no match" }
> + tmpl2(); // { dg-error "no match" }
> + }
> +};
> +
> +int main() {
> + S<int>::foo();
> +}
prev parent reply other threads:[~2022-07-12 16:05 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2022-07-11 13:33 Patrick Palka
2022-07-12 16:05 ` Jason Merrill [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=70652dd1-1600-f4a9-1f64-3a5779d72439@redhat.com \
--to=jason@redhat.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=ppalka@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).