constant references in enums

[Maurizio Cimadamore]

My bad - the section you quote refers to a different scenario:

enum Foo {
     BAR;

    static int e = 0; //non constant
    final static int ce = 42; //constant

    //8.9.2:  It is a compile-time error to reference a static field of 
an enum type from...

    // instance variable initializer expression
    int field1 = e;
    int field2 = ce;

    // instance initializers
    {
     int i1 = e;
     int i2 = ce;
    }

    //constructors
    Foo() {
     int i1 = e;
     int i2 = ce;
    }
}

So, in your case the access is occurring from another *static* variable 
initializer, so 8.9.2 does not apply. Which I think means that the same 
rules for ordinary classes apply - meaning that forward reference for 
statics is only allowed with fully qualified name. So it is consistent. 
And it is not a bug. Let's wait from some spec guru to chime in.

Maurizio

On 22/01/16 00:41, Maurizio Cimadamore wrote:
> If it helps - this is rejected too:
>
> class FooE {
>         static FooE fe = new FooE(FOOC);  // ?? error: illegal forward 
> reference
>         FooE(int k) {}
>         public static final int FOOC = 42;  // a constant variable
>     }
>
> But - this isn't:
>
> class FooE {
>         static FooE fe = new FooE(*FooE.*FOOC);  // ?? error: illegal 
> forward reference
>         FooE(int k) {}
>         public static final int FOOC = 42;  // a constant variable
>         // look, JLS 8.9.2 says "...unless the field is a constant 
> variable"
>     }
>
> And I know this is not a bug - i.e. the spec says that fully qualified 
> names are allowed to forward references (see 8.3.3).
>
> So, I'm assuming that, since javac desugars away enums at parsing time 
> (by translating them into classes similar to the one above), it ends 
> up generating illegal code in your specific case. Or maybe the spec 
> should be rectified to do something consistent in both cases.
>
> Btw - if you add 'FooE.' your examples compiles too :-)
>
> Maurizio
>
> On 22/01/16 00:16, John Rose wrote:
>> enum FooE {
>>          FOOV(FOOC);  // ?? error: illegal forward reference
>>          FooE(int k) {}
>>          public static final int FOOC = 42;  // a constant variable
>>          // look, JLS 8.9.2 says "...unless the field is a constant variable"
>>      }
>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.openjdk.java.net/pipermail/compiler-dev/attachments/20160122/1a7a57cc/attachment.html>