Fix #4073: erase <repeted> type from lifted val for a vararg

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

@@ -133,12 +133,7 @@ object TypeErasure {
     erasureFn(isJava = false, semiEraseVCs = true, isConstructor = false, wildcardOK = false)(tp)(erasureCtx)
 
   def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = {
-    val normTp =
-      if (tp.isRepeatedParam) {
-        val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
-        tp.translateParameterized(defn.RepeatedParamClass, seqClass)
-      }
-      else tp
+    val normTp = tp.underlyingIfRepeated(isJava)
     val erase = erasureFn(isJava, semiEraseVCs = false, isConstructor = false, wildcardOK = true)
     erase.sigName(normTp)(erasureCtx)
   }
@@ -394,6 +389,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       else eraseNormalClassRef(tp)
     case tp: AppliedType =>
       if (tp.tycon.isRef(defn.ArrayClass)) eraseArray(tp)
+      else if (tp.isRepeatedParam) apply(tp.underlyingIfRepeated(isJava))
       else apply(tp.superType)
     case _: TermRef | _: ThisType =>
       this(tp.widen)

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

@@ -82,7 +82,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       arg match {
         case arg: Typed if isWildcardStarArg(arg) =>
           if (tree.fun.symbol.is(JavaDefined) && arg.expr.tpe.derivesFrom(defn.SeqClass))
-            seqToArray(arg.expr, formal.translateParameterized(defn.RepeatedParamClass, defn.ArrayClass))
+            seqToArray(arg.expr, formal.underlyingIfRepeated(isJava = true))
           else arg.expr
         case arg => arg
       }

tests/Foo.scala

@@ -0,0 +1,18 @@
+import scala.language.dynamics
+
+class DynImpl extends Dynamic {
+  def applyDynamic(name: String)(args: Any*)(implicit implicitArg: String = "foo"): String =
+    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")} and implicit argument '$implicitArg'"
+}
+
+object Main {
+  def main(args:Array[String]): Unit = {
+    val d = new DynImpl
+
+    println(d.some())
+
+    println(d.ints(1, 2, 3))
+
+    println(d.strings("a", "b", "c"))
+  }
+}

tests/run/i4073.check

@@ -0,0 +1,3 @@
+method 'some' called with arguments '' and implicit argument 'foo'
+method 'ints' called with arguments '1', '2', '3' and implicit argument 'foo'
+method 'strings' called with arguments 'a', 'b', 'c' and implicit argument 'foo'

tests/run/i4073.scala

@@ -0,0 +1,18 @@
+import scala.language.dynamics
+
+class DynImpl extends Dynamic {
+  def applyDynamic(name: String)(args: Any*)(implicit implicitArg: String = "foo"): String =
+    s"method '$name' called with arguments ${args.mkString("'", "', '", "'")} and implicit argument '$implicitArg'"
+}
+
+object Test {
+  def main(args:Array[String]): Unit = {
+    val d = new DynImpl
+
+    println(d.some())
+
+    println(d.ints(1, 2, 3))
+
+    println(d.strings("a", "b", "c"))
+  }
+}

tests/run/i4073b.check

@@ -0,0 +1 @@
+foo123

tests/run/i4073b.scala

@@ -0,0 +1,4 @@
+object Test {
+  def main(args:Array[String]): Unit = println(foo(1, 2, 3)())
+  def foo(args: Any*)(arg: String = "foo"): String = arg + args.mkString("")
+}

tests/run/i4073c.check

@@ -0,0 +1 @@
+foo123

tests/run/i4073c.scala

@@ -0,0 +1,4 @@
+object Test {
+  def main(args:Array[String]): Unit = println(foo(1, 2, 3)())
+  def foo(args: Int*)(arg: String = "foo"): String = arg + args.mkString("")
+}