Translate Java varargs ...T into T* instead of (T & Object)*

This is much more convenient for users but is more complicated for the
compiler since we still need to translate the varargs into an `Object[]`
in bytecode. Since ElimRepeated was already responsible for doing some
adaptation of repeated arguments, it now also takes care of this (this
differs from Scala 2 which handles this at Erasure).

Fixes #9439.

Author: smarter

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

@@ -397,6 +397,8 @@ class Definitions {
     def runtimeMethodRef(name: PreName): TermRef = ScalaRuntimeModule.requiredMethodRef(name)
     def ScalaRuntime_drop: Symbol = runtimeMethodRef(nme.drop).symbol
     @tu lazy val ScalaRuntime__hashCode: Symbol = ScalaRuntimeModule.requiredMethod(nme._hashCode_)
+    @tu lazy val ScalaRuntime_toArray: Symbol = ScalaRuntimeModule.requiredMethod(nme.toArray)
+    @tu lazy val ScalaRuntime_toObjectArray: Symbol = ScalaRuntimeModule.requiredMethod(nme.toObjectArray)
 
   @tu lazy val BoxesRunTimeModule: Symbol = requiredModule("scala.runtime.BoxesRunTime")
     @tu lazy val BoxesRunTimeModule_externalEquals: Symbol = BoxesRunTimeModule.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol

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

@@ -423,7 +423,8 @@ class ClassfileParser(
               if isRepeatedParam(index) then
                 index += 1
                 val elemType = sig2type(tparams, skiptvs)
-                defn.RepeatedParamType.appliedTo(elemType.translateJavaArrayElementType)
+                // `ElimRepeated` is responsible for correctly erasing this.
+                defn.RepeatedParamType.appliedTo(elemType)
               else
                 objToAny(sig2type(tparams, skiptvs))
             }

compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala

@@ -20,8 +20,9 @@ object ElimRepeated {
   val name: String = "elimRepeated"
 }
 
-/** A transformer that removes repeated parameters (T*) from all types, replacing
- *  them with Seq types.
+/** A transformer that eliminates repeated parameters (T*) from all types, replacing
+ *  them with Seq or Array types and adapting repeated arguments to conform to
+ *  the transformed type if needed.
  */
 class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   import ast.tpd._
@@ -54,11 +55,22 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   private def elimRepeated(tp: Type)(using Context): Type = tp.stripTypeVar match
     case tp @ MethodTpe(paramNames, paramTypes, resultType) =>
       val resultType1 = elimRepeated(resultType)
-      val paramTypes1 =
-        if paramTypes.nonEmpty && paramTypes.last.isRepeatedParam then
-          val last = paramTypes.last.translateFromRepeated(toArray = tp.isJavaMethod)
-          paramTypes.init :+ last
-        else paramTypes
+      val paramTypes1 = paramTypes match
+        case init :+ last if last.isRepeatedParam =>
+          val isJava = tp.isJavaMethod
+          // A generic Java varargs `T...` is erased to `Object[]` in bytecode,
+          // we directly translate such a type to `Array[_ <: Object]` instead
+          // of `Array[_ <: T]` here. This allows the tree transformer of this phase
+          // to emit the correct adaptation for repeated arguments without
+          // relying on any cast (cf `adaptToArray`).
+          val last1 =
+            if isJava && last.elemType.isInstanceOf[TypeParamRef] then
+              defn.ArrayOf(TypeBounds.upper(defn.ObjectType))
+            else
+              last.translateFromRepeated(toArray = isJava)
+          init :+ last1
+        case _ =>
+          paramTypes
       tp.derivedLambdaType(paramNames, paramTypes1, resultType1)
     case tp: PolyType =>
       tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType))
@@ -82,9 +94,10 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       case arg: Typed if isWildcardStarArg(arg) =>
         val isJavaDefined = tree.fun.symbol.is(JavaDefined)
         val tpe = arg.expr.tpe
-        if isJavaDefined && tpe.derivesFrom(defn.SeqClass) then
-          seqToArray(arg.expr)
-        else if !isJavaDefined && tpe.derivesFrom(defn.ArrayClass)
+        if isJavaDefined then
+          val pt = tree.fun.tpe.widen.firstParamTypes.last
+          adaptToArray(arg.expr, pt.elemType.bounds.hi)
+        else if tpe.derivesFrom(defn.ArrayClass) then
           arrayToSeq(arg.expr)
         else
           arg.expr
