Drop all uses of sealed on type parameters in tests

Author: odersky

tests/neg-custom-args/captures/capt-test.scala

@@ -14,7 +14,7 @@ def raise[E <: Exception](e: E): Nothing throws E = throw e
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def handle[E <: Exception, sealed R <: Top](op: (CT[E] @retains(caps.cap)) => R)(handler: E => R): R =
+def handle[E <: Exception,  R <: Top](op: (CT[E] @retains(caps.cap)) => R)(handler: E => R): R =
   val x: CT[E] = ???
   try op(x)
   catch case ex: E => handler(ex)

tests/neg-custom-args/captures/heal-tparam-cs.scala

@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Capp { def use(): Unit }
 
-def localCap[sealed T](op: (c: Capp^) => T): T = ???
+def localCap[T](op: (c: Capp^) => T): T = ???
 
 def main(io: Capp^, net: Capp^): Unit = {
 
@@ -25,7 +25,7 @@ def main(io: Capp^, net: Capp^): Unit = {
       (c1: Capp^{io}) => () => { c1.use() }
     }
 
-  def localCap2[sealed T](op: (c: Capp^{io}) => T): T = ???
+  def localCap2[T](op: (c: Capp^{io}) => T): T = ???
 
   val test5: () ->{io} Unit =
     localCap2 { c =>  // ok

tests/neg-custom-args/captures/i15049.scala

@@ -2,7 +2,7 @@ class Session:
   def request = "Response"
 class Foo:
   private val session: Session^ = new Session
-  def withSession[sealed T](f: Session^ => T): T = f(session)
+  def withSession[T](f: Session^ => T): T = f(session)
 
 def Test: Unit =
   val f = new Foo

tests/neg-custom-args/captures/i15749a.scala

@@ -11,12 +11,12 @@ def test =
   def wrapper[T](x: T): Wrapper[T] =
     [X] => (op: T ->{cap} X) => op(x)
 
-  def strictMap[A <: Top, sealed B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
+  def strictMap[A <: Top,  B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
     mx((x: A) => wrapper(f(x)))
 
   def force[A](thunk: Unit ->{cap} A): A = thunk(u)
 
-  def forceWrapper[sealed A](mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[A](mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
     // Γ ⊢ mx: Wrapper[□ {cap} Unit => A]
     // `force` should be typed as ∀(□ {cap} Unit -> A) A, but it can not
     strictMap[Unit ->{cap} A, A](mx)(t => force[A](t)) // error

tests/neg-custom-args/captures/leaking-iterators.scala

@@ -39,7 +39,7 @@ end Iterator
 private final class ConcatIteratorCell[A](head: => IterableOnce[A]^):
   def headIterator: Iterator[A]^{this} = head.iterator
 
-def usingLogFile[sealed R](op: FileOutputStream^ => R): R =
+def usingLogFile[R](op: FileOutputStream^ => R): R =
   val logFile = FileOutputStream("log")
   val result = op(logFile)
   logFile.close()

tests/neg-custom-args/captures/reaches.scala

@@ -1,11 +1,11 @@
 class File:
   def write(): Unit = ???
 
-def usingFile[sealed T](f: File^ => T): T = ???
+def usingFile[T](f: File^ => T): T = ???
 
 type Proc = () => Unit
 
-class Ref[sealed T](init: T):
+class Ref[T](init: T):
   private var x: T = init
   def get: T = x
   def set(y: T) = { x = y }
@@ -45,7 +45,7 @@ def runAll3(xs: List[Proc]): Unit =
     next()
     cur.set(cur.get.tail: List[Proc])
 
-class Id[sealed -A, sealed +B >: A]():
+class Id[-A,  +B >: A]():
   def apply(a: A): B = a
 
 def test =

tests/neg-custom-args/captures/recursive-leaking-local-cap.scala

@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 trait Cap:
   def use: Int = 42
 
-def usingCap[sealed T](op: Cap^ => T): T = ???
+def usingCap[T](op: Cap^ => T): T = ???
 
 def badTest(): Unit =
   def bad(b: Boolean)(c: Cap^): Cap^{c} =

tests/neg-custom-args/captures/simple-using.scala

@@ -1,5 +1,5 @@
 import java.io.*
-def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+def usingLogFile[T](op: FileOutputStream^ => T): T =
   val logFile = FileOutputStream("log")
   val result = op(logFile)
   logFile.close()

tests/neg-custom-args/captures/try.scala

@@ -14,7 +14,7 @@ def raise[E <: Exception](e: E): Nothing throws E = throw e
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def handle[E <: Exception, sealed R <: Top](op: CT[E]^ => R)(handler: E => R): R =
+def handle[E <: Exception,  R <: Top](op: CT[E]^ => R)(handler: E => R): R =
   val x: CT[E] = ???
   try op(x)
   catch case ex: E => handler(ex)

tests/neg-custom-args/captures/usingFile.scala

@@ -7,7 +7,7 @@ object Test:
   class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
+  def usingFile[T](name: String, op: OutputStream^ => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()