Take expected type into account when typing a sequence argument

Given an expected type `*T`, we allow a sequence argument `xs: _*` to be
either a `Seq[T]` or an `Array[_ <: T]`, irrespective of whether the
method we're calling is a Java or Scala method. So far we typed sequence
arguments without an expected type, meaning that adaptation did not take
place. But thanks to #8635, we can type them with an expected type of
`Seq[T] | Array[_ <: T]` and type inference works out. This is what this
commit does.

Author: smarter

community-build/community-projects/xml-interpolator

@@ -389,12 +389,16 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** If this is a repeated parameter `*T`, translate it to either `Seq[T]` or
-   *  `Array[? <: T]` depending on the value of `toArray`, keep other types as
-   *  they are.
+   *  `Array[? <: T]` depending on the value of `toArray`.
+   *  Additionally, if `translateWildcard` is true, a wildcard type
+   *  will be translated to `*<?>`.
+   *  Other types are kept as-is.
    */
-  def translateFromRepeated(toArray: Boolean)(using Context): Type =
-    if self.isRepeatedParam then
-      val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
+  def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false)(using Context): Type =
+    val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
+    if translateWildcard && self.isInstanceOf[WildcardType] then
+      seqClass.typeRef.appliedTo(WildcardType)
+    else if self.isRepeatedParam then
       // We want `Array[? <: T]` because arrays aren't covariant until after
       // erasure. See `tests/pos/i5140`.
       translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)

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

@@ -728,19 +728,20 @@ class Typer extends Namer
 
     if (untpd.isWildcardStarArg(tree)) {
       def typedWildcardStarArgExpr = {
+        // A sequence argument `xs: _*` can be either a `Seq[T]` or an `Array[_ <: T]`,
+        // irrespective of whether the method we're calling is a Java or Scala method,
+        // so the expected type is the union `Seq[T] | Array[_ <: T]`.
         val ptArg =
-          if (ctx.mode.is(Mode.QuotedPattern)) pt.translateFromRepeated(toArray = false)
-          else WildcardType
+          // FIXME(#8680): Quoted patterns do not support Array repeated arguments
+          if (ctx.mode.is(Mode.QuotedPattern)) pt.translateFromRepeated(toArray = false, translateWildcard = true)
+          else pt.translateFromRepeated(toArray = false, translateWildcard = true) |
+               pt.translateFromRepeated(toArray = true,  translateWildcard = true)
         val tpdExpr = typedExpr(tree.expr, ptArg)
         tpdExpr.tpe.widenDealias match {
           case defn.ArrayOf(_) =>
-            val starType = defn.ArrayType.appliedTo(WildcardType)
-            val exprAdapted = adapt(tpdExpr, starType)
-            arrayToRepeated(exprAdapted)
+            arrayToRepeated(tpdExpr)
           case _ =>
-            val starType = defn.SeqType.appliedTo(defn.AnyType)
-            val exprAdapted = adapt(tpdExpr, starType)
-            seqToRepeated(exprAdapted)
+            seqToRepeated(tpdExpr)
         }
       }
       cases(

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

@@ -0,0 +1,5 @@
+// If `translateFromRepeated` translated wildcards by default, the following
+// would break because of the use of wildcards in signatures.
+case class Benchmark[A](params: List[A],
+  sqlInsert: (benchId: Long, params: A, session: Int) => Unit,
+  fun: List[A])

tests/pos/case-signature.scala

@@ -0,0 +1,28 @@
+import scala.reflect.ClassTag
+import scala.language.implicitConversions
+
+object B {
+  def doubleSeq[T](x: T): Seq[T] = Seq(x, x)
+  def doubleArray[T: ClassTag](x: T): Array[T] = Array(x, x)
+
+  def box(args: Integer*): Unit = {}
+  def widen(args: Long*): Unit = {}
+  def conv(args: Y*): Unit = {}
+
+  box(doubleSeq(1): _*)
+  box(doubleArray(1): _*)
+  Java_2.box(doubleSeq(1): _*)
+  Java_2.box(doubleArray(1): _*)
+
+  widen(doubleSeq(1): _*)
+  widen(doubleArray(1): _*)
+  Java_2.widen(doubleSeq(1): _*)
+  Java_2.widen(doubleArray(1): _*)
+
+  implicit def xToY(x: X): Y = new Y
+  val x: X = new X
+  conv(doubleSeq(x): _*)
+  conv(doubleArray(x): _*)
+  Java_2.conv(doubleSeq(x): _*)
+  Java_2.conv(doubleArray(x): _*)
+}

tests/pos/sequence-argument/B_2.scala

@@ -0,0 +1,5 @@
+public class Java_2 {
+  public static void box(Integer ...args) {}
+  public static void widen(Long... args) {}
+  public static void conv(Y... args) {}
+}

tests/pos/sequence-argument/Java_2.java

@@ -0,0 +1,2 @@
+class X
+class Y