Bug 32638 - Wrong selection of field in inner class when outer class and super class have a relevant filed named the same
Summary: Wrong selection of field in inner class when outer class and super class have...
Status: UNCONFIRMED
Alias: None
Product: gcc
Classification: Unclassified
Component: java (show other bugs)
Version: 4.1.2
: P3 normal
Target Milestone: ---
Assignee: Not yet assigned to anyone
URL:
Keywords:
Depends on:
Blocks:
 
Reported: 2007-07-05 17:12 UTC by Mark Wielaard
Modified: 2007-07-05 17:31 UTC (History)
3 users (show)

See Also:
Host:
Target:
Build:
Known to work:
Known to fail:
Last reconfirmed:


Attachments

Note You need to log in before you can comment on or make changes to this bug.
Description Mark Wielaard 2007-07-05 17:12:21 UTC
The following program should print true, but prints false when compiled with gcj -C because the wrong field o is selected in the anonymous inner class (the protected field named o in the super class is more specific than the field o in the enclosing method).

public class t
{
  static abstract class a
  {
    protected Object o = new Object();
    abstract void print(Object input);
  }

  static class b
  {
    void m()
    {
      final Object o = new Object();
      a x = new a()
        {
          void print(Object input)
          {
            System.out.println(o != input);
          }
        };
      x.print(o);
    }
  }

  public static void main(String[] args)
  {
    new b().m();
  }
}

Since this is pretty hard to see why this code works/doesn't work in the first place (the super class could be in a completely different file and the field in the outer class certainly looks like it would be the one that is used in the inner class) a warning for this kind of usage would be nice.

gcj (GCC) 4.1.2 20070626 (Red Hat 4.1.2-13)
Comment 1 Tom Tromey 2007-07-05 17:31:17 UTC
I tried this with svn trunk and got 'false'.
If there is a bug here it is in ecj, not gcj.

I'm not sure I agree with your interpretation here.
I don't see how specificity applies.  Isn't that term only used
for overload resolution?  It's been a while since I was completely
familiar with the JLS, though ... where are you reading?

IMO the JLS could be clearer here, but I believe the local 'o'
shadows the field a.o.  See:

http://java.sun.com/docs/books/jls/third_edition/html/names.html#34133

Anyway, I suggest filing against ecj or perhaps the JDK for resolution.


Comment 2 Mark Wielaard 2007-07-05 18:34:41 UTC
Subject: Re:  Wrong selection of field in inner class when
	outer class and super class have a relevant filed named the same

> ------- Comment #1 from tromey at gcc dot gnu dot org  2007-07-05 17:31 -------
> I tried this with svn trunk and got 'false'.
> If there is a bug here it is in ecj, not gcj.

Wow, that is interesting. Which ecj version are you using?
v_686_R32x, 3.2.2 release gives "true".

> I'm not sure I agree with your interpretation here.
> I don't see how specificity applies.  Isn't that term only used
> for overload resolution?  It's been a while since I was completely
> familiar with the JLS, though ... where are you reading?

I am using the completely wrong terms, sorry about that. I got the idea
from JLS second edition 8.3 Field Declarations (but admit to not have
had it handy when I filed the bug report, it actually took me some time
to find it back):
http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#40898

         If the class declares a field with a certain name, then the
        declaration of that field is said to hide any and all accessible
        declarations of fields with the same name in superclasses, and
        superinterfaces of the class. The field declaration also shadows
        (ยง6.3.1) declarations of any accessible fields in enclosing
        classes or interfaces, and any local variables, formal method
        parameters, and exception handler parameters with the same name
        in any enclosing blocks.
        
         If a field declaration hides the declaration of another field,
        the two fields need not have the same type.
        
         A class inherits from its direct superclass and direct
        superinterfaces all the non-private fields of the superclass and
        superinterfaces that are both accessible to code in the class
        and not hidden by a declaration in the class.

Since it mentions that the field declaration shadows the local variables
of the enclosing block (the method) and not the enclosing class and that
it inherits the fields (which I take to mean also shadows) I believe my
interpretation is correct.

> IMO the JLS could be clearer here, but I believe the local 'o'
> shadows the field a.o.  See:
> 
> http://java.sun.com/docs/books/jls/third_edition/html/names.html#34133
> 
> Anyway, I suggest filing against ecj or perhaps the JDK for resolution.

Yeah, it certainly is confusing. I need all my language lawyer skills to
even defend my bug report :) All I really want is a big fat warning from
the compiler for this type of usage because it clearly is something that
takes a long debate to even see who is right and why.