Add import to tests

Sporarum · Sporarum · commit 1e402f3e4431 · 2023-02-03T11:47:12.000+01:00
diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -52,7 +52,12 @@ extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Num
 extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f11(b: Any)(c: Any): Any
   = ???
+
+import scala.language.experimental.clauseInterleaving
+
+extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f13(b: Any)[T](c: T): T
   = ???
   def f14[D](b: D)[T](c: T): T
   = ???
+
diff --git a/scaladoc-testcases/src/tests/methodsAndConstructors.scala b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
@@ -60,5 +60,8 @@ class Methods:
  def withImplicitParam2(v: String)(implicit ab: Double, a: Int, b: String): String
  = ???
 
+ import scala.language.experimental.clauseInterleaving
+
  def clauseInterleaving[T](x: T)[U](y: U)(using (T, U)): (T, U)
  = ???
+
diff --git a/tests/neg/interleaving-ab.scala b/tests/neg/interleaving-ab.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object Ab:
   given String = ""
   given Double = 0
diff --git a/tests/neg/interleaving-params.scala b/tests/neg/interleaving-params.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 class Params{
     def bar[T](x: T)[T]: String = ??? // error
     def zoo(x: Int)[T, U](x: U): T = ??? // error
diff --git a/tests/neg/interleaving-signatureCollision.scala b/tests/neg/interleaving-signatureCollision.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object signatureCollision:
     def f[T](x: T)[U](y: U) = (x,y)
     def f[T](x: T, y: T) = (x,y) // error
diff --git a/tests/neg/interleaving-typeApply.check b/tests/neg/interleaving-typeApply.check
@@ -1,29 +1,29 @@
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:8:11 ---------------------------------------------
-8 |        f3[String]() // error
-  |           ^
-  |           Type argument String does not conform to upper bound Int
-  |
-  | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:9:16 ---------------------------------------------
-9 |        f5[Int][Unit] // error
-  |                ^
-  |                Type argument Unit does not conform to upper bound String
-  |
-  | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:19 --------------------------------------------
-10 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
+10 |        f3[String]() // error
+   |           ^
+   |           Type argument String does not conform to upper bound Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:16 --------------------------------------------
+11 |        f5[Int][Unit] // error
+   |                ^
+   |                Type argument Unit does not conform to upper bound String
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:19 --------------------------------------------
+12 |        f5[String][Unit] // error // error
    |                   ^
    |                   Type argument Unit does not conform to upper bound String
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
-10 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:11 --------------------------------------------
+12 |        f5[String][Unit] // error // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:11 --------------------------------------------
-11 |        f7[String]()[Unit] // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:13:11 --------------------------------------------
+13 |        f7[String]()[Unit] // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |
diff --git a/tests/neg/interleaving-typeApply.scala b/tests/neg/interleaving-typeApply.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object typeApply:
     
     def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
diff --git a/tests/neg/interleaving-unmatched.scala b/tests/neg/interleaving-unmatched.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object unmatched:
     def f1[T (x: T)] = ??? // error
     def f2(x: Any[)T] = ??? // error // error
diff --git a/tests/neg/namedTypeParams.check b/tests/neg/namedTypeParams.check
@@ -92,11 +92,11 @@
    |  illegal repeated type application
    |  You might have meant something like:
    |  Test.f[Y = String, Int]
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:32:9 -----------------------------------------------------------
-32 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
+33 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
-33 |  f2[Y = String](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:34:9 -----------------------------------------------------------
+34 |  f2[Y = String](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.
diff --git a/tests/neg/namedTypeParams.scala b/tests/neg/namedTypeParams.scala
@@ -27,6 +27,7 @@ object Test:
 
 object TestInterleaving:
   import language.experimental.namedTypeArguments
+  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[Y = String][X = Int](1, "") // error: Y is undefined
diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
@@ -39,30 +39,36 @@ 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 = ???
 
+  import scala.language.experimental.clauseInterleaving
+
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 }
 
 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
+
+  import scala.language.experimental.clauseInterleaving
+
+  override def b[T <: Int](x: Int)(y: String) = true // error
 }
 
 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
 
+  import scala.language.experimental.clauseInterleaving
+
+  override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
 }
 
 class X {
diff --git a/tests/pos/interleaving-ba.scala b/tests/pos/interleaving-ba.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 
 object BA {
     given String = ""
diff --git a/tests/pos/interleaving-chainedParams.scala b/tests/pos/interleaving-chainedParams.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object chainedParams{
 
   trait Chain{
diff --git a/tests/pos/interleaving-classless.scala b/tests/pos/interleaving-classless.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 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](using DummyImplicit)[V](x: T): U = ???
diff --git a/tests/pos/interleaving-functor.scala b/tests/pos/interleaving-functor.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object functorInterleaving:
   //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
   //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
diff --git a/tests/pos/interleaving-newline.scala b/tests/pos/interleaving-newline.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object newline {
   def multipleLines
         [T]
diff --git a/tests/pos/interleaving-overload.scala b/tests/pos/interleaving-overload.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 
 class A{
 
diff --git a/tests/pos/interleaving-params.scala b/tests/pos/interleaving-params.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 class Params{
     type U
     def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
diff --git a/tests/pos/interleaving-signatureCollision.scala b/tests/pos/interleaving-signatureCollision.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 import scala.annotation.targetName
 
 object signatureCollision:
diff --git a/tests/pos/interleaving-typeApply.scala b/tests/pos/interleaving-typeApply.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object typeApply:
 
     def f0[T]: [U] => T => T = ???
@@ -10,6 +12,7 @@ object typeApply:
     def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
+        import scala.language.experimental.namedTypeArguments
         f0[Int][String]
         f1[Int][String]
         f2[Int][String]()
diff --git a/tests/pos/namedTypeParams.scala b/tests/pos/namedTypeParams.scala
@@ -1,4 +1,5 @@
 import language.experimental.namedTypeArguments
+
 object Test {
 
   def f[X, Y](x: X, y: Y): Int = ???
@@ -7,7 +8,10 @@ object Test {
   f[X = Int, Y = String](1, "")
   f[X = Int](1, "")
   f[Y = String](1, "")
+}
 
+object TestInterleaving{
+  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[X = Int][Y = String](1, "")
diff --git a/tests/pos/overrides.scala b/tests/pos/overrides.scala
@@ -1,16 +1,21 @@
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  
+  import scala.language.experimental.clauseInterleaving
+
   def b[U <: T](x: Int)[V >: T](y: String) = false
 
 }
-
 class B extends A[Int] {
 
   override def f(x: Int)(y: Int) = y
 
   f(2)()
 
+
+  import scala.language.experimental.clauseInterleaving
+
   override def b[T <: Int](x: Int)[U >: Int](y: String) = true
 
 }
diff --git a/tests/run/interleaving.scala b/tests/run/interleaving.scala
@@ -1,4 +1,5 @@
 object Test extends App {
+  import scala.language.experimental.clauseInterleaving
   trait Key { type Value }
   trait DB {
     def getOrElse(k: Key)[V >: k.Value](default: V): V // dependent type parameter

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+import scala.language.experimental.clauseInterleaving`
	`2`	`+`
`1`	`3`	`object Ab:`
`2`	`4`	`given String = ""`
`3`	`5`	`given Double = 0`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+import scala.language.experimental.clauseInterleaving`
	`2`	`+`
`1`	`3`	`class Params{`
`2`	`4`	`def bar[T](x: T)[T]: String = ??? // error`
`3`	`5`	`def zoo(x: Int)[T, U](x: U): T = ??? // error`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+import scala.language.experimental.clauseInterleaving`
	`2`	`+`
`1`	`3`	`object typeApply:`
`2`	`4`
`3`	`5`	`def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???`