Update tests

Author: Sporarum

tests/neg/interleaving-ab.scala

@@ -2,7 +2,8 @@ object Ab:
     given String = ""
     given Double = 0
 
-    def ab[A][B](x: A)(using B): B = summon[B]
-
+    def illegal[A][B](x: A)(using B): B = summon[B] // error: Type parameter lists must be separated by a term or using parameter list
+    
+    def ab[A](x: A)[B](using B): B = summon[B]
     def test =
         ab[Int](0: Int) // error

tests/neg/interleaving-typeApply.scala

@@ -1,8 +1,8 @@
 object typeApply:
 
-    def f3[T <: Int][U <: String](): T => T = ???
-    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
-    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+    def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
+    def f5[T <: Int](using DummyImplicit)[U <: String]: [X <: Unit] => X => X = ???
+    def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
         f3[String]() // error

tests/neg/namedTypeParams.scala

@@ -17,13 +17,16 @@ object Test {
   def f[X, Y](x: X, y: Y): Int = ???
 
   f[X = Int, String](1, "") // error // error
-  /* Conflicts with Clause Interweaving, stems from named type parameters assuming one type clause
   f[X = Int][X = Int][Y = String](1, "") // error: illegal repeated type application
 
   f[X = Int][Y = String](1, "") // error: illegal repeated type application
   f[X = Int][String](1, "") // error: illegal repeated type application
 
   f[Y = String][X = Int](1, "") // error: illegal repeated type application
   f[Y = String][Int](1, "") // error: illegal repeated type application
-  */
+
+  def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
+
+  f2[Y = String][X = Int](1, "") // error: Y is undefined
+  f2[Y = String](1, "") // error: Y is undefined
 }

tests/pos/interleaving-ba.scala

@@ -4,8 +4,8 @@ object BA {
     given String = ""
     given Double = 0
 
-    def ba[B][A](x: A)(using B): B = summon[B]
+    def ba[A](x: A)[B](using B): B = summon[B]
 
-    def test = ba[String](0)
+    def test = ba(0)[String]
 
 }

tests/pos/interleaving-classless.scala

@@ -1,4 +1,4 @@
-def f1[T][U](x: T, y: U): (T, U) = (x, y)
+def f1[T]()[U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)
-def f3[T, U][V](x: T): U = ???
-def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)
+def f3[T, U](using DummyImplicit)[V](x: T): U = ???
+def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)

tests/pos/interleaving-functorInterleaving.scala renamed to tests/pos/interleaving-functor.scala

@@ -10,7 +10,7 @@ object functorInterweaving:
     def map[A](x: List[A])[B](f: A => B): List[B] =
       x.map(f)
 
-  def assertTransformation[F[_]: Functor][A](original: F[A])[B](expected: F[B])(mapping: A => B): Unit =
+  def assertTransformation[F[_]: Functor, A](original: F[A])[B](expected: F[B])(mapping: A => B): Unit =
     assert(expected == summon[Functor[F]].map(original)(mapping))
 
   @main def testInterweaving =

tests/pos/interleaving-functorCurrying.scala

@@ -1,8 +1,8 @@
 
 class A{
 
-    def f1[T][U](x: Any) = ???
-    def f1[T][U](x: Int) = ???
+    def f1[T](x: Any)[U] = ???
+    def f1[T](x: Int)[U] = ???
 
     f1(1)
     f1("hello")

tests/pos/interleaving-overload.scala

@@ -1,6 +1,6 @@
 class Params{
     type U
-    def foo[T](x: T)[U >: x.type <: T][L <: List[U]](l: L): L = ???
+    def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
     def aaa(x: U): U = ???
     def bbb[T <: U](x: U)[U]: U = ???
 }

tests/pos/interleaving-params.scala

@@ -1,13 +1,13 @@
 object typeApply:
 
     def f0[T]: [U] => T => T = ???
-    def f1[T][U]: T => T = ???
-    def f2[T][U](): T => T = ???
-    def f3[T <: Int][U <: String](): T => T = ???
-    def f4[T <: Int][U <: String]: T => T = ???
-    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
-    def f6[T <: Int][U <: String](): [X <: Unit] => X => X = ???
-    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+    def f1[T](using DummyImplicit)[U]: T => T = ???
+    def f2[T](using DummyImplicit)[U](): T => T = ???
+    def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
+    def f4[T <: Int](using DummyImplicit)[U <: String]: T => T = ???
+    def f5[T <: Int](using DummyImplicit)[U <: String]: [X <: Unit] => X => X = ???
+    def f6[T <: Int](using DummyImplicit)[U <: String](): [X <: Unit] => X => X = ???
+    def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
         f0[Int][String]

tests/pos/interleaving-typeApply.scala

@@ -9,4 +9,10 @@ object Test {
   f[Y = String](1, "")
 
 
+  def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
+
+  f2[X = Int][Y = String](1, "")
+  f2[X = Int](1, "")
+
+
 }