Properly handle generic arrays coming from Java sources

Treat them like generic arrays coming from Java classfiles: `T[]` needs
to be typed as `Array[T & Object]` since it will not accept primitive
arrays.

Author: smarter

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

@@ -408,6 +408,28 @@ class TypeApplications(val self: Type) extends AnyVal {
   def translateToRepeated(from: ClassSymbol)(using Context): Type =
     translateParameterized(from, defn.RepeatedParamClass)
 
+  /** Translate `T` by `T & Object` in the situations where an `Array[T]`
+   *  coming from Java would need to be interpreted as an `Array[T & Object]`
+   *  to be erased correctly.
+   *
+   *  This is necessary because a fully generic Java array erases to an array of Object,
+   *  whereas a fully generic Java array erases to Object to allow primitive arrays
+   *  as subtypeS.
+   *
+   *  Note: According to
+   *  <http://cr.openjdk.java.net/~briangoetz/valhalla/sov/02-object-model.html>,
+   *  in the future the JVM will consider that:
+   *
+   *      int[] <: Integer[] <: Object[]
+   *
+   *  So hopefully our grand-children will not have to deal with this non-sense!
+   */
+  def translateJavaArrayElementType(using Context): Type =
+    if self.typeSymbol.isAbstractOrParamType && !self.derivesFrom(defn.ObjectClass) then
+      AndType(self, defn.ObjectType)
+    else
+      self
+
   /** If this is an encoding of a (partially) applied type, return its arguments,
    *  otherwise return Nil.
    *  Existential types in arguments are returned as TypeBounds instances.

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -395,16 +395,8 @@ class ClassfileParser(
           tpe
         case ARRAY_TAG =>
           while ('0' <= sig(index) && sig(index) <= '9') index += 1
-          var elemtp = sig2type(tparams, skiptvs)
-          // make unbounded Array[T] where T is a type variable into Array[T with Object]
-          // (this is necessary because such arrays have a representation which is incompatible
-          // with arrays of primitive types.
-          // NOTE that the comparison to Object only works for abstract types bounded by classes that are strict subclasses of Object
-          // if the bound is exactly Object, it will have been converted to Any, and the comparison will fail
-          // see also RestrictJavaArraysMap (when compiling java sources directly)
-          if (elemtp.typeSymbol.isAbstractOrParamType && !(elemtp.derivesFrom(defn.ObjectClass)))
-            elemtp = AndType(elemtp, defn.ObjectType)
-          defn.ArrayOf(elemtp)
+          val elemtp = sig2type(tparams, skiptvs)
+          defn.ArrayOf(elemtp.translateJavaArrayElementType)
         case '(' =>
           // we need a method symbol. given in line 486 by calling getType(methodSym, ..)
           val paramtypes = new ListBuffer[Type]()

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

@@ -1641,6 +1641,15 @@ class Typer extends Namer
       else if (tpt1.symbol == defn.orType)
         checkedArgs = checkedArgs.mapconserve(arg =>
           checkSimpleKinded(checkNoWildcard(arg)))
+      else if (ctx.compilationUnit.isJava)
+        if (tpt1.symbol eq defn.ArrayClass) || (tpt1.symbol eq defn.RepeatedParamClass) then
+          checkedArgs match {
+            case List(arg) =>
+              val elemtp = arg.tpe.translateJavaArrayElementType
+              if (elemtp ne arg.tpe)
+                checkedArgs = List(TypeTree(elemtp).withSpan(arg.span))
+            case _ =>
+          }
       assignType(cpy.AppliedTypeTree(tree)(tpt1, checkedArgs), tpt1, checkedArgs)
     }
   }

tests/explicit-nulls/run/generic-java-array-src/Test.scala

@@ -4,7 +4,7 @@ object Test {
     // then on the Scala side we'll need to pass a nullable array.
     // i.e. with explicit nulls the previously-implicit cast becomes an explicit
     // type annotation.
-    val x = new Array[Int|Null](1)
+    val x = new Array[Integer|Null](1)
     x(0) = 10
     println(JA.get(x))
 

tests/neg/i533/JA.java

@@ -0,0 +1,9 @@
+class JA {
+  public static <T> T get(T[] arr) {
+    return arr[0];
+  }
+
+  public static <T> T getVarargs(T ...arr) {
+    return arr[0];
+  }
+}

tests/neg/i533/Test.scala

@@ -0,0 +1,8 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val x = new Array[Int](1)
+    x(0) = 10
+    println(JA.get(x)) // error
+    println(JA.getVarargs(x: _*)) // error
+  }
+}

tests/run/i533/JA.java

@@ -2,4 +2,8 @@ class JA {
   public static <T> T get(T[] arr) {
     return arr[0];
   }
-}
+
+  public static <T> T getVarargs(T ...arr) {
+    return arr[0];
+  }
+}

tests/run/i533/Test.scala

@@ -1,7 +1,8 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    val x = new Array[Int](1)
+    val x = new Array[Integer](1)
     x(0) = 10
     println(JA.get(x))
+    println(JA.getVarargs(x: _*))
   }
 }