Fix #3675: don't unnecessarily wrap arrays when eliminating java varargs

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

@@ -94,6 +94,8 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   private def seqToArray(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree match {
     case SeqLiteral(elems, elemtpt) =>
       JavaSeqLiteral(elems, elemtpt)
+    case app@Apply(fun, args) if isWrappedArray(app) => // rewrite a call to `wrapXArray(arr)` to `arr`
+      args.head
     case _ =>
       val elemType = tree.tpe.elemType
       var elemClass = elemType.classSymbol
@@ -106,6 +108,14 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
           // Because of phantomclasses, the Java array's type might not conform to the return type
   }
 
+  /** Determines whether `tree` is a method call to Predef.wrapXArray */
+  private def isWrappedArray(tree: Apply)(implicit ctx: Context): Boolean = {
+    val elemTpe = tree.tpe.elemType
+    val wrapMethodName = TreeGen.wrapArrayMethodName(elemTpe)
+    val wrapMethodSym = defn.ScalaPredefModuleRef.denot.requiredMethod(wrapMethodName)
+    tree.fun.symbol == wrapMethodSym
+  }
+
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     transformTypeOfTree(tree)
 

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala

@@ -187,4 +187,32 @@ class TestBCode extends DottyBytecodeTest {
         diffInstructions(instructions1, instructions2))
     }
   }
+
+  /** Verifies that arrays are not unnecessarily wrapped when passed to Java varargs methods */
+  @Test def dontWrapArraysInJavaVarargs = {
+    val source =
+      """
+        |import java.nio.file._
+        |class Test {
+        |  def test(xs: Array[String]) = {
+        |     val p4 = Paths.get("Hello", xs: _*)
+        |  }
+        |}
+      """.stripMargin
+
+    checkBCode(source) { dir =>
+      val moduleIn = dir.lookupName("Test.class", directory = false)
+      val moduleNode = loadClassNode(moduleIn.input)
+      val method = getMethod(moduleNode, "test")
+
+      val arrayWrapped = instructionsFromMethod(method).exists { instr: Instruction =>
+        instr match {
+          case inv: Invoke => inv.name.contains("wrapRefArray")
+          case _ => false
+        }
+      }
+
+      assert(!arrayWrapped, "Arrays should not be wrapped when passed to a Java varargs method\n")
+    }
+  }
 }