Assign to static final field of same name

Question

To distinguish between an instance field and a local variable of the same name we can qualify access to the field with the prefix this.:

class Test {
    public final Foo x;

    public Test(Foo x) {
        this.x = x;
    }
}

I'm trying to do the same thing in a static context by qualifying access with the class name:

import java.util.*;

class Test {
    public static final Map<String,Object> map;

    static {
        Map<String,Object> map = new HashMap<>();

        // ... 
        // assume I fill the map with useful data here
        // ...

        // now I want to freeze it and assign it to the field
        Test.map = Collections.unmodifiableMap(map);
    }
}

The compiler wants nothing to do with this code. I have several variables like this and for all of them it keeps yelling: "cannot assign a value to final variable". If I don't assign to it, it complains "variable not initialized" instead. If I assign to the static field at the beginning and try to make the map unmodifiable afterwards, it complains "variable might already have been assigned". It's not happy with anything.

Is this a flaw in the language, or a bug in the compiler? What's the best way to squash the compiler into doing as its told?

Answer 1

The easiest way to solve is as follows:

import java.util.*;

class Test {
    public static final Map<String,Object> map;

    static {
        Map<String,Object> contents = new HashMap<>();

        map = Collections.unmodifiableMap(contents);
    }
}

Somehow it seems that if you qualify the constant with the class name in Java 8, the compiler won't have it.

Update

After some more digging, it seems that the Java Language Specification explicitly states that the simple (unqualified) name needs to be used for the assignment of final fields (highlighting mine):

For every access of a local variable or blank final field x, x must be definitely assigned before the access, or a compile-time error occurs.

Similarly, every blank final variable must be assigned at most once; it must be definitely unassigned when an assignment to it occurs.

Such an assignment is defined to occur if and only if either the simple name of the variable (or, for a field, its simple name qualified by this) occurs on the left hand side of an assignment operator.