test all combinations of java.lang.Object from java

Author: bishabosha

sbt-test/pipelining/Yjava-tasty-fromjavaobject/a/src/main/scala/a/A.java

@@ -0,0 +1,40 @@
+// this test ensures that Object can accept Any from Scala
+// see Definitions.FromJavaObjectSymbol
+package a;
+
+public class A {
+
+  public static class Inner<T> extends Object {
+    public Inner() {}
+
+    public void meth1(T arg) {}
+    public <U extends T> void meth2(U arg) {}
+  }
+
+  public static class Inner_sel<T> extends java.lang.Object {
+    public Inner_sel() {}
+
+    public void meth1(T arg) {}
+    public <U extends T> void meth2(U arg) {}
+  }
+
+  // 1. At the top level:
+  public void meth1(Object arg) {}
+  public void meth1_sel(java.lang.Object arg) {}
+  public <T> void meth2(T arg) {} // T implicitly extends Object
+
+  // 2. In a class type parameter:
+  public void meth3(scala.collection.immutable.List<Object> arg) {}
+  public void meth3_sel(scala.collection.immutable.List<java.lang.Object> arg) {}
+  public <T> void meth4(scala.collection.immutable.List<T> arg) {}
+
+  // 3. As the type parameter of an array:
+  public void meth5(Object[] arg) {}
+  public void meth5_sel(java.lang.Object[] arg) {}
+  public <T> void meth6(T[] arg) {}
+
+  // 4. As the repeated argument of a varargs method:
+  public void meth7(Object... args) {}
+  public void meth7_sel(java.lang.Object... args) {}
+  public <T> void meth8(T... args) {}
+}

sbt-test/pipelining/Yjava-tasty-fromjavaobject/a/src/main/scala/a/AImport.java

@@ -0,0 +1,27 @@
+// this test ensures that Object can accept Any from Scala
+// see Definitions.FromJavaObjectSymbol
+package a;
+
+import java.lang.Object;
+
+// same signatures that reference Object explicitly from A.java, but with the java.lang.Object import
+public class AImport {
+
+  public static class Inner<T> extends Object {
+    public Inner() {}
+
+    public void meth1(T arg) {}
+  }
+
+  // 1. At the top level:
+  public void meth1(Object arg) {}
+
+  // 2. In a class type parameter:
+  public void meth3(scala.collection.immutable.List<Object> arg) {}
+
+  // 3. As the type parameter of an array:
+  public void meth5(Object[] arg) {}
+
+  // 4. As the repeated argument of a varargs method:
+  public void meth7(Object... args) {}
+}

sbt-test/pipelining/Yjava-tasty-fromjavaobject/a/src/main/scala/a/package.scala

@@ -0,0 +1,2 @@
+// THIS FILE EXISTS SO THAT `A.java` WILL BE COMPILED BY SCALAC
+package a

sbt-test/pipelining/Yjava-tasty-fromjavaobject/b-alt/.keep

@@ -0,0 +1,42 @@
+package b
+
+import a.A
+
+// keep in sync with Bexplicit.scala
+object B {
+
+  val newA = new A
+
+  val newAInner = new A.Inner[Int]()
+  val newAInner_sel = new A.Inner_sel[Int]()
+
+  @main
+  def test = {
+    newA.meth1(1) // OK
+    newA.meth1_sel(1) // OK
+    newA.meth2(1) // OK
+    newA.meth3(List[Int](1)) // OK
+    newA.meth3_sel(List[Int](1)) // OK
+    newA.meth4(List[Int](1)) // OK
+    newA.meth5(Array[Object]("abc")) // OK
+    newA.meth5_sel(Array[Object]("abc")) // OK
+    newA.meth6(Array[String]("abc")) // Ok
+    // newA.meth5(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+    // newA.meth6(Array[Int](1)) // error: Array[Int] is not a subtype of Array[T & Object]
+    newA.meth7(1) // OK (creates a reference array)
+    newA.meth7_sel(1) // OK (creates a reference array)
+    newA.meth8(1) // OK (creates a primitive array and copies it into a reference array at Erasure)
+    val ai = Array[Int](1)
+    newA.meth7(ai: _*) // OK (will copy the array at Erasure)
+    newA.meth7_sel(ai: _*) // OK (will copy the array at Erasure)
+    newA.meth8(ai: _*) // OK (will copy the array at Erasure)
+
+    newAInner.meth1(1) // OK
+    newAInner.meth2(1) // OK
+    newAInner_sel.meth1(1) // OK
+    newAInner_sel.meth2(1) // OK
+
+    BImport.testImport() // OK
+  }
+}
+

