[WIP] Take expected type into account when typing a sequence argument

Author: smarter

community-build/community-projects/xml-interpolator

@@ -392,7 +392,11 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  or, if isJava is true, Array type, else the type itself.
    */
   def underlyingIfRepeated(isJava: Boolean)(implicit ctx: Context): Type =
-    if (self.isRepeatedParam) {
+    if (self eq WildcardType) {
+      val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
+      seqClass.typeRef.appliedTo(WildcardType)
+    }
+    else if (self.isRepeatedParam) {
       val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
       // If `isJava` is set, then we want to turn `RepeatedParam[T]` into `Array[? <: T]`,
       // since arrays aren't covariant until after erasure. See `tests/pos/i5140`.

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

@@ -728,17 +728,13 @@ class Typer extends Namer
       def typedWildcardStarArgExpr = {
         val ptArg =
           if (ctx.mode.is(Mode.QuotedPattern)) pt.underlyingIfRepeated(isJava = false)
-          else WildcardType
+          else pt.underlyingIfRepeated(isJava = false) | pt.underlyingIfRepeated(isJava = 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,25 @@
+import scala.reflect.ClassTag
+import scala.language.implicitConversions
+
+class A
+class B
+
+object Test {
+  def doubleSeq[T](x: T): Seq[T] = Seq(x, x)
+  def doubleArray[T: ClassTag](x: T): Array[T] = Array(x, x)
+
+  def box(x: Integer*): Unit = {}
+  def widen(x: Long*): Unit = {}
+  def conv(x: B*): Unit = {}
+
+  box(doubleSeq(1): _*)
+  box(doubleArray(1): _*)
+
+  widen(doubleSeq(1): _*)
+  widen(doubleArray(1): _*)
+
+  implicit def aToB(x: A): B = new B
+  val a: A = new A
+  conv(doubleSeq(a): _*)
+  conv(doubleArray(a): _*)
+}