* [PATCH] c++: dependence of constrained memfn from current inst [PR105842]
@ 2022-07-11 13:33 Patrick Palka
2022-07-12 16:05 ` Jason Merrill
0 siblings, 1 reply; 2+ messages in thread
From: Patrick Palka @ 2022-07-11 13:33 UTC (permalink / raw)
To: gcc-patches
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;
+
/* 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();
+}
--
2.37.0.3.g30cc8d0f14
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [PATCH] c++: dependence of constrained memfn from current inst [PR105842]
2022-07-11 13:33 [PATCH] c++: dependence of constrained memfn from current inst [PR105842] Patrick Palka
@ 2022-07-12 16:05 ` Jason Merrill
0 siblings, 0 replies; 2+ messages in thread
From: Jason Merrill @ 2022-07-12 16:05 UTC (permalink / raw)
To: Patrick Palka, gcc-patches
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();
> +}
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2022-07-12 16:05 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-07-11 13:33 [PATCH] c++: dependence of constrained memfn from current inst [PR105842] Patrick Palka
2022-07-12 16:05 ` Jason Merrill
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).