public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc r13-1687] c++: dependence of constrained memfn from current inst [PR105842]
@ 2022-07-13 18:03 Patrick Palka
0 siblings, 0 replies; only message in thread
From: Patrick Palka @ 2022-07-13 18:03 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:f07778f6f92111aa0abfd0f669b148a0bda537a9
commit r13-1687-gf07778f6f92111aa0abfd0f669b148a0bda537a9
Author: Patrick Palka <ppalka@redhat.com>
Date: Wed Jul 13 14:01:28 2022 -0400
c++: dependence of constrained memfn from current inst [PR105842]
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 already consider dependence of a
TEMPLATE_DECL's constraints (via uses_outer_template_parms), but
neglect to do the same for a FUNCTION_DECL (such as that for 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.
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
test into ...
(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.
Diff:
---
gcc/cp/constraint.cc | 22 +++++++++++----
gcc/cp/cp-tree.h | 1 +
gcc/cp/pt.cc | 39 ++++++++++++++++++++++----
gcc/testsuite/g++.dg/cpp2a/concepts-memtmpl6.C | 34 ++++++++++++++++++++++
4 files changed, 84 insertions(+), 12 deletions(-)
diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
index 591155cee22..f2137eb7aa1 100644
--- a/gcc/cp/constraint.cc
+++ b/gcc/cp/constraint.cc
@@ -3176,9 +3176,15 @@ 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)
+ && ((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. */
@@ -3240,9 +3246,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..da00ce1301a 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,13 +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))
- return true;
- return false;
+ if (!ci)
+ return false;
+ int depth = template_class_depth (CP_DECL_CONTEXT (decl));
+ if (depth == 0)
+ return false;
+ return for_each_template_parm (ci, template_parm_outer_level,
+ &depth, NULL, /*nondeduced*/true);
}
/* Returns TRUE iff INST is an instantiation we don't need to do in an
@@ -28103,6 +28119,17 @@ 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
+ /* As an optimization, check this cheaper sufficient condition first.
+ (At this point we've established that we're looking at a member of
+ a dependent class, so it makes sense to start treating say undeduced
+ auto as dependent.) */
+ && !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();
+}
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-07-13 18:03 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-07-13 18:03 [gcc r13-1687] c++: dependence of constrained memfn from current inst [PR105842] Patrick Palka
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).