@@ -107,7 +120,39 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
         .appliedToType(elemType)
         .appliedTo(tree, clsOf(elemClass.typeRef))
 
-  /** Convert Java array argument to Scala Seq */
+  /** Adapt a Seq or Array tree to be a subtype of `Array[_ <: $elemPt]`.
+   *
+   *  @pre `elemPt` must either be a super type of the argument element type or `Object`.
+   *        The special handling of `Object` is required to deal with the translation
+   *        of generic Java varargs in `elimRepeated`.
+   */
+  private def adaptToArray(tree: Tree, elemPt: Type)(implicit ctx: Context): Tree =
+    val elemTp = tree.tpe.elemType
+    val treeIsArray = tree.tpe.derivesFrom(defn.ArrayClass)
+    if elemTp <:< elemPt then
+      if treeIsArray then
+        tree // no adaptation needed
+      else
+        tree match
+          case SeqLiteral(elems, elemtpt) =>
+            JavaSeqLiteral(elems, elemtpt).withSpan(tree.span)
+          case _ =>
+            // Convert a Seq[T] to an Array[$elemPt]
+            ref(defn.DottyArraysModule)
+              .select(nme.seqToArray)
+              .appliedToType(elemPt)
+              .appliedTo(tree, clsOf(elemPt))
+    else if treeIsArray then
+      // Convert an Array[T] to an Array[Object]
+      ref(defn.ScalaRuntime_toObjectArray)
+        .appliedTo(tree)
+    else
+      // Convert a Seq[T] to an Array[Object]
+      ref(defn.ScalaRuntime_toArray)
+        .appliedToType(elemTp)
+        .appliedTo(tree)
+
+  /** Convert an Array into a scala.Seq */
   private def arrayToSeq(tree: Tree)(using Context): Tree =
     tpd.wrapArray(tree, tree.tpe.elemType)
 

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

@@ -1723,7 +1723,7 @@ class Typer extends Namer
         checkedArgs = checkedArgs.mapconserve(arg =>
           checkSimpleKinded(checkNoWildcard(arg)))
       else if (ctx.compilationUnit.isJava)
-        if (tpt1.symbol eq defn.ArrayClass) || (tpt1.symbol eq defn.RepeatedParamClass) then
+        if (tpt1.symbol eq defn.ArrayClass) then
           checkedArgs match {
             case List(arg) =>
               val elemtp = arg.tpe.translateJavaArrayElementType

tests/neg/i533/Test.scala

@@ -3,6 +3,6 @@ object Test {
     val x = new Array[Int](1)
     x(0) = 10
     println(JA.get(x)) // error
-    println(JA.getVarargs(x: _*)) // error
+    println(JA.getVarargs(x: _*)) // now OK.
   }
 }

tests/pos/arrays2.scala

@@ -24,4 +24,5 @@ one warning found
 // #2461
 object arrays3 {
   def apply[X <: AnyRef](xs : X*) : java.util.List[X] = java.util.Arrays.asList(xs: _*)
+  def apply2[X](xs : X*) : java.util.List[X] = java.util.Arrays.asList(xs: _*)
 }

tests/run/i9439.scala

@@ -0,0 +1,17 @@
+object Test {
+  // First example with a concrete type <: AnyVal
+  def main(args: Array[String]): Unit = {
+    val coll = new java.util.ArrayList[Int]()
+    java.util.Collections.addAll(coll, 5, 6)
+    println(coll.size())
+
+    foo(5, 6)
+  }
+
+  // Second example with an abstract type not known to be <: AnyRef
+  def foo[A](a1: A, a2: A): Unit = {
+    val coll = new java.util.ArrayList[A]()
+    java.util.Collections.addAll(coll, a1, a2)
+    println(coll.size())
+  }
+}

tests/run/java-varargs-2/A.java

@@ -0,0 +1,7 @@
+class A {
+  public static void foo(int... args) {
+  }
+
+  public static <T> void gen(T... args) {
+  }
+}

tests/run/java-varargs-2/Test.scala

@@ -0,0 +1,8 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    A.foo(Array(1): _*)
+    A.foo(Seq(1): _*)
+    A.gen(Array(1): _*)
+    A.gen(Seq(1): _*)
+  }
+}