WIP: handle inherited classes

Author: bishabosha

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1516,8 +1516,8 @@ object SymDenotations {
      *
      *  See tests/neg/i19619/Test.scala
      */
-    def javaTypeRef(using Context) =
-      TypeRef(maybeOwner.reachablePrefix.widen, symbol)
+    def javaTypeRef(from: Symbol)(using Context) =
+      TypeRef(from.reachablePrefix.widen, symbol)
 
     /** Like typeRef, but objects in the prefix are represented by their singleton type,
      *  this means we output `pre.O.member` rather than `pre.O$.this.member`.

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1552,7 +1552,7 @@ class Namer { typer: Typer =>
         if (cls.isRefinementClass) ptype
         else {
           val pt = checkClassType(ptype, parent.srcPos,
-              traitReq = parent ne parents.head, stablePrefixReq = true)
+              traitReq = parent ne parents.head, stablePrefixReq = !ctx.isJava)
           if (pt.derivesFrom(cls)) {
             val addendum = parent match {
               case Select(qual: Super, _) if Feature.migrateTo3 =>

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -463,8 +463,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   defDenot.symbol.namedType
                 }
                 else if (ctx.isJava && defDenot.symbol.isClass) {
-                  // in a java context a raw identifier to a class should have a widened prefix.
-                  defDenot.symbol.javaTypeRef
+                  val correctScope = if curOwner.is(ModuleClass) then curOwner.companionClass else curOwner
+                  val from =
+                    if correctScope != defDenot.symbol.maybeOwner then correctScope // inherited
+                    else defDenot.symbol.maybeOwner // defined in the same class
+                  defDenot.symbol.javaTypeRef(from)
                 } else {
                   val effectiveOwner =
                     if (curOwner.isTerm && defDenot.symbol.maybeOwner.isType)

tests/run/i19619/InnerClassSub.java

@@ -0,0 +1,54 @@
+// InnerClass.java
+
+package lib;
+
+public class InnerClassSub extends InnerClass {
+
+  public class InnerSub<U> extends Inner<U> {
+    public InnerSub(U innerField) {
+      super(innerField);
+    }
+  }
+
+  public class OuterSub<U> extends Outer<U> {
+    public OuterSub() {
+      super();
+    }
+  }
+
+  public <U> Inner<U> createInnerSub(U innerField) {
+    return new InnerSub<>(innerField);
+  }
+
+  public <U, V> Outer<U>.Nested<V> createNestedSub(U outerField, V innerField) {
+    OuterSub<U> outer = new OuterSub<>();
+    return outer.new Nested<>(outerField, innerField);
+  }
+
+  public <U> InnerClass.Inner<U> createInnerSub2(U innerField) {
+    return new InnerSub<>(innerField);
+  }
+
+  public <U, V> InnerClass.Outer<U>.Nested<V> createNestedSub2(U outerField, V innerField) {
+    OuterSub<U> outer = new OuterSub<>();
+    return outer.new Nested<>(outerField, innerField);
+  }
+
+  public static <U> InnerClass.Inner<U> createInnerStatic(U innerField) {
+    InnerClassSub innerClass = new InnerClassSub();
+    return innerClass.new Inner<>(innerField);
+  }
+
+  public static <U, V> InnerClass.Outer<U>.Nested<V> createNestedStatic(U outerField, V innerField) {
+    InnerClassSub innerClass = new InnerClassSub();
+    InnerClassSub.Outer<U> outer = innerClass.new Outer<>();
+    return outer.new Nested<>(outerField, innerField);
+  }
+
+  public static <U, V> void consumeNestedStatic(InnerClass.Outer<U>.Nested<V> nested) {
+  }
+
+  public static <U, V> void consumeNestedStatic2(Outer<U>.Nested<V> nested) {
+  }
+
+}

tests/run/i19619/Test.scala

@@ -1,6 +1,7 @@
 import lib.InnerClass
 import lib.InnerClassGen
 import lib.RawTypes
+import lib.InnerClassSub
 
 @main def Test =
 
@@ -40,3 +41,19 @@ import lib.RawTypes
 
     RawTypes.mii_Raw_Raw(cd_ii_Raw)
     RawTypes.mii_Raw_Raw2(cd_ii_Raw)
+
+  locally:
+    val ici: InnerClassSub = new InnerClassSub()
+    // val ici_inner1: ici.Inner[Long] = ici.createInner[Long](47L) // error
+    val ici_inner2: InnerClassSub#Inner[Long] = ici.createInnerSub[Long](47L)
+    val ici_inner2_2: InnerClass#Inner[Long] = ici.createInnerSub2[Long](47L)
+    val ici_inner3: InnerClass#Inner[Long] = InnerClassSub.createInnerStatic[Long](47L)
+
+    val ici_outer: InnerClassSub#Outer[Long] = new ici.Outer[Long]()
+    val ici_nested1: InnerClassSub#Outer[Long]#Nested[Int] = new ici_outer.Nested[Int](47L, 23)
+    val ici_nested2: InnerClassSub#Outer[Long]#Nested[Int] = ici.createNestedSub[Long, Int](47L, 23)
+    val ici_nested2_2: InnerClass#Outer[Long]#Nested[Int] = ici.createNestedSub2[Long, Int](47L, 23)
+    val ici_nested3: InnerClass#Outer[Long]#Nested[Int] = InnerClassSub.createNestedStatic[Long, Int](47L, 23)
+
+    InnerClass.consumeNestedStatic(ici_nested3)
+    InnerClass.consumeNestedStatic2(ici_nested3)