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;
