ecj ignores error "cannot select a static class from a parameterized type"

[nbauma109]

Here's a minimal demo:

public class OuterStaticNestedDemo<E> {
    class Outer {
        static class StaticNested {}
    }

    void qualifiedNew(Outer outer) {
        new Outer.StaticNested();
    }
}

When I compile with javac, it raises an error (using version 25 here, but it's the same for versions 11, 17 and 21) :

javac -g -source 25 -target 25 OuterStaticNestedDemo.java
OuterStaticNestedDemo.java:8: error: cannot select a static class from a parameterized type
        new Outer.StaticNested();
                 ^
1 error

When I compile with ecj, it compiles :

java -jar ecj-3.44.0.jar -g -source 25 -target 25 OuterStaticNestedDemo.java

Could you please fix to raise the same error as javac ?

[srikanth-sankaran]

I'll take a look. See also #4356

[nbauma109]

See also https://stackoverflow.com/q/79849237/8315843

[ShivanshhGargg]

Hi @nbauma109
This is actually not a bug. According to the Java Language Specification, you cannot reference a static nested class through a parameterized or instance type of an enclosing class. javac correctly rejects this.

ECJ currently allows it in this scenario, which is a known leniency in the compiler, not a deviation from the language spec.

What you can do to make ECJ behave like javac:

1. Make the outer class static if possible.
2. Reference the static nested class through the raw outer class type (e.g., OuterStaticNestedDemo<?>.Outer.StaticNested).

[srikanth-sankaran]

ECJ currently allows it in this scenario, which is a known leniency in the compiler, not a deviation from the language spec.

@ShivanshhGargg - May I ask on what basis you arrive at this conclusion ? Your message is self-contradictory. If javac correctly rejects some code by behaving according to the Java Language Specification, then Eclipse has no business being lenient. Either ECJ deviates from the spec or javac is incorrectly rejecting this - both cannot be simultaneously false!

[ShivanshhGargg]

Hi @srikanth-sankaran,

You’re right to challenge my earlier wording , thanks for the patience.

After revisiting the JLS more carefully, this behavior is a spec deviation in ECJ, not a permitted leniency.

The relevant rule is in JLS §6.5.5.1 (Simple Type Name), which disallows selecting a static member through a parameterized or instance-dependent type.

In this example: -

class OuterStaticNestedDemo {
class Outer {
static class StaticNested {}
}
}

1. Outer is a non-static inner class of OuterStaticNestedDemo.
2. Outer is an instance-dependent type.
3. As per JLS §6.5.5.1 static members cannot be selected through such types.
4. Therefore Outer.StaticNested is not a legal type name.

This explains why javac correctly rejects the code with: - "cannot select a static class from a parameterized type"

ECJ currently allows this access because it does not enforce the §6.5.5.1 restriction in this scenario, which makes this a spec compliance issue.

Accordingly, ECJ should be fixed to reject this construct to align with both the JLS and javac behavior.

Thanks again for prompting the clarification, it helped me pinpoint the exact rule involved.

[srikanth-sankaran]

Accordingly, ECJ should be fixed to reject this construct to align with both the JLS and javac behavior.

Thanks again for prompting the clarification, it helped me pinpoint the exact rule involved.

No problem. Are you willing to work on a PR ?

[ShivanshhGargg]

I’m new to open source and this would be my first PR. I’m eager to contribute and happy to help with the fix.

[srikanth-sankaran]

I’m new to open source and this would be my first PR. I’m eager to contribute and happy to help with the fix.

Good luck - I am happy to review and help you take it forward.

[ShivanshhGargg]

Hi, I tried reproducing this issue with the provided example, but I’m running into a fundamental compilation error before the behavior described can be observed.

Specifically, in the example:

class Outer {
    static class StaticNested {}
}

Outer is a non-static inner class, and Java does not allow declaring a static member type inside a non static inner class. The current ECJ reject this with an error like:

The member type StaticNested cannot be declared static; static types can only be declared in static or top level types

Because of this, compilation fails before reaching the qualified access (Outer.StaticNested) logic, so I’m unable to reproduce the reported ECJ vs javac difference using this snippet.

It looks like we may need a slightly different example to test the behavior around selecting a static nested type via an instance dependent or parameterized qualifying type.

[nbauma109]

Take this:

public class OuterStaticNestedDemo<E> {
    class Outer {
        static class StaticNested {}
    }

    void qualifiedNew(Outer outer) {
        new Outer.StaticNested();
    }
}

[ShivanshhGargg]

That is actually the snippet I’m using in my tests already.

[nbauma109]

Actually you must not compile it (because javac does not compile it) but give it as input to ecj compiler.

[ShivanshhGargg]

Thanks for the clarification. I am indeed passing this code directly as input to the ECJ batch compiler
java -jar org.eclipse.jdt.core.compiler.batch/target/org.eclipse.jdt.core.compiler.batch-3.45.0-SNAPSHOT.jar OuterStaticNestedDemo.java

I am not compiling it with javac.

However, ECJ rejects the example earlier with:

----------
1. ERROR in Eclipse/OuterStaticNestedDemo.java (at line 3)
        static class StaticNested {}
                     ^^^^^^^^^^^^
The member type StaticNested cannot be declared static; static types can only be declared in static or top level types
----------
1 problem (1 error)

It seems the example triggers a more fundamental structural error first, which prevents testing the intended scenario.

[nbauma109]

ok, so maybe the issue is already fixed in this SNAPSHOT version ? because I used 3.44.