sbt-test/pipelining/Yjava-tasty-fromjavaobject/b/src/main/scala/b/B.scala

@@ -0,0 +1,23 @@
+package b
+
+import a.AImport
+
+object BImport {
+
+  val newA = new AImport
+
+  val newAInner = new AImport.Inner[Int]()
+
+  def testImport() = {
+    newA.meth1(1) // OK
+    newA.meth3(List[Int](1)) // OK
+    newA.meth5(Array[Object]("abc")) // OK
+    // newA.meth5(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+    newA.meth7(1) // OK (creates a reference array)
+    val ai = Array[Int](1)
+    newA.meth7(ai: _*) // OK (will copy the array at Erasure)
+
+    newAInner.meth1(1) // OK
+  }
+}
+

sbt-test/pipelining/Yjava-tasty-fromjavaobject/b/src/main/scala/b/BImport.scala

@@ -0,0 +1,46 @@
+lazy val a = project.in(file("a"))
+  .settings(
+    compileOrder := CompileOrder.Mixed, // ensure we send java sources to Scala compiler
+    scalacOptions += "-Yjava-tasty", // enable pickling of java signatures
+    scalacOptions ++= Seq("-Yjava-tasty-output", ((ThisBuild / baseDirectory).value / "a-enum-java-tasty.jar").toString),
+    scalacOptions += "-Ycheck:all",
+    Compile / classDirectory := ((ThisBuild / baseDirectory).value / "a-enum-classes"), // send classfiles to a different directory
+  )
+
+
+lazy val b = project.in(file("b"))
+  .settings(
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-java-tasty.jar")),
+    scalacOptions += "-Ycheck:all",
+  )
+  .settings(
+    fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes"), // make sure the java classes are visible at runtime
+  )
+
+// same as b, but adds the real classes to the classpath instead of the tasty jar
+lazy val bAlt = project.in(file("b-alt"))
+  .settings(
+    Compile / sources := (b / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes")),
+    scalacOptions += "-Ycheck:all",
+  )
+  .settings(
+    fork := true, // we have to fork the JVM if we actually want to run the code with correct failure semantics
+    Runtime / unmanagedClasspath += Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes"), // make sure the java classes are visible at runtime
+  )
+
+// negative compilation tests
+lazy val c = project.in(file("c"))
+  .settings(
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-java-tasty.jar")),
+    scalacOptions += "-Ycheck:all",
+  )
+
+// same as c, but adds the real classes to the classpath instead of the tasty jar
+lazy val cAlt = project.in(file("c-alt"))
+  .settings(
+    Compile / sources := (c / Compile / sources).value,
+    Compile / unmanagedClasspath := Seq(Attributed.blank((ThisBuild / baseDirectory).value / "a-enum-classes")),
+    scalacOptions += "-Ycheck:all",
+  )

sbt-test/pipelining/Yjava-tasty-fromjavaobject/build.sbt

@@ -0,0 +1,16 @@
+package c
+
+import a.A
+
+object C {
+
+  val newA = new A
+
+  @main
+  def test = {
+    newA.meth5(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+    newA.meth5_sel(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+    newA.meth6(Array[Int](1)) // error: Array[Int] is not a subtype of Array[T & Object]
+  }
+}
+

sbt-test/pipelining/Yjava-tasty-fromjavaobject/c-alt/.keep

@@ -0,0 +1,14 @@
+package c
+
+import a.AImport
+
+object CImport {
+
+  val newA = new AImport
+
+  @main
+  def test = {
+    newA.meth5(Array[Int](1)) // error: Array[Int] is not a subtype of Array[Object]
+  }
+}
+

sbt-test/pipelining/Yjava-tasty-fromjavaobject/c/src/main/scala/c/C.scala

@@ -0,0 +1,12 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := sys.props("plugin.scalaVersion"),
+    scalacOptions += "-source:3.0-migration"
+  )
+}

sbt-test/pipelining/Yjava-tasty-fromjavaobject/c/src/main/scala/c/CImport.scala

@@ -0,0 +1,9 @@
+> a/compile
+# test depending on a java compiled enum through TASTy
+> b/run
+# double check against the real java classes
+> bAlt/run
+# check that java Array T is Array T & Object
+-> c/compile
+# double check against the real java classes
+-> cAlt/compile