Add interleaving tests

Author: Sporarum

tests/neg/interleaving-ab.scala

@@ -0,0 +1,8 @@
+object Ab:
+    given String = ""
+    given Double = 0
+
+    def ab[A][B](x: A)(using B): B = summon[B]
+
+    def test =
+        ab[Int](0: Int) // error

tests/neg/interleaving-nameCollision.scala

@@ -0,0 +1,3 @@
+object nameCollision:
+    def f[T](x: T)[U](y: U) = (x,y)
+    def f[T](x: T, y: T) = (x,y) // error

tests/neg/interleaving-params.scala

@@ -0,0 +1,7 @@
+class Params{
+    def bar[T](x: T)[T]: String = ??? // error
+    def zoo(x: Int)[T, U](x: U): T = ??? // error
+    def bbb[T <: U](x: U)[U]: U = ??? // error // error
+    def f0[T](implicit x: T)[U](y: U) = (x,y) // error
+    def f1[T](implicit x: T)[U] = (x,y) // error
+}

tests/neg/interleaving-typeApply.scala

@@ -0,0 +1,12 @@
+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 = ???
+
+    @main def test = {
+        f3[String]() // error
+        f5[Int][Unit] // error
+        f5[String][Unit] // error // error
+        f7[String]()[Unit] // error
+    }

tests/neg/interleaving-unmatched.scala

@@ -0,0 +1,3 @@
+object unmatched:
+    def f1[T (x: T)] = ??? // error
+    def f2(x: Any[)T] = ??? // error // error

tests/neg/overrides.scala

@@ -39,6 +39,7 @@ package p2 { // all being in the same package compiles fine
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 
   def next: T = ???
 
@@ -49,11 +50,22 @@ class B extends A[Int] {
   def f(x: Int)(y: Int) = y // error: needs `override' modifier
 
   f(2)()
+  override def b[T <: Int](x: Int)(y: String) = true // error
 
   override def next(): Int = ???    // error: incompatible type
 
 }
 
+class C extends A[String] {
+
+  override def f(x: String) = x // error
+
+  override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
+
+  override def next: Int = ???    // error: incompatible type
+
+}
+
 class X {
   def f: A[Int] = ???
 }

tests/pos/interweaving-ba.scala

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

tests/pos/interweaving-chainedParams.scala

@@ -0,0 +1,18 @@
+object chainedParams{
+
+    trait Chain{
+        type Tail <: Chain
+    }
+
+    def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
+
+    val self = new Chain{ type Tail = this.type }
+    val res: self.type = f(self)(self)(self)
+
+    type C <: Chain
+
+    val c3 = new Chain{ type Tail = C }
+    val c2 = new Chain{ type Tail = c3.type }
+    val c1 = new Chain{ type Tail = c2.type }
+    val u: C = f(c1)(c2)(c3)
+}

tests/pos/interweaving-classless.scala

@@ -0,0 +1,4 @@
+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)

tests/pos/interweaving-functorCurrying.scala

@@ -0,0 +1,17 @@
+object functorCurrying:
+  //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
+  //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
+  //modified to have type currying
+  trait Functor[F[_]]:
+    def map[A][B](x: F[A], f: A => B): F[B]
+
+
+  given Functor[List] with
+    def map[A][B](x: List[A], f: A => B): List[B] =
+      x.map(f)
+
+  def assertTransformation[F[_]: Functor][A][B](expected: F[B], original: F[A], mapping: A => B): Unit =
+    assert(expected == summon[Functor[F]].map(original, mapping))
+
+  @main def testCurrying =
+    assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")

tests/pos/interweaving-functorInterweaving.scala

@@ -0,0 +1,17 @@
+object functorInterweaving:
+  //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
+  //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
+  //modified to have type interveawing
+  trait Functor[F[_]]:
+    def map[A](x: F[A])[B](f: A => B): F[B]
+
+
+  given Functor[List] with
+    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 =
+    assert(expected == summon[Functor[F]].map(original)(mapping))
+
+  @main def testInterweaving =
+    assertTransformation(List("a", "b"))(List("a1", "b1")){elt => s"${elt}1"}

tests/pos/interweaving-nameCollision.scala

@@ -0,0 +1,5 @@
+import scala.annotation.targetName
+
+object nameCollision:
+    def f[T](x: T)[U](y: U) = (x,y)
+    @targetName("g") def f[T](x: T, y: T) = (x,y)

tests/pos/interweaving-newline.scala

@@ -0,0 +1,9 @@
+object newline {
+  def multipleLines
+        [T]
+        (x: T)
+        [U]
+        (using (T,U))
+        (y: U)
+        = ???
+}

tests/pos/interweaving-overload.scala

@@ -0,0 +1,19 @@
+
+class A{
+
+    def f1[T][U](x: Any) = ???
+    def f1[T][U](x: Int) = ???
+
+    f1(1)
+    f1("hello")
+
+    case class B[U](x: Int)
+    def b[U](x: Int) = B[U](x)
+
+    def f2[T]: [U] => Int => B[U] = [U] => (x: Int) => b[U](x)
+
+    f2(1)
+    f2[Any](1)
+    f2[Any][Any](1)
+
+}

tests/pos/interweaving-params.scala

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

tests/pos/interweaving-typeApply.scala

@@ -0,0 +1,22 @@
+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 = ???
+
+    @main def test = {
+        f0[Int][String]
+        f1[Int][String]
+        f2[Int][String]()
+        f3[Int][String]()
+        f4[Int][String]
+        f5[Int][String]
+        f5[Int][String][Unit]
+        f6[Int]()[Unit]
+        f7[Int]()[Unit]
+    }

tests/pos/overrides.scala

@@ -1,6 +1,7 @@
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 
 }
 
@@ -10,4 +11,6 @@ class B extends A[Int] {
 
   f(2)()
 
+  override def b[T <: Int](x: Int)[U >: Int](y: String) = true
+
 }