Fix PR c++/60573

PR c++/60573
	* parser.c (synthesize_implicit_template_parm): Handle the fact that
	nested class member declarations erroneously appearing in an enclosing
	class contain an addition scope level for the class being defined.

	PR c++/60573
	* g++.dg/cpp1y/pr60573.C: New testcase.
---
 gcc/cp/parser.c                      | 18 ++++++++++++++++--
 gcc/testsuite/g++.dg/cpp1y/pr60573.C | 13 +++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/cpp1y/pr60573.C

On 03/18/2014 10:46 PM, Adam Butcher wrote:
> -	  while (scope->kind == sk_class
> -		 && !TYPE_BEING_DEFINED (scope->this_entity))

Does it work to just change TYPE_BEING_DEFINED to currently_open_class?

Jason

On 2014-03-24 17:23, Jason Merrill wrote:
> On 03/18/2014 10:46 PM, Adam Butcher wrote:
>> -	  while (scope->kind == sk_class
>> -		 && !TYPE_BEING_DEFINED (scope->this_entity))
>
> Does it work to just change TYPE_BEING_DEFINED to 
> currently_open_class?
>
No.  The object referred to by 'scope->this_entity' is the same for 
each of the two levels, so unless there's something else I can pass to 
'currently_open_class', the result will be equivalent; the issue is that 
the class being referred to *is* being defined, but I need to skip over 
the second class-scope for that type to arrive at the defining scope 
level.

Adam

On 03/18/2014 10:46 PM, Adam Butcher wrote:
> +	      if (TYPE_BEING_DEFINED (scope->this_entity))
> +		if (scope->level_chain == 0
> +		    || scope->this_entity != scope->level_chain->this_entity)
> +		  break;

I don't think this is an adequate test; if you have another class 
wrapping B, you'll have two levels of context pushed for the declarator, 
so the this_entities will compare unequal.  I think we need some way to 
designate a scope that actually corresponds to a class-specifier.

Jason

On 2014-03-25 15:48, Jason Merrill wrote:
> On 03/18/2014 10:46 PM, Adam Butcher wrote:
>> +	      if (TYPE_BEING_DEFINED (scope->this_entity))
>> +		if (scope->level_chain == 0
>> +		    || scope->this_entity != scope->level_chain->this_entity)
>> +		  break;
>
> I don't think this is an adequate test; if you have another class
> wrapping B, you'll have two levels of context pushed for the
> declarator, so the this_entities will compare unequal.  I think we
> need some way to designate a scope that actually corresponds to a
> class-specifier.
>
I don't follow.  Are you suggesting a case like the following?

   struct A
   {
     struct X
     {
       struct B
       {
         void foo(auto);
       };
     };

     void X::B::foo(auto) {}  // { dg-error "cannot define" }
   };

If so, it is handled.  The code you are referring to is within a 
level_chain traversal loop so handles arbitrary levels of pushed 
context.  The end result is the same though; we arrive at an 'A::' scope 
that is not the defining class scope but has the same 'this_entity' as 
it (so TYPE_BEING_DEFINED returns true).  The scope chain is as if the 
following was used to declare it:

   struct A
   {
     ...
     void A::X::B::foo(auto);
   };

It is the two levels of 'A' entity scopes that caused the ICE due the 
previous version of the loop stopping to inject the template parameter 
list between the 'A::' and the 'X::', rather than unwinding back to the 
scope defining 'A'.

Apologies if I've completely misunderstood your point here.  I've got a 
feeling that I may have.

Adam

On 03/25/2014 03:48 PM, Adam Butcher wrote:
> I don't follow.  Are you suggesting a case like the following?
>
>    struct A
>    {
>      struct X
>      {
>        struct B
>        {
>          void foo(auto);
>        };
>      };
>
>      void X::B::foo(auto) {}  // { dg-error "cannot define" }
>    };

I meant

   struct A
   {
     struct X
     {
       struct B
       {
         void foo(auto);
       };

       void B::foo(auto) {}  // { dg-error "cannot define" }
     };
   };

Here we push both A and X for the declarator.  When we get to the pushed 
X, we see that the enclosing scope is A, so we break out of the loop and 
don't pop either of the pushed scopes.

Jason

On 2014-03-26 15:17, Jason Merrill wrote:
>
> I meant
>
>   struct A
>   {
>     struct X
>     {
>       struct B
>       {
>         void foo(auto);
>       };
>
>       void B::foo(auto) {}  // { dg-error "cannot define" }
>     };
>   };
>
> Here we push both A and X for the declarator.  When we get to the
> pushed X, we see that the enclosing scope is A, so we break out of 
> the
> loop and don't pop either of the pushed scopes.
>
Thought I was probably being dense!  :)  Yes, that will be broken with 
the current patch.  Continuing the loop based on TYPE_BEING_DEFINED 
might do the trick.  I'll try to have a look later.

Cheers,
Adam

On 2014-03-25 15:48, Jason Merrill wrote:
>
> I think we need some way to designate a scope that actually
> corresponds to a class-specifier.
>
Agreed.  I'll look into it.

Adam