RFR: 8343580: Type error with inner classes of generic classes in functions generic by outer [v2]

[Maurizio Cimadamore]

On Thu, 22 May 2025 09:10:39 GMT, Aggelos Biboudis <abimpoudis at openjdk.org> wrote:

>> javac determines erroneously that `getter` has a raw type (`G.Getter`). The type of `getter` is deduced as the raw type `Getters<T>.Getter` by javac. Thus, the `Object` in the following example. The question is whether it should be treated as raw or not in the scenario where the qualifying type *is* a type parameter, as in `G.Getter`. In this case `Getter` is inherited from the supertype `Getters<T>`:
>> 
>> 
>> static abstract class Getters<T> {
>>     abstract class Getter {
>>         abstract T get();
>>     }
>> }
>> 
>> static class Usage<T, G extends Getters<T>> {
>>     public T test(G.Getter getter) {
>>         return getter.get(); // incompatible types: Object cannot be converted to T
>>     }
>> }
>> 
>> 
>> It seems that this is a compiler bug. According to 4.8 Raw Types a “rare” type occurs when the inner is a partially raw type but the definition of Getter doesn’t take any type variables, so this is not a case of a "rare" type. `G.Getter` describes a type with a qualifying type being a type parameter which is not raw and moreover there is an instantiation of its bound. Simply not looking into the bounds of `G` seems like a compiler bug.
>
> Aggelos Biboudis has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Address review

src/jdk.compiler/share/classes/com/sun/tools/javac/code/Type.java line 1155:

> 1153:             if (allparams_field == null) {
> 1154:                 Type enclosingType = getEnclosingType();
> 1155:                 while (enclosingType.hasTag(TYPEVAR)) {

Note we can also use `Types::skipTypeVars` here (which brings up the question whether we should stop at regular tvars, or also keep going for captured tvars)

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/25346#discussion_r2104304045