Fix PR c++/60065.

PR c++/60065
        * parser.c (cp_parser_parameter_declaration_list): Use
        current_template_parms and scope check as predicate for
        inspecting current function template parameter list length
        rather than num_template_parameter_lists.

	PR c++/60065
	* g++.dg/cpp1y/pr60065.C: New testcase.
---
 gcc/cp/parser.c                      | 20 +++++++++++++++++---
 gcc/testsuite/g++.dg/cpp1y/pr60065.C |  8 ++++++++
 2 files changed, 25 insertions(+), 3 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/cpp1y/pr60065.C

On 02/19/2014 10:00 PM, Adam Butcher wrote:
> +  if (current_template_parms)
> +    {
> +      cp_binding_level *maybe_tmpl_scope = current_binding_level->level_chain;
> +      while (maybe_tmpl_scope && maybe_tmpl_scope->kind == sk_class)
> +	maybe_tmpl_scope = maybe_tmpl_scope->level_chain;
> +      if (maybe_tmpl_scope && maybe_tmpl_scope->kind == sk_template_parms)
> +	declaring_template_p = true;
> +    }

Won't this return true for a member function of a class template?  i.e.

template <class T>
struct A {
   void f(auto x);
};

Why doesn't num_template_parameter_lists work as a predicate here?

Jason

On 2014-02-20 16:18, Jason Merrill wrote:
> On 02/19/2014 10:00 PM, Adam Butcher wrote:
>> +  if (current_template_parms)
>> +    {
>> +      cp_binding_level *maybe_tmpl_scope = 
>> current_binding_level->level_chain;
>> +      while (maybe_tmpl_scope && maybe_tmpl_scope->kind == 
>> sk_class)
>> +	maybe_tmpl_scope = maybe_tmpl_scope->level_chain;
>> +      if (maybe_tmpl_scope && maybe_tmpl_scope->kind == 
>> sk_template_parms)
>> +	declaring_template_p = true;
>> +    }
>
> Won't this return true for a member function of a class template?  
> i.e.
>
> template <class T>
> struct A {
>   void f(auto x);
> };
>
Yes I think you're right.  I was thinking about that yesterday but 
hadn't had a chance to get to my PC to check or post a reply.  The 
intent is to deal with out-of-line implicit member templates.  But I 
think the issue is more complex; and I think it may be true for the 
synthesize code as well as this new code.

A class template with an out-of-line generic function definition will 
give the same issue I think:

   template <typename T>
   void A<T>::f(auto x) {}  // should inject a new list

It needs to know when to extend a function template parameter list and 
when to insert a new one.  Another case:

   struct B
   {
     template <int N>
     void f(auto x);
   };

   template <int N>
   void B::f(auto x) {}  // should extend existing inner list

And also:

   template <typename T>
   struct C
   {
     template <int N>
     void f(auto x);
   };

   template <typename T>
   template <int N>
   void C<T>::f(auto x) {}  // should extend existing inner list

Obviously there is an arbitrary depth of class and class templates.

Need to look further into it when I get some more time.


Once it's resolved I think it'd be useful to create a new function to 
determine this rather than doing the scope walk in a number of places.  
Something like 'templ_parm_scope_for_fn_being_declared' --- or hopefully 
some more elegant name!


> Why doesn't num_template_parameter_lists work as a predicate here?
>
It works in the lambda case as it is updated there, but for generic 
functions I think the following prevents it:

   cp/parser.c:17063:

               /* Inside the function parameter list, surrounding
                  template-parameter-lists do not apply.  */
               saved_num_template_parameter_lists
                 = parser->num_template_parameter_lists;
               parser->num_template_parameter_lists = 0;

               begin_scope (sk_function_parms, NULL_TREE);

               /* Parse the parameter-declaration-clause.  */
               params = cp_parser_parameter_declaration_clause (parser);

               /* Restore saved template parameter lists accounting for 
implicit
                  template parameters.  */
               parser->num_template_parameter_lists
                 += saved_num_template_parameter_lists;


Cheers,
Adam

On 02/21/2014 03:19 AM, Adam Butcher wrote:
> A class template with an out-of-line generic function definition will
> give the same issue I think:
>
>    template <typename T>
>    void A<T>::f(auto x) {}  // should inject a new list

Right.  template_class_depth should be useful here.  This is basically 
the same question as whether a particular member function is a primary 
template (member template) or not, but figuring it out in the middle of 
the parameter list complicates things.

> Once it's resolved I think it'd be useful to create a new function to
> determine this rather than doing the scope walk in a number of places.
> Something like 'templ_parm_scope_for_fn_being_declared' --- or hopefully
> some more elegant name!

Right.

>> Why doesn't num_template_parameter_lists work as a predicate here?
>>
> It works in the lambda case as it is updated there, but for generic
> functions I think the following prevents it:
>
>    cp/parser.c:17063:
>
>                /* Inside the function parameter list, surrounding
>                   template-parameter-lists do not apply.  */
>                saved_num_template_parameter_lists
>                  = parser->num_template_parameter_lists;
>                parser->num_template_parameter_lists = 0;

Hmm, I wonder what that's for?  What breaks when you remove it? :)

Jason

On 2014-02-21 15:49, Jason Merrill wrote:
> On 02/21/2014 03:19 AM, Adam Butcher wrote:
>> Jason Merrill wrote:
>>> Why doesn't num_template_parameter_lists work as a predicate here?
>>>
>> It works in the lambda case as it is updated there, but for generic
>> functions I think the following prevents it:
>>
>>    cp/parser.c:17063:
>
> Hmm, I wonder what that's for?  What breaks when you remove it? :)
>
Nothing (according to the g++.dg testsuite at least).  It's been there 
since I started looking at GCC so I assumed that it was needed for 
something.  Having removed it I should be able use a 
num_template_parameter_lists and template_class_depth as you suggested 
to solve this issue (hopefully without the need of a scope walk).

Cheers,
Adam