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 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
  

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();
> +}