Migrate scala2 PR-7671

Author: changvvb

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

@@ -2,8 +2,8 @@ package dotty.tools.dotc
 package core
 
 import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps._
-import Denotations._
-import SymDenotations.LazyType, Names.Name, StdNames.nme
+import Denotations._, SymDenotations._
+import Names.Name, StdNames.nme
 import ast.untpd
 
 /** Extension methods for contexts where we want to keep the ctx.<methodName> syntax */
@@ -34,14 +34,51 @@ object ContextOps:
               if (elem.name == name) return elem.sym.denot // return self
             }
             val pre = ctx.owner.thisType
-            pre.findMember(name, pre, required, excluded)
+            if ctx.isJava then javaFindMember(name, pre, required, excluded)
+            else pre.findMember(name, pre, required, excluded)
           }
           else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
             ctx.owner.findMember(name, ctx.owner.thisType, required, excluded)
         else
           ctx.scope.denotsNamed(name).filterWithFlags(required, excluded).toDenot(NoPrefix)
       }
 
+    final def javaFindMember(name: Name, pre: Type, required: FlagSet = EmptyFlags, excluded: FlagSet = EmptyFlags): Denotation =
+      assert(ctx.isJava)
+      inContext(ctx) {
+
+        val preSym = pre.typeSymbol
+
+        // 1. Try to search in current type and parents
+        val directSearch = pre.findMember(name, pre, required, excluded)
+
+        // 2. Try to search in companion class if current is an object
+        def searchCompanionClass = if preSym.is(Flags.Module) then
+          preSym.companionClass.thisType.findMember(name, pre, required, excluded)
+          else NoDenotation
+
+        // 3. Try to search in companion objects of super classes.
+        // In Java code, static inner classes, which we model as members of the companion object,
+        // can be referenced from an ident in a subclass or by a selection prefixed by the subclass.
+        def searchSuperCompanionObjects =
+          val toSearch = if preSym.is(Flags.Module) then
+            if preSym.companionClass.exists then
+              preSym.companionClass.asClass.baseClasses
+            else Nil
+          else
+            preSym.asClass.baseClasses
+
+          toSearch.iterator.map { bc =>
+            val pre1 = bc.thisType.typeSymbol.companionClass.thisType
+            pre1.findMember(name, pre1, required, excluded)
+          }.find(_.exists).getOrElse(NoDenotation)
+
+        if preSym.isClass then
+          directSearch orElse searchCompanionClass orElse searchSuperCompanionObjects
+        else
+          directSearch
+      }
+
     /** A fresh local context with given tree and owner.
     *  Owner might not exist (can happen for self valdefs), in which case
     *  no owner is set in result context

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -901,16 +901,7 @@ object JavaParsers {
             members) ++= decls
         }
       }
-      def forwarders(sdef: Tree): List[Tree] = sdef match {
-        case TypeDef(name, _) if (parentToken == INTERFACE) =>
-          var rhs: Tree = Select(Ident(parentName.toTermName), name)
-          List(TypeDef(name, rhs).withMods(Modifiers(Flags.Protected)))
-        case _ =>
-          List()
-      }
-      val sdefs = statics.toList
-      val idefs = members.toList ::: (sdefs flatMap forwarders)
-      (sdefs, idefs)
+      (statics.toList, members.toList)
     }
     def annotationParents: List[Select] = List(
       scalaAnnotationDot(tpnme.Annotation),

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

@@ -4,7 +4,7 @@ package typer
 
 import core._
 import ast._
-import Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
+import Contexts._, ContextOps._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
 import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._
 import util.Spans._
 import util.SrcPos
@@ -145,7 +145,12 @@ trait TypeAssigner {
       // this is exactly what Erasure will do.
       case _ =>
         val pre = maybeSkolemizePrefix(qualType, name)
-        val mbr = qualType.findMember(name, pre)
+        val mbr =
+          if ctx.isJava && pre.typeSymbol.isClass then
+            ctx.javaFindMember(name, pre)
+          else
+            qualType.findMember(name, pre)
+
         if reallyExists(mbr) then qualType.select(name, mbr)
         else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType
         else NoType

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

@@ -367,7 +367,9 @@ class Typer extends Namer
             if (qualifies(defDenot)) {
               val found =
                 if (isSelfDenot(defDenot)) curOwner.enclosingClass.thisType
-                else {
+                else if(ctx.isJava && defDenot.symbol.isStatic) {
+                  defDenot.symbol.namedType
+                } else {
                   val effectiveOwner =
                     if (curOwner.isTerm && defDenot.symbol.maybeOwner.isType)
                       // Don't mix NoPrefix and thisType prefixes, since type comparer

compiler/test/dotc/pos-test-pickling.blacklist

@@ -66,3 +66,4 @@ i2797a
 # GADT cast applied to singleton type difference
 i4176-gadt.scala
 
+java-inherited-type1

compiler/test/dotc/run-test-pickling.blacklist

@@ -35,3 +35,5 @@ varargs-abstract
 zero-arity-case-class.scala
 i12194.scala
 i12753
+t6138
+t6138-2

tests/pos/java-inherited-type/Client.scala

@@ -0,0 +1,19 @@
+object Client {
+  def test= {
+    Test.Outer.Nested.sig
+    Test.Outer.Nested.sig1
+    Test.Outer.Nested.sig2
+    val o = new Test.Outer
+    new o.Nested1().sig
+    new o.Nested1().sig1
+    new o.Nested1().sig2
+  }
+
+  def test1 = {
+    val t = new Test
+    val o = new t.Outer1
+    new o.Nested1().sig
+    new o.Nested1().sig1
+    new o.Nested1().sig2
+  }
+}

tests/pos/java-inherited-type/Test.java

@@ -0,0 +1,30 @@
+public class Test {
+  static class OuterBase implements OuterBaseInterface {
+    static class StaticInner {}
+    class Inner {}
+  }
+  interface OuterBaseInterface {
+    interface InnerFromInterface {}
+  }
+  public static class Outer extends OuterBase {
+    public static class Nested {
+      public static P<StaticInner, Inner, InnerFromInterface> sig; // was: "type StaticInner", "not found: type Inner", "not found: type InnerFromInterface"
+      public static P<Outer.StaticInner, Outer.Inner, Outer.InnerFromInterface> sig1; // was: "type StaticInner is not a member of Test.Outer"
+      public static P<OuterBase.StaticInner, OuterBase.Inner, OuterBaseInterface.InnerFromInterface> sig2;
+
+    }
+    public class Nested1 {
+      public P<StaticInner, Inner, InnerFromInterface> sig; // was: "not found: type StaticInner"
+      public P<Outer.StaticInner, Outer.Inner, Outer.InnerFromInterface> sig1; // was: "type StaticInner is not a member of Test.Outer"
+      public P<OuterBase.StaticInner, OuterBase.Inner, OuterBaseInterface.InnerFromInterface> sig2;
+    }
+  }
+  public class Outer1 extends OuterBase {
+    public class Nested1 {
+      public P<StaticInner, Inner, InnerFromInterface> sig; // was: "not found: type StaticInner"
+      public P<Outer.StaticInner, Outer.Inner, Outer.InnerFromInterface> sig1; // was: "type StaticInner is not a member of Test.Outer"
+      public P<OuterBase.StaticInner, OuterBase.Inner, OuterBaseInterface.InnerFromInterface> sig2;
+    }
+  }
+  public static class P<A, B, C>{}
+}

tests/pos/java-inherited-type1/J.java

@@ -0,0 +1,9 @@
+class J extends S {
+  // These references all work in Javac because `object O { class I }` erases to `O$I`
+
+  void select1(S1.Inner1 i) { new S1.Inner1(); }
+  void ident(Inner i) {}
+
+  void ident1(Inner1 i) {}
+  void select(S.Inner i) { new S.Inner(); }
+}

tests/pos/java-inherited-type1/S.scala

@@ -0,0 +1,9 @@
+class S extends S1
+object S {
+  class Inner
+}
+
+class S1
+object S1 {
+  class Inner1
+}