Update tests to use new syntax

Author: odersky

tests/bench/string-interpolation-macro/Macro.scala

@@ -9,8 +9,8 @@ object Macro {
     var res: Expr[String] = null
     for _ <- 0 to 5_000 do
       (strCtxExpr, argsExpr) match {
-        case ('{ StringContext(${Varargs(Exprs(parts))}: _*) }, Varargs(Exprs(args))) =>
-          res = Expr(StringContext(parts: _*).s(args: _*))
+        case ('{ StringContext(${Varargs(Exprs(parts))}*) }, Varargs(Exprs(args))) =>
+          res = Expr(StringContext(parts*).s(args*))
         case _ => ???
       }
     res

tests/fuzzy/86ffb5f29d6fcab5893656be0307f2b8933b1498.scala

@@ -3,5 +3,5 @@ def i1: Unit = {
 val i2: Unit = {
 def this(i3: Int): Unit => Unit = {
 val i4 = 0
-i3(i2) = i3.i5 contains i4+ 1 else 1 + (i4: _*) * (0 i5 else i7 =  + (classOf) < [Int](2)) }
+i3(i2) = i3.i5 contains i4+ 1 else 1 + (i4*) * (0 i5 else i7 =  + (classOf) < [Int](2)) }
 }

tests/fuzzy/AE-c00f7074d074a942f48e3e24845e7f7054b76b69.scala

@@ -1 +1 @@
-class I0 { List(null: _*) }
+class I0 { List(null*) }

tests/fuzzy/ba77fdb2a05d078e9c400f45d1fe12fa769a1c1f.scala

@@ -2,7 +2,7 @@ import language.List
 class i0 {
 def main(i1: Array[String]): Unit =
 try {
-case List(_, _: _*) => 0 case List(1, 2) => i2 :: i1 - 1 }
+case List(_, _*) => 0 case List(1, 2) => i2 :: i1 - 1 }
 println()
 case _
 (1

tests/fuzzy/ed71e8db3233023ed7a8795d01bbc03b6b063a8b.scala

@@ -1,6 +1,6 @@
 class i0 {
 def i1: Nothing = {
-def this(i2: Dynamic): Int = i2.i3(i4: _*)
+def this(i2: Dynamic): Int = i2.i3(i4*)
 }
 }
 var i3 = 0

tests/init/crash/i6858.scala

@@ -1,10 +1,10 @@
 object Test extends App {
-  inline def foo(ys: Int*): Unit = bar(ys: _*)
+  inline def foo(ys: Int*): Unit = bar(ys*)
   def bar(ys: Int*) = ()
 
   val xs: Array[Int] = new Array[Int](3)
-  foo(xs: _*)
+  foo(xs*)
 
   val ys: Seq[Int] = new Array[Int](3)
-  foo(ys: _*)
+  foo(ys*)
 }

tests/neg-macros/i6432/Macro_1.scala

@@ -8,7 +8,7 @@ object Macro {
   def impl(sc: Expr[StringContext])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
     sc match {
-      case '{ StringContext(${Varargs(parts)}: _*) } =>
+      case '{ StringContext(${Varargs(parts)}*) } =>
         for (part @ Expr(s) <- parts)
           report.error(s, part.asTerm.pos)
     }

tests/neg-macros/i6432b/Macro_1.scala

@@ -8,7 +8,7 @@ object Macro {
   def impl(sc: Expr[StringContext])(using Quotes) : Expr[Unit] = {
     import quotes.reflect._
     sc match {
-      case '{ StringContext(${Varargs(parts)}: _*) } =>
+      case '{ StringContext(${Varargs(parts)}*) } =>
         for (part @ Expr(s) <- parts)
           report.error(s, part.asTerm.pos)
     }

tests/neg-macros/i6436.check

@@ -1,6 +1,6 @@
 -- Error: tests/neg-macros/i6436.scala:5:9 -----------------------------------------------------------------------------
-5 |    case '{ StringContext(${Varargs(parts)}: _*) } => // error
-  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+5 |    case '{ StringContext(${Varargs(parts)}*) } => // error
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |         no implicit argument of type scala.quoted.Quotes was found
 -- [E006] Not Found Error: tests/neg-macros/i6436.scala:6:34 -----------------------------------------------------------
 6 |      val ps: Seq[Expr[String]] = parts // error

tests/neg-macros/i6436.scala

@@ -2,7 +2,7 @@ import scala.quoted._
 
 def f(sc: quoted.Expr[StringContext]): Unit = {
   sc match {
-    case '{ StringContext(${Varargs(parts)}: _*) } => // error
+    case '{ StringContext(${Varargs(parts)}*) } => // error
       val ps: Seq[Expr[String]] = parts // error
   }
 }

tests/neg-macros/quote-interpolator-core-old.scala

@@ -19,7 +19,7 @@ object FInterpolation {
   def fInterpolation(sc: StringContext, args: Seq[Expr[Any]])(using Quotes): Expr[String] = {
     val str: Expr[String] = Expr(sc.parts.mkString(""))
     val args1: Expr[Seq[Any]] = liftSeq(args)
-    '{ $str.format($args1: _*) }
+    '{ $str.format($args1*) }
   }
 
   def hello = "hello"

tests/neg-macros/tasty-string-interpolator-position-a/Macro_1.scala

@@ -12,7 +12,7 @@ object FIntepolator {
   def apply(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes) : Expr[String] = {
     import quotes.reflect._
     report.error("there are no parts", strCtxExpr.asTerm.underlyingArgument.pos)
-    '{ ($strCtxExpr).s($argsExpr: _*) }
+    '{ ($strCtxExpr).s($argsExpr*) }
   }
 
 }

tests/neg-macros/tasty-string-interpolator-position-b/Macro_1.scala

@@ -11,7 +11,7 @@ object FIntepolator {
   def apply(strCtxExpr: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes) : Expr[String] = {
     import quotes.reflect._
     report.error("there are no args", argsExpr.asTerm.underlyingArgument.pos)
-    '{ ($strCtxExpr).s($argsExpr: _*) }
+    '{ ($strCtxExpr).s($argsExpr*) }
   }
 
 }

tests/neg-scalajs/reflective-calls.scala

@@ -28,12 +28,12 @@ object Test {
   def classOfVarArgs(): Unit = {
     val receiver: ReflectSel = ???
     val classOfs: List[Class[_]] = List(classOf[String], classOf[List[_]])
-    receiver.applyDynamic("foo", classOfs: _*)("bar", Nil) // error
+    receiver.applyDynamic("foo", classOfs*)("bar", Nil) // error
   }
 
   def argsVarArgs(): Unit = {
     val receiver: ReflectSel = ???
     val args: List[Any] = List("bar", Nil)
-    receiver.applyDynamic("foo", classOf[String], classOf[List[_]])(args: _*) // error
+    receiver.applyDynamic("foo", classOf[String], classOf[List[_]])(args*) // error
   }
 }

tests/neg/applydynamic_sip.scala

@@ -5,9 +5,9 @@ object Test extends App {
   val a = "a"
   val a2 = "a2"
 
-  qual.sel(a, a2: _*) // error
-  qual.sel(arg = a, a2: _*) // error
-  qual.sel(arg, arg2 = "a2", a2: _*) // error
+  qual.sel(a, a2*) // error
+  qual.sel(arg = a, a2*) // error
+  qual.sel(arg, arg2 = "a2", a2*) // error
 
   class Bad1 extends Dynamic {
     def selectDynamic(n: Int) = n

tests/neg/creator-ambiguous.scala

@@ -8,9 +8,9 @@ object Test:
 
   object Record:
 
-    inline def apply[R <: Record](elems: (String, Any)*) : R = new Record(elems: _*).asInstanceOf[R]
+    inline def apply[R <: Record](elems: (String, Any)*) : R = new Record(elems*).asInstanceOf[R]
 
-    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems: _*) // error: ambiguous overload
+    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems*) // error: ambiguous overload
 
   def apply(x: String): Test = Test(x ++ x)
 

tests/neg/i1643.scala

@@ -1,10 +1,10 @@
 trait T extends Array { // error // error
-  def t1(as: String*): Array[String] = { varargs1(as: _*) } // error
-  def t2(as: String*): Array[String] = { super.varargs1(as: _*) } // error
+  def t1(as: String*): Array[String] = { varargs1(as*) } // error
+  def t2(as: String*): Array[String] = { super.varargs1(as*) } // error
 }
 class C extends Base_1 { // error
-  def c1(as: String*): Array[String] = { varargs1(as: _*) } // error
-  def c2(as: String*): Array[String] = { super.varargs1(as: _*) } // error
+  def c1(as: String*): Array[String] = { varargs1(as*) } // error
+  def c2(as: String*): Array[String] = { super.varargs1(as*) } // error
 }
 object Test extends App {
   val t = new T {}  // error

tests/neg/i4922.scala

@@ -9,7 +9,7 @@ object A {
 object Main {
   def main(args: Array[String]): Unit = {
     val seq: Seq[Int] = 2 match {
-      case A(xs: _*) => xs // error // error
+      case A(xs*) => xs // error // error
     }
   }
 }

tests/neg/i4984.scala

@@ -26,13 +26,13 @@ object Array3 {
 object Test {
   def test(xs: Array[Int]): Int = xs match {
     case Array2(x, y)         => 1 // error
-    case Array2(x, y, xs: _*) => 2 // error
-    case Array2(xs: _*)       => 3 // error
+    case Array2(x, y, xs*) => 2 // error
+    case Array2(xs*)       => 3 // error
   }
 
   def test2(xs: Array[Int]): Int = xs match {
     case Array3(x, y)         => 1 // error
-    case Array3(x, y, xs: _*) => 2 // error
-    case Array3(xs: _*)       => 3 // error
+    case Array3(x, y, xs*) => 2 // error
+    case Array3(xs*)       => 3 // error
   }
 }

tests/neg/i533/Test.scala

@@ -3,6 +3,6 @@ object Test {
     val x = new Array[Int](1)
     x(0) = 10
     println(JA.get(x)) // error
-    println(JA.getVarargs(x: _*)) // now OK.
+    println(JA.getVarargs(x*)) // now OK.
   }
 }

tests/neg/i7972.scala

@@ -1,18 +1,18 @@
 object O {
-  def m1(a: Int*) = (a: _*) // error // error: Cannot return repeated parameter type Int*
-  def m2(a: Int*) = { // error: Cannot return repeated parameter type Int*
-    val b = (a: _*) // error // error: Cannot return repeated parameter type Int*
+  def m1(a: Int*) = (a*) // error
+  def m2(a: Int*) = {
+    val b = (a*) // error
     b
   }
   def m3(a: Int*): Any = {
-    val b = (a: _*) // error // error: Cannot return repeated parameter type Int*
+    val b = (a*) // error
     b
   }
-  def m4(a: 2*) = (a: _*) // error // error: Cannot return repeated parameter type Int*
+  def m4(a: 2*) = (a*) // error
 
 }
 
 class O(a: Int*) {
-  val m = (a: _*) // error // error: Cannot return repeated parameter type Int*
-}
+  val m = (a*) // error
 
+}

tests/neg/i8407.scala

@@ -1,5 +1,5 @@
 object Foo {
   val foo = Nil
   object foo // error
-  foo(foo: _*) // error
+  foo(foo*) // error
 }

tests/neg/i8715.scala

@@ -2,6 +2,6 @@ class A {
   def f(x: Any) = 1
 
   def foo(x: List[String]): Unit = {
-    f(x: _*) // error
+    f(x*) // error
   }
 }

tests/neg/i9298.scala

@@ -6,25 +6,25 @@ class repeatedArgs {
 
   def test(xs: immutable.Seq[String], ys: collection.Seq[String], zs: Array[String]): Unit = {
     bar("a", "b", "c")
-    bar(xs: _*)
-    bar(ys: _*) // error: immutable.Seq expected, found Seq
-    bar(zs: _*) // old-error: Remove (compiler generated) Array to Seq conversion in 2.13?
+    bar(xs*)
+    bar(ys*) // error: immutable.Seq expected, found Seq
+    bar(zs*) // old-error: Remove (compiler generated) Array to Seq conversion in 2.13?
 
     Paths.get("Hello", "World")
-    Paths.get("Hello", xs: _*)
-    Paths.get("Hello", ys: _*) // error: immutable.Seq expected, found Seq
-    Paths.get("Hello", zs: _*)
+    Paths.get("Hello", xs*)
+    Paths.get("Hello", ys*) // error: immutable.Seq expected, found Seq
+    Paths.get("Hello", zs*)
   }
 
   def test2(xs: immutable.Seq[String] | Null, ys: collection.Seq[String] | Null, zs: Array[String] | Null): Unit = {
     bar("a", "b", "c")
-    bar(xs: _*)
-    bar(ys: _*) // error: immutable.Seq expected, found Seq
-    bar(zs: _*) // old-error: Remove (compiler generated) Array to Seq conversion in 2.13?
+    bar(xs*)
+    bar(ys*) // error: immutable.Seq expected, found Seq
+    bar(zs*) // old-error: Remove (compiler generated) Array to Seq conversion in 2.13?
 
     Paths.get("Hello", "World")
-    Paths.get("Hello", xs: _*)
-    Paths.get("Hello", ys: _*) // error: immutable.Seq expected, found Seq
-    Paths.get("Hello", zs: _*)
+    Paths.get("Hello", xs*)
+    Paths.get("Hello", ys*) // error: immutable.Seq expected, found Seq
+    Paths.get("Hello", zs*)
   }
 }

tests/neg/i9749.scala

@@ -7,9 +7,9 @@ object Test {
     val is = List(1,2,3)
 
     is match {
-      case List(1, _*,) => // error // // error: bad use of _* (a sequence pattern must be the last pattern)
-                           // illegal start of simple pattern
-      case List(1, _*3,) => // error // error // error: illegal start of simple pattern
+      case List(1, _*,) => // error: pattern expected // error
+
+      case List(1, _*3,) => // error: pattern expected // error // error
       //case List(1, _*3:) =>  // poor recovery by parens
       case List(1, x*) => // ok
       case List(x*, 1) => // error: pattern expected
@@ -20,8 +20,8 @@ object Test {
 // good syntax, bad semantics, detected by typer
 //gowild.scala:14: error: star patterns must correspond with varargs parameters
     val K(x @ _*) = k
-    val K(ns @ _*, x) = k // error: bad use of _* (a sequence pattern must be the last pattern)
-    val (b, _ : _* ) = (5,6) // error: bad use of _* (sequence pattern not allowed)
+    val K(ns @ _*, x) = k // error: pattern expected
+    val (b, _ * ) = (5,6) // ok
 // no longer complains
 //bad-and-wild.scala:15: error: ')' expected but '}' found.
   }

tests/neg/repeatedArgs213.scala

@@ -6,5 +6,5 @@ object Foo {
 
 def foo(x: Foo): Unit =
   x match {
-    case Foo(x, _: _*) => assert(x == 3)
+    case Foo(x, _*) => assert(x == 3)
   }

tests/neg/t5702-neg-bad-and-wild.scala

@@ -2,9 +2,9 @@ sealed trait T
 
 case class C(xs: Int*) extends T
 
-def f(): Unit = (C(42): T) match { case C(xs: _*) => }
-def g(): Unit = (C(42): T) match { case C(_: _*) => }
+def f(): Unit = (C(42): T) match { case C(xs*) => }
+def g(): Unit = (C(42): T) match { case C(_*) => }
 
 def h(): Unit = (C(42): T) match
-  case C(5, _: _*) =>
-  case C(x, xs: _*) =>
+  case C(5, _*) =>
+  case C(x, xs*) =>

tests/patmat/i6490.scala

@@ -4,7 +4,7 @@ case class FailsChild2(a: Seq[String]) extends Fails
 object FailsTest {
   def matchOnVarArgsFirstFails(f: Fails) = {
     f match {
-      case VarArgs1(_: _*) => ???
+      case VarArgs1(_*) => ???
       // BUG: Without this line we should get a non-exhaustive match compiler error.
       //case FailsChild2(_) => ???
     }

tests/patmat/i8757.scala

@@ -11,14 +11,14 @@ case class Node2() extends Tree
 
 object Test {
   def transformTree(tree: Tree): Any = tree match {
-    case Node1(Foo(_: _*)) => ???
+    case Node1(Foo(_*)) => ???
   }
 
   def transformTree2(tree: Tree): Any = tree match {
-    case Node1(Foo(1, _: _*)) => ???
+    case Node1(Foo(1, _*)) => ???
   }
 
   def transformTree3(tree: Tree): Any = tree match {
-    case Node1(Foo(x, _: _*)) => ???
+    case Node1(Foo(x, _*)) => ???
   }
 }

tests/patmat/t8178.scala

@@ -13,8 +13,8 @@ object Test {
   }
 
   case class CS1(xs: Any*)
-  class CS2(xs: Seq[_]*) extends CS1(xs: _*)
-  class CS3(xs: IndexedSeq[Int]*) extends CS2(xs: _*)
+  class CS2(xs: Seq[_]*) extends CS1(xs*)
+  class CS3(xs: IndexedSeq[Int]*) extends CS2(xs*)
 
   case class H1(x: Int, y: Double)
   class H2(x: Double, y: Int) extends H1(y, x)

tests/patmat/t9232.scala

@@ -17,15 +17,15 @@ object Test {
     case _            => false
   }
   def f1seq(x: Any) = x match {
-    case Foo(x, ys : _*) => true
+    case Foo(x, ys *) => true
     case _               => false
   }
   def f2seq(x: Any) = x match {
-    case Foo(x, y, zs : _*) => true
+    case Foo(x, y, zs *) => true
     case _                  => false
   }
   def f3seq(x: Any) = x match {
-    case Foo(x, y, z, qs : _*) => true
+    case Foo(x, y, z, qs *) => true
     case _                     => false
   }