Fix #4785: Change typing rule for wildcard star args

We typecheck them without expected type to avoid relying on the implicit
conversion from Array to Seq defined in Predef. ElimRepeated does the
necessary adaptations (i.e. seqToArray and arrayToSeq conversions).

Author: allanrenucci

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

@@ -497,7 +497,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** The element type of a sequence or array */
-  def elemType(implicit ctx: Context): Type = self match {
+  def elemType(implicit ctx: Context): Type = self.widenDealias match {
     case defn.ArrayOf(elemtp) => elemtp
     case JavaArrayType(elemtp) => elemtp
     case _ => self.baseType(defn.SeqClass).argInfos.headOption.getOrElse(NoType)

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

@@ -78,9 +78,14 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
     val args1 = tree.args.zipWithConserve(formals) { (arg, formal) =>
       arg match {
         case arg: Typed if isWildcardStarArg(arg) =>
-          if (tree.fun.symbol.is(JavaDefined) && arg.expr.tpe.derivesFrom(defn.SeqClass))
+          val isJavaDefined = tree.fun.symbol.is(JavaDefined)
+          val tpe = arg.expr.tpe
+          if (isJavaDefined && tpe.derivesFrom(defn.SeqClass))
             seqToArray(arg.expr, formal.underlyingIfRepeated(isJava = true))
-          else arg.expr
+          else if (!isJavaDefined && tpe.derivesFrom(defn.ArrayClass))
+            arrayToSeq(arg.expr)
+          else
+            arg.expr
         case arg => arg
       }
     }
@@ -91,12 +96,10 @@ 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 defn.WrapArrayMethods().contains(fun.symbol) => // rewrite a call to `wrapXArray(arr)` to `arr`
-      args.head
     case _ =>
       val elemType = tree.tpe.elemType
       var elemClass = elemType.classSymbol
-      if (defn.NotRuntimeClasses contains elemClass) elemClass = defn.ObjectClass
+      if (defn.NotRuntimeClasses.contains(elemClass)) elemClass = defn.ObjectClass
       ref(defn.DottyArraysModule)
         .select(nme.seqToArray)
         .appliedToType(elemType)
@@ -105,6 +108,10 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
           // Because of phantomclasses, the Java array's type might not conform to the return type
   }
 
+  /** Convert Java array argument to Scala Seq */
+  private def arrayToSeq(tree: Tree)(implicit ctx: Context): Tree =
+    tpd.wrapArray(tree, tree.tpe.elemType)
+
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     transformTypeOfTree(tree)
 

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

@@ -153,8 +153,12 @@ trait TypeAssigner {
     if (!sym.is(SyntheticOrPrivate) && sym.owner.isClass) checkNoPrivateLeaks(sym, pos)
     else sym.info
 
-  def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree =
-    Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(defn.SeqClass, defn.RepeatedParamClass)))
+  private def toRepeated(tree: Tree, from: ClassSymbol)(implicit ctx: Context): Tree =
+    Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(from, defn.RepeatedParamClass)))
+
+   def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.SeqClass)
+
+   def arrayToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.ArrayClass)
 
   /** A denotation exists really if it exists and does not point to a stale symbol. */
   final def reallyExists(denot: Denotation)(implicit ctx: Context): Boolean = try

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

@@ -546,6 +546,7 @@ class Typer extends Namer
         }
       case _ => ifExpr
     }
+
     def ascription(tpt: Tree, isWildcard: Boolean) = {
       val underlyingTreeTpe =
         if (isRepeatedParamType(tpt)) TypeTree(defn.SeqType.appliedTo(pt :: Nil))
@@ -557,11 +558,26 @@ class Typer extends Namer
         else typed(tree.expr, tpt.tpe.widenSkolem)
       assignType(cpy.Typed(tree)(expr1, tpt), underlyingTreeTpe)
     }
-    if (untpd.isWildcardStarArg(tree))
+
+    if (untpd.isWildcardStarArg(tree)) {
+      def typedWildcardStarArgExpr = {
+        val tpdExpr = typedExpr(tree.expr)
+        tpdExpr.tpe.widenDealias match {
+          case defn.ArrayOf(_) =>
+            val starType = defn.ArrayType.appliedTo(WildcardType)
+            val exprAdapted = adapt(tpdExpr, starType)
+            arrayToRepeated(exprAdapted)
+          case _ =>
+            val starType = defn.SeqType.appliedTo(defn.AnyType)
+            val exprAdapted = adapt(tpdExpr, starType)
+            seqToRepeated(exprAdapted)
+        }
+      }
       cases(
         ifPat = ascription(TypeTree(defn.RepeatedParamType.appliedTo(pt)), isWildcard = true),
-        ifExpr = seqToRepeated(typedExpr(tree.expr, defn.SeqType.appliedTo(defn.AnyType))),
+        ifExpr = typedWildcardStarArgExpr,
         wildName = nme.WILDCARD_STAR)
+    }
     else {
       def typedTpt = checkSimpleKinded(typedType(tree.tpt))
       def handlePattern: Tree = {

tests/neg/repeatedArgs213.scala

@@ -33,11 +33,11 @@ class repeatedArgs {
     bar("a", "b", "c")
     bar(xs: _*)
     bar(ys: _*) // error: immutable.Seq expected, found Seq
-    bar(zs: _*) // error: immutable.Seq expected, found Array
+    bar(zs: _*) // old-error: Remove (compiler generated) Array to Seq convertion in 2.13?
 
     Paths.get("Hello", "World")
     Paths.get("Hello", xs: _*)
     Paths.get("Hello", ys: _*) // error: immutable.Seq expected, found Seq
-    Paths.get("Hello", zs: _*) // error: immutable.Seq expected, found Array
+    Paths.get("Hello", zs: _*)
   }
 }

tests/pos/i4785.scala

@@ -0,0 +1,15 @@
+import scala.Predef.Set // unimport Predef.wrapRefArray
+
+import java.nio.file.Paths
+
+class i4785 {
+  def bar(xs: String*) = xs.length
+
+  def test(xs: Seq[String], ys: Array[String]) = {
+    Paths.get("Hello", xs: _*)
+    Paths.get("Hello", ys: _*)
+
+    bar(xs: _*)
+    bar(ys: _*)
+  }
+}