Arrays and Repeated arguments in 2.13 and future Dotty version

[allanrenucci]

Starting with Scala 2.13 the default Seq type is immutable.Seq. This change apply to repeated arguments:

scala> def foo(x: Int*) = 1
foo: (x: Int*)Int

scala> foo(immutable.Seq(1, 2): _*)
res0: Int = 1

scala> foo(mutable.Seq(1, 2): _*)
                      ^
       error: type mismatch;
        found   : Seq[Int] (in scala.collection.mutable)
        required: Seq[Int] (in scala.collection.immutable)

scala> foo(Array(1, 2): _*)
res2: Int = 1

However, it is still possible to pass an Array where repeated arguments are expected. This is a requirement for java interoperability.

In Dotty, given foo: _*, foo must be a subtype of Seq. If foo is an array, then an implicit conversion is applied (i.e. Predef.wrapXXXArray). We don't need to special case arrays in typer but latter (in ElimRepeated) we have to revert the conversion if the array is used as a repeated arguments of a java defined method. E.g.

// xs: Array[String]

java.nio.file.Paths.get("foo", xs: _*)

// >>>>>> Typer
java.nio.file.Paths.get("foo", Predef.wrapRefArray(xs): String*)

// >>>>>> ElimRepeated
java.nio.file.Paths.get("foo", xs)

The current implicit conversions defined in Predef returns a mutable.Seq.

How do we solve this problem in the future when Dotty switch its default Seq type to immutable.Seq instead of collection.Seq? Here are my thoughts, either:

1. Introduce new implicit conversions in DottyPredef (or Predef?) from Array to immutable.Seq.
2. Change typing rules for repeated arguments. In expression position:

   foo <:< Array[A] or foo <:< immutable.Seq[A]
   ---------------------------------------------
   foo: _* ⊢ Repeated[A]
   

I think scalac does 2). @adriaanm, any thoughts on this?

[julienrf]

I don’t think scalac has special cased the typing rule for splicing arrays as multiple parameters. If you write Paths.get("foo", Array(): _*), this expression is not correctly typed but we have a deprecated implicit conversion from Array to immutable.Seq (that performs a copy of the array), for backward compatibility only, so that the expression becomes correctly typed.

[allanrenucci]

class Test {
  def bar(xs: String*) = 1
  def foo(xs: Array[String]) = {
    bar(xs: _*)
    java.nio.file.Paths.get("", xs: _*)
  }
}

Simplified output from scalac Test.scala -Xprint:all (2.13.x branch):

[[syntax trees at end of                     typer]] // Test.scala
class Test extends scala.AnyRef {
  def foo(xs: Array[String]): java.nio.file.Path = {
    Test.this.bar((xs: _*));
    java.nio.file.Paths.get("", (xs: _*))
  }
}

[[syntax trees at end of                   uncurry]] // Test.scala
class Test extends Object {
  def foo(xs: Array[String]): java.nio.file.Path = {
    Test.this.bar(scala.runtime.ScalaRunTime.wrapRefArray[String](xs));
    java.nio.file.Paths.get("", xs)
  }
}

@julienrf As you can see typer does not introduce any implicit conversion from Array to immutable.Seq. uncurry will introduces a conversion but only if the method is not java defined

[julienrf]

You’re right. We have a deprecated implicit conversion but it’s used only when one wants to coerce an Array into a scala.Seq (which is now immutable). The “splice operator” does not go through this machinery and, in the case of a Scala varargs method, wraps the Array into an immutable.ArraySeq without using the deprecated implicit conversion.

[allanrenucci]

We concluded that if Seq is an alias for immutable.Seq, you should not be able to pass a mutable array where a repeated argument is expected

[allanrenucci]

I have opened scala/bug#11024