Use Java rules for member lookup in .java sources

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.companionModule.namedType
+ 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

@@ -751,35 +751,8 @@ object JavaParsers {
  makeTemplate(List(), statics, List(), false)).withMods((cdef.mods & Flags.RetainedModuleClassFlags).toTermFlags)
  }
 
- def importCompanionObject(cdef: TypeDef): Tree =
- Import(
- Ident(cdef.name.toTermName).withSpan(NoSpan),
- ImportSelector(Ident(nme.WILDCARD)) :: Nil)
-
- // Importing the companion object members cannot be done uncritically: see
- // ticket #2377 wherein a class contains two static inner classes, each of which
- // has a static inner class called "Builder" - this results in an ambiguity error
- // when each performs the import in the enclosing class's scope.
- //
- // To address this I moved the import Companion._ inside the class, as the first
- // statement. This should work without compromising the enclosing scope, but may (?)
- // end up suffering from the same issues it does in scala - specifically that this
- // leaves auxiliary constructors unable to access members of the companion object
- // as unqualified identifiers.
- def addCompanionObject(statics: List[Tree], cdef: TypeDef): List[Tree] = {
- // if there are no statics we can use the original cdef, but we always
- // create the companion so import A._ is not an error (see ticket #1700)
- val cdefNew =
- if (statics.isEmpty) cdef
- else {
- val template = cdef.rhs.asInstanceOf[Template]
- cpy.TypeDef(cdef)(cdef.name,
- cpy.Template(template)(body = importCompanionObject(cdef) :: template.body))
- .withMods(cdef.mods)
- }
-
- List(makeCompanionObject(cdefNew, statics), cdefNew)
- }
+ def addCompanionObject(statics: List[Tree], cdef: TypeDef): List[Tree] =
+ List(makeCompanionObject(cdef, statics), cdef)
 
  def importDecl(): List[Tree] = {
  val start = in.offset
@@ -901,16 +874,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
+}

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

@@ -0,0 +1,13 @@
+object Test {
+ val j = new J
+ // force completion of these signatures
+ j.ident(null);
+ j.ident1(null);
+ j.select(null);
+ j.select1(null);
+
+ val message:TestMessage = null
+ val builder:TestMessage.Builder = message.toBuilder
+ builder.setName("name")
+
+}

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

@@ -0,0 +1,17 @@
+abstract class AbstractMessage {
+ public static abstract class Builder<BuilderType extends Builder<BuilderType>> {
+ }
+}
+
+class TestMessage extends AbstractMessage {
+
+ public Builder toBuilder() {
+ return null;
+ }
+
+ public static class Builder extends AbstractMessage.Builder<Builder> {
+ public Builder setName(String name) {
+ return this;
+ }
+ }
+}

tests/run/t6138-2.check

@@ -0,0 +1 @@
+Foo$Bar was instantiated!

tests/run/t6138-2/JavaClass.java

@@ -0,0 +1,4 @@
+public class JavaClass {
+ // This is defined in ScalaClass
+ public static final Foo.Bar bar = new Foo.Bar();
+}

tests/run/t6138-2/ScalaClass.scala

@@ -0,0 +1,18 @@
+/* Similar to t10490 -- but defines `Foo` in the object.
+ * Placing this test within t10490 makes it work without a fix, that's why it's independent.
+ * Note that this was already working, we add it to make sure we don't regress
+ */
+
+class Foo
+object Foo {
+ class Bar {
+ override def toString: String = "Foo$Bar was instantiated!"
+ }
+}
+
+object Test {
+ def main(args: Array[String]): Unit = {
+ // JavaClass is the user of the Scala defined classes
+ println(JavaClass.bar)
+ }
+}

tests/run/t6138/JavaClass.java

@@ -0,0 +1,4 @@
+public class JavaClass {
+ // This is defined in ScalaClass
+ public static final Foo.Bar bar = (new Foo()).new Bar();
+}

tests/run/t6138/ScalaClass.scala

@@ -0,0 +1,13 @@
+class Foo {
+ class Bar {
+ override def toString: String = "Foo$Bar was instantiated!"
+ }
+}
+
+object Test {
+ def main(args: Array[String]): Unit = {
+ // JavaClass is the user of the Scala defined classes
+ println(JavaClass.bar)
+ //println(JavaClass.baz)
+ }
+}

tests/run/t6238.check

@@ -0,0 +1 @@
+Foo$Bar was instantiated!