Cleanup and Fix test files

Author: Sporarum

tests/pos/_typeInterweaving/ba.scala

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

tests/pos/_typeInterweaving/chainedParams.scala

@@ -1,6 +1,18 @@
+object chainedParams{
 
-class Chain{
-    type Tail <: Chain
-}
+    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)
 
-def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
+    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/_typeInterweaving/classless.scala

@@ -1,4 +1,3 @@
 def f1[T][U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)
-
-@main def test = f2(0)[String]("Hello")
+def f3[T, U][V](x: T): U = ???

tests/pos/_typeInterweaving/functorCurrying.scala

@@ -1,16 +1,17 @@
-//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]
+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)
+  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))
+  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 test =
-  assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")
+  @main def test =
+    assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")

tests/pos/_typeInterweaving/functorInterweaving.scala

@@ -1,16 +1,17 @@
-//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]
+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)
+  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))
+  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 test =
-  assertTransformation(List("a", "b"))(List("a1", "b1")){elt => s"${elt}1"}
+  @main def test =
+    assertTransformation(List("a", "b"))(List("a1", "b1")){elt => s"${elt}1"}

tests/pos/_typeInterweaving/higherKindedReturn.scala

@@ -1,3 +1,5 @@
 import scala.annotation.targetName
-def f[T](x: T)[U](y: U) = (x,y)
-@targetName("g") def f[T](x: T, y: T) = (x,y)
+
+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/_typeInterweaving/nameCollision.scala

@@ -1,4 +1,4 @@
-class Newline {
+object newline {
   def multipleLines
         [T]
         (x: T)

tests/pos/_typeInterweaving/newline.scala

@@ -0,0 +1,23 @@
+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] //only one that works when lines 1088 to 1089 of Applications.scala are uncommented
+        f1[Int][String]
+        f2[Int][String]()
+        f3[Int][String]()
+        f4[Int][String]
+        f5[Int][String]
+        f5[Int][Unit] // Should this work ?
+        f5[Int][String][Unit]
+        f6[Int]()[Unit]
+        f7[Int]()[Unit]
+    }