Don't drop Object intersection for varargs

A Java generic array `T[]` is unpickled in ClassfileParser to `Array[T &
Object]`, because it will not accept primitive arrays. However, Java
varargs were special-cased to drop this intersection. Erasure contained
some code to compensate for this, but this is still unsound and lead to
tests/run/t1360.scala failing with a ClassCastException.

Thanks to scala#8669 we can drop this special-casing of varargs without
affecting typing too much: it's still possible to pass `Array(1, 2): _*`
where `(T & Object)*` is expected because adaptation will take care of
boxing.

One test case had to be adapted, I replaced:

    def apply[X](xs : X*): java.util.List[X]
      java.util.Arrays.asList(xs: _*)

with:

    def apply[X <: AnyRef](xs : X*): java.util.List[X] =
      java.util.Arrays.asList(xs: _*)

I don't think that's too constraining.

Note: after this commit, tests/run/i533 started failing, this is fixed
in the next commit.

Author: smarter

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -67,22 +67,9 @@ object Scala2Unpickler {
     case tp: MethodType =>
       val lastArg = tp.paramInfos.last
       assert(lastArg isRef defn.ArrayClass)
-      val elemtp0 :: Nil = lastArg.baseType(defn.ArrayClass).argInfos
-      val elemtp = elemtp0 match {
-        case AndType(t1, t2) => // drop intersection with Object for abstract types and parameters in varargs. Erasure can handle them.
-          if t2.isAnyRef then
-            t1 match {
-              case t1: TypeParamRef => t1
-              case t1: TypeRef if t1.symbol.isAbstractOrParamType => t1
-              case _ => elemtp0
-            }
-          else elemtp0
-        case _ =>
-          elemtp0
-      }
       tp.derivedLambdaType(
         tp.paramNames,
-        tp.paramInfos.init :+ defn.RepeatedParamType.appliedTo(elemtp),
+        tp.paramInfos.init :+ lastArg.translateParameterized(defn.ArrayClass, defn.RepeatedParamClass),
         tp.resultType)
     case tp: PolyType =>
       tp.derivedLambdaType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType))

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

@@ -309,11 +309,6 @@ object Erasure {
       assert(!pt.isInstanceOf[SingletonType], pt)
       if (pt isRef defn.UnitClass) unbox(tree, pt)
       else (tree.tpe.widen, pt) match {
-        case (JavaArrayType(treeElem), JavaArrayType(ptElem))
-        if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
-          // See SI-2386 for one example of when this might be necessary.
-          cast(ref(defn.runtimeMethodRef(nme.toObjectArray)).appliedTo(tree), pt)
-
         // When casting between two EVTs, we need to check which one underlies the other to determine
         // whether u2evt or evt2u should be used.
         case (tp1 @ ErasedValueType(tycon1, underlying1), tp2 @ ErasedValueType(tycon2, underlying2)) =>

tests/pos/arrays2.scala

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

tests/run/java-varargs/A_1.java

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

tests/run/java-varargs/Test_2.scala

@@ -2,5 +2,7 @@ object Test {
   def main(args: Array[String]): Unit = {
     A_1.foo(Array(1): _*)
     A_1.foo(Seq(1): _*)
+    A_1.gen(Array(1): _*)
+    A_1.gen(Seq(1): _*)
   }
 }