add more vararg tests

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

@@ -185,23 +185,20 @@ trait Dynamic {
     val vargss = termArgss(tree)
 
     def handleRepeated(base: untpd.Tree, possiblyCurried: List[List[Tree]], isReflectSelectable: Boolean) = {
-      val handled = possiblyCurried.map { args =>
-        val isRepeated = args.exists(_.tpe.widen.isRepeatedParam)
-        if isRepeated && isReflectSelectable then
-          List(untpd.TypedSplice(tpd.repeatedSeq(args, TypeTree(defn.AnyType))))
-        else args.map { t =>
-          val clzSym = t.tpe.resultType.classSymbol.asClass
-          if ValueClasses.isDerivedValueClass(clzSym) && isReflectSelectable then
-            val underlying = ValueClasses.valueClassUnbox(clzSym).asTerm
-            tpd.Select(t, underlying.name)
-          else
-            t
-        }.map(untpd.TypedSplice(_))
+      val args = possiblyCurried.flatten.map { t =>
+        val clzSym = t.tpe.resultType.classSymbol.asClass
+        if clzSym.isDerivedValueClass && isReflectSelectable then
+          val underlying = ValueClasses.valueClassUnbox(clzSym).asTerm
+          tpd.Select(t, underlying.name)
+        else
+          t
       }
+      val handledFlat =
+        if isReflectSelectable then List(untpd.TypedSplice(tpd.repeatedSeq(args, TypeTree(defn.AnyType))))
+        else if args.isEmpty then List()
+        else List(untpd.TypedSplice(tpd.repeatedSeq(args, TypeTree(args.map(_.tpe).reduce(_ | _)))))
 
-      if isReflectSelectable
-      then untpd.Apply(base, handled.flatten)
-      else handled.foldLeft(base)((base, args) => untpd.Apply(base, args))
+      untpd.Apply(base, handledFlat)
     }
 
     def structuralCall(selectorName: TermName, classOfs: => List[Tree]) = {
@@ -265,7 +262,7 @@ trait Dynamic {
        */
       def maybeBoxingCast(tpe: Type) =
         val maybeBoxed =
-          if tpe.classSymbol.isDerivedValueClass && qual.tpe <:< defn.ReflectSelectableTypeRef then
+          if tpe.classSymbol.isDerivedValueClass && qual.tpe.isReflectSelectableTypeRef then
             val genericUnderlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass)
             val underlying = tpe.select(genericUnderlying).widen.resultType
             New(tpe.widen, tree.cast(underlying) :: Nil)
@@ -295,7 +292,7 @@ trait Dynamic {
               fail(i"has a parameter type with an unstable erasure") :: Nil
             else
               TypeErasure.erasure(tpe).asInstanceOf[MethodType].paramInfos.map { tpe =>
-                if ValueClasses.isDerivedValueClass(tpe.widen.classSymbol) then
+                if tpe.widen.classSymbol.isDerivedValueClass then
                   clsOf(ValueClasses.valueClassUnbox(tpe.classSymbol.asClass).info)
                 else
                   clsOf(tpe)

tests/run/i14340.scala

@@ -1,8 +1,8 @@
 class Container1 extends reflect.Selectable
 
-class Container2(values: Map[String, Any], methods: Map[String, Int => Any]) extends Selectable:
+class Container2(values: Map[String, Any], methods: Map[String, Seq[Int] => Any]) extends Selectable:
   def selectDynamic(name: String) = values(name)
-  def applyDynamic(name: String)(arg: Int) = methods(name)(arg)
+  def applyDynamic(name: String)(arg: Int*) = methods(name)(arg)
 
 class Foo(val value: Int) extends AnyVal
 class Bar[A](val value: A) extends AnyVal
@@ -29,7 +29,7 @@ object Helpers:
   )
 
   val cont2methods = Map(
-    "fooFromInt" -> { (i: Int) => Foo(i) }
+    "fooFromInt" -> { (i: Seq[Int]) => Foo(i.head) }
   )
 
   val cont2 = Container2(cont2values, cont2methods).asInstanceOf[Container2 {
@@ -39,7 +39,7 @@ object Helpers:
     def qux2: Bar[Container2 { def foo: Foo }]
     def fooFromInt(i: Int): Foo
   }]
-  
+
 
   println(cont1.foo.value)
   println(cont2.foo.value)
@@ -49,7 +49,7 @@ object Helpers:
 
   println(cont1.qux1.value.foo.value)
   println(cont2.qux1.value.foo.value)
-  
+
   println(cont1.qux2.value.foo.value)
   println(cont2.qux2.value.foo.value)
 

tests/run/i16995.check

@@ -1,10 +1,62 @@
-1
-check
-6
-7
-5
-3
-3
-3
-7
-3
+foo
+foo0
+fooI 1
+fooN 1
+fooII 1 2
+fooNN 1 2
+fooIvarargs 1 2
+fooNvarargs 1 2
+fooIseq 1 2
+fooNseq 1 2
+fooIIvarargs 1 2
+fooNNvarargs 1 2
+fooI_I 1 2
+fooN_N 1 2
+foo0_II 1 2
+foo0_NN 1 2
+foo0_Ivarargs 1 2
+foo0_Nvarargs 1 2
+foo0_I_I 1 2
+foo0_N_N 1 2
+
+foo
+foo0 
+fooI 1
+fooN 1
+fooII 1 2
+fooNN 1 2
+fooIvarargs 1 2
+fooNvarargs 1 2
+fooIseq 1 2
+fooNseq 1 2
+fooIIvarargs 1 2 3
+fooNNvarargs 1 2
+fooI_I 1 2
+fooN_N 1 2
+foo0_II 1 2
+foo0_NN 1 2
+foo0_Ivarargs 1 2
+foo0_Nvarargs 1 2
+foo0_I_I 1 2
+foo0_N_N 1 2
+
+foo
+foo0 
+fooI 1
+fooN 1
+fooII 1 2
+fooNN 1 2
+fooIvarargs 1 2
+fooNvarargs 1 2
+fooIseq 1 2
+fooNseq 1 2
+fooIIvarargs 1 2
+fooNNvarargs 1 2
+fooI_I 1 2
+fooN_N 1 2
+foo0_II 1 2
+foo0_NN 1 2
+foo0_Ivarargs 1 2
+foo0_Nvarargs 1 2
+foo0_I_I 1 2
+foo0_N_N 1 2