Adapt tests to local roots

odersky · odersky · commit 50419ace1c99 · 2023-09-01T15:00:48.000+02:00
diff --git a/tests/neg-custom-args/captures/boundschecks2.scala b/tests/neg-custom-args/captures/boundschecks2.scala
@@ -8,6 +8,6 @@ object test {
 
   val foo: C[Tree^] = ??? // error
   type T = C[Tree^] // error
-  val bar: T -> T = ???
+  val bar: T -> T = ???  // error
   val baz: C[Tree^] -> Unit = ??? // error
 }
diff --git a/tests/neg-custom-args/captures/ctest.scala b/tests/neg-custom-args/captures/ctest.scala
diff --git a/tests/neg-custom-args/captures/filevar.scala b/tests/neg-custom-args/captures/filevar.scala
@@ -5,14 +5,14 @@ class File:
   def write(x: String): Unit = ???
 
 class Service:
-  var file: File^ = uninitialized  // error
+  var file: File^ = uninitialized
   def log = file.write("log")
 
-def withFile[T](op: (f: File^) => T): T =
+def withFile[T](op: (l: caps.Root) ?-> (f: File^{l}) => T): T =
   op(new File)
 
 def test =
   withFile: f =>
     val o = Service()
-    o.file = f
+    o.file = f  // error
     o.log
diff --git a/tests/neg-custom-args/captures/i15049.scala b/tests/neg-custom-args/captures/i15049.scala
@@ -2,7 +2,7 @@ class Session:
   def request = "Response"
 class Foo:
   private val session: Session^{cap} = new Session
-  def withSession[sealed T](f: (Session^{cap}) => T): T = f(session)
+  def withSession[T](f: (local: caps.Root) ?-> (Session^{local}) => T): T = f(session)
 
 def Test: Unit =
   val f = new Foo
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
@@ -6,8 +6,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:46 ---------------------------------------
 20 |    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
    |                                          ^^^^^^^
-   |                                          Found:    (C{val arg: C^}^{c} => Unit) ->{c} Unit
-   |                                          Required: (C^ => Unit) -> Unit
+   |            Found:    (C{val arg: C^{cap[C]}}^{c} ->{'cap[..main1](from instantiating box1), c} Unit) ->{c} Unit
+   |            Required: (C^ => Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/i15772.scala:26:26 ------------------------------------------------------------
@@ -18,15 +18,28 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:35 ---------------------------------------
 27 |    val boxed2 : Observe[C^] = box2(c)  // error
    |                               ^^^^^^^
-   |                               Found:    (C{val arg: C^}^{c} => Unit) ->{c} Unit
-   |                               Required: Observe[C^]
+   |            Found:    (C{val arg: C^{cap[C]}}^{c} ->{'cap[..main2](from instantiating box2), c} Unit) ->{c} Unit
+   |            Required: (C^ => Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:33 ---------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:34 ---------------------------------------
 33 |  val boxed2 : Observe[C]^ = box2(c) // error
-   |                             ^^^^^^^
-   |                             Found:    (C{val arg: C^}^ => Unit) ->? Unit
-   |                             Required: Observe[C]^
+   |                                  ^
+   |                                  Found:    box C^{cap[c]}
+   |                                  Required: box C{val arg: C^?}^?
+   |
+   |                                  Note that reference (cap[c] : caps.Root), defined at level 2
+   |                                  cannot be included in outer capture set ?, defined at level 1 in method main3
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:34:29 ---------------------------------------
+34 |  boxed2((cap: C^) => unsafe(c)) // error
+   |                             ^
+   |                             Found:    C^{cap[c]}
+   |                             Required: C^{'cap[..main3](from instantiating unsafe)}
+   |
+   |                             Note that reference (cap[c] : caps.Root), defined at level 2
+   |                             cannot be included in outer capture set ?, defined at level 1 in method main3
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:44:2 ----------------------------------------
@@ -35,4 +48,7 @@
    |  Found:    () ->{x} Unit
    |  Required: () -> Unit
    |
+   |  Note that reference (cap[c] : caps.Root), defined at level 2
+   |  cannot be included in outer capture set ?, defined at level 1 in method main3
+   |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/i15772.scala b/tests/neg-custom-args/captures/i15772.scala
@@ -31,7 +31,7 @@ def main2(x: C^) : () -> Int =
 def main3(x: C^) =
   def c : C^ = new C(x)
   val boxed2 : Observe[C]^ = box2(c) // error
-  boxed2((cap: C^) => unsafe(c))
+  boxed2((cap: C^) => unsafe(c)) // error
   0
 
 trait File:
diff --git a/tests/neg-custom-args/captures/i15923.scala b/tests/neg-custom-args/captures/i15923.scala
@@ -3,12 +3,12 @@ type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
 def bar() = {
-  def withCap[sealed X](op: (Cap^) => X): X = {
-    val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }
+  def withCap[X](op: (lcap: caps.Root) ?-> Cap^{lcap} => X): X = {
+    val cap: Cap = new Cap { def use() = { println("cap is used"); 0 } }
     val result = op(cap)
     result
   }
 
-  val leak = withCap(cap => mkId(cap))  // error
+  val leak = withCap(cap => mkId(cap))  // error // error
   leak { cap => cap.use() }
 }
diff --git a/tests/neg-custom-args/captures/leaked-curried.check b/tests/neg-custom-args/captures/leaked-curried.check
@@ -1,4 +1,11 @@
--- Error: tests/neg-custom-args/captures/leaked-curried.scala:12:52 ----------------------------------------------------
-12 |      val get: () ->{} () ->{io} Cap^ = () => () => io // error
-   |                                                    ^^
-   |(io : Cap^) cannot be referenced here; it is not included in the allowed capture set {} of pure base class trait Pure
+-- Error: tests/neg-custom-args/captures/leaked-curried.scala:13:20 ----------------------------------------------------
+13 |        () => () => io // error
+   |                    ^^
+   |(io : Cap^{cap[main]}) cannot be referenced here; it is not included in the allowed capture set {} of pure base class trait Pure
+-- [E164] Declaration Error: tests/neg-custom-args/captures/leaked-curried.scala:12:10 ---------------------------------
+12 |      val get: () ->{} () ->{io} Cap^ = // error
+   |          ^
+   |          error overriding value get in trait Box of type () -> () ->{cap[Box]} Cap^{cap[Box]};
+   |            value get of type () -> () ->{io} Cap^ has incompatible type
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/leaked-curried.scala b/tests/neg-custom-args/captures/leaked-curried.scala
@@ -1,14 +1,15 @@
 trait Cap:
   def use(): Unit
 
-def withCap[sealed T](op: (x: Cap^) => T): T = ???
+def withCap[T](op: (x: Cap^) => T): T = ???
 
 trait Box:
   val get: () ->{} () ->{cap} Cap^
 
 def main(): Unit =
   val leaked = withCap: (io: Cap^) =>
     class Foo extends Box, Pure:
-      val get: () ->{} () ->{io} Cap^ = () => () => io // error
+      val get: () ->{} () ->{io} Cap^ = // error
+        () => () => io // error
     new Foo
   val bad = leaked.get()().use()  // using a leaked capability
diff --git a/tests/neg-custom-args/captures/refs.scala b/tests/neg-custom-args/captures/refs.scala
@@ -4,35 +4,35 @@ class Ref[T](init: T):
   var x: T = init
   def setX(x: T): Unit = this.x = x
 
-def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+def usingLogFile[T](op: (local: caps.Root) ?-> FileOutputStream^{local} => T): T =
   val logFile = FileOutputStream("log")
   val result = op(logFile)
   logFile.close()
   result
 
 type Proc = () => Unit
 def test1 =
-  usingLogFile[Proc]: f => // error
-    () =>
-      f.write(1)
-      ()
+  usingLogFile[Proc]: (local: caps.Root) ?=> // error (but with a hard to parse error message)
+    (f: FileOutputStream^{local}) =>
+      () => f.write(1)  // this line has type () ->{local} Unit, but usingLogFile
+                        // requires Proc, which expands to () -> 'cap[..test1](from instantiating usingLogFile)
 
 def test2 =
   val r = new Ref[Proc](() => ())
    usingLogFile[Unit]: f =>
-    r.setX(() => f.write(10))  // should be error
+    r.setX(() => f.write(10))  // error
   r.x() // crash: f is closed at that point
 
 def test3 =
   val r = new Ref[Proc](() => ())
    usingLogFile[Unit]: f =>
-    r.x = () => f.write(10)   // should be error
+    r.x = () => f.write(10)   // error
   r.x() // crash: f is closed at that point
 
 def test4 =
-  var r: Proc = () => ()  // error
+  var r: Proc = () => ()
    usingLogFile[Unit]: f =>
-    r = () => f.write(10)
+    r = () => f.write(10)  // error
   r() // crash: f is closed at that point
 
 
diff --git a/tests/neg-custom-args/captures/sealed-leaks.scala b/tests/neg-custom-args/captures/sealed-leaks.scala
@@ -2,7 +2,7 @@
 import java.io.*
 def Test2 =
 
-  def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+  def usingLogFile[T](op: (l: caps.Root) ?-> FileOutputStream^{l} => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -11,10 +11,10 @@ def Test2 =
   val later = usingLogFile { f => () => f.write(0) } // error
   val later2 = usingLogFile[(() => Unit) | Null] { f => () => f.write(0) } // error
 
-  var x: (FileOutputStream^) | Null = null  // error
+  var x: (FileOutputStream^) | Null = null
   def foo(f: FileOutputStream^, g: FileOutputStream^) =
     var y = if ??? then f else g  // error
 
-  usingLogFile { f => x = f }
+  usingLogFile { f => x = f }  // error
 
   later()
diff --git a/tests/neg-custom-args/captures/simple-escapes.check b/tests/neg-custom-args/captures/simple-escapes.check
@@ -0,0 +1,11 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/simple-escapes.scala:16:10 -------------------------------
+16 |    foo = f      // error
+   |          ^
+   |          Found:    box FileOutputStream^{f}
+   |          Required: box FileOutputStream^{cap[Test1]}
+   |
+   | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/simple-escapes.scala:19:15 ----------------------------------------------------
+19 |  val later2 = usingLogFile { local => f => // error
+   |               ^^^^^^^^^^^^
+   |               escaping local reference local.type
diff --git a/tests/neg-custom-args/captures/simple-escapes.scala b/tests/neg-custom-args/captures/simple-escapes.scala
@@ -0,0 +1,24 @@
+class FileOutputStream(str: String):
+  def close(): Unit = ()
+  def write(x: Int): Unit = ()
+
+def Test1 =
+
+  def usingLogFile[T](op: (local: caps.Root) -> FileOutputStream^{local} => T): T =
+    val logFile = FileOutputStream("log")
+    val result = op(caps.cap)(logFile)
+    logFile.close()
+    result
+
+  var foo: FileOutputStream^ = FileOutputStream("")
+
+  val later1 = usingLogFile { local => f =>
+    foo = f      // error
+    () => ()
+  }
+  val later2 = usingLogFile { local => f => // error
+    () => f.write(0)
+  }
+  later1()
+  later2()
+
diff --git a/tests/neg-custom-args/captures/stack-alloc.scala b/tests/neg-custom-args/captures/stack-alloc.scala
@@ -5,7 +5,7 @@ class Pooled
 val stack = mutable.ArrayBuffer[Pooled]()
 var nextFree = 0
 
-def withFreshPooled[sealed T](op: Pooled^ => T): T =
+def withFreshPooled[T](op: (lcap: caps.Root) ?-> Pooled^{lcap} => T): T =
   if nextFree >= stack.size then stack.append(new Pooled)
   val pooled = stack(nextFree)
   nextFree = nextFree + 1
diff --git a/tests/neg-custom-args/captures/usingLogFile.scala b/tests/neg-custom-args/captures/usingLogFile.scala
@@ -3,7 +3,7 @@ import annotation.capability
 
 object Test1:
 
-  def usingLogFile[sealed T](op: FileOutputStream => T): T =
+  def usingLogFile[T](op: (local: caps.Root) ?-> FileOutputStream => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -14,7 +14,7 @@ object Test1:
 
 object Test2:
 
-  def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+  def usingLogFile[T](op: (local: caps.Root) ?-> FileOutputStream^{local} => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -38,7 +38,7 @@ object Test2:
 
 object Test3:
 
-  def usingLogFile[sealed T](op: FileOutputStream^ => T) =
+  def usingLogFile[T](op: (local: caps.Root) ?-> FileOutputStream^{local} => T) =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -50,7 +50,7 @@ object Test4:
   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: (local: caps.Root) ?-> OutputStream^{local} => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
@@ -63,7 +63,7 @@ object Test4:
     later(1)
 
 
-  def usingLogger[sealed T](f: OutputStream^, op: Logger^{f} => T): T =
+  def usingLogger[T](f: OutputStream^, op: (local: caps.Root) ?-> Logger^{f} => T): T =
     val logger = Logger(f)
     op(logger)
 
diff --git a/tests/neg-custom-args/captures/vars.scala b/tests/neg-custom-args/captures/vars.scala
@@ -9,27 +9,30 @@ def test(cap1: Cap, cap2: Cap) =
   val zc: () ->{cap1} String = z
   val z2 = () => { x = identity }
   val z2c: () -> Unit = z2  // error
+  var a: String => String = f
 
-  var a: String => String = f // error
-  var b: List[String => String] = Nil // error
+  var b: List[String => String] = Nil
   val u = a  // was error, now ok
   a("")  // was error, now ok
   b.head // was error, now ok
 
   def scope =
     val cap3: Cap = CC()
     def g(x: String): String = if cap3 == cap3 then "" else "a"
-    a = g
-    b = List(g)
+    def h(): String = ""
+    a = x => g(x)      // error
+    a = g      // error
+
+    b = List(g) // error
     val gc = g
     g
 
-  val s = scope
-  val sc: String => String = scope
+  val s = scope // error (but should be OK, we need to allow poly-captures)
+  val sc: String => String = scope // error (but should also be OK)
 
-  def local[sealed T](op: Cap -> T): T = op(CC())
+  def local[T](op: (local: caps.Root) -> CC^{local} -> T): T = op(caps.cap)(CC())
 
-  local { cap3 => // error
+  local { root => cap3 => // error
     def g(x: String): String = if cap3 == cap3 then "" else "a"
     g
   }
@@ -39,4 +42,4 @@ def test(cap1: Cap, cap2: Cap) =
 
   val r = Ref()
   r.elem = f
-  val fc = r.elem
+  val fc = r.elem

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ object test {`
`8`	`8`
`9`	`9`	`val foo: C[Tree^] = ??? // error`
`10`	`10`	`type T = C[Tree^] // error`
`11`		`- val bar: T -> T = ???`
	`11`	`+ val bar: T -> T = ??? // error`
`12`	`12`	`val baz: C[Tree^] -> Unit = ??? // error`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ def main2(x: C^) : () -> Int =`
`31`	`31`	`def main3(x: C^) =`
`32`	`32`	`def c : C^ = new C(x)`
`33`	`33`	`val boxed2 : Observe[C]^ = box2(c) // error`
`34`		`- boxed2((cap: C^) => unsafe(c))`
	`34`	`+ boxed2((cap: C^) => unsafe(c)) // error`
`35`	`35`	`0`
`36`	`36`
`37`	`37`	`trait File:`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,12 @@ type Id[X] = [T] -> (op: X => T) -> T`
`3`	`3`	`def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)`
`4`	`4`
`5`	`5`	`def bar() = {`
`6`		`- def withCap[sealed X](op: (Cap^) => X): X = {`
`7`		`- val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }`
	`6`	`+ def withCap[X](op: (lcap: caps.Root) ?-> Cap^{lcap} => X): X = {`
	`7`	`+ val cap: Cap = new Cap { def use() = { println("cap is used"); 0 } }`
`8`	`8`	`val result = op(cap)`
`9`	`9`	`result`
`10`	`10`	`}`
`11`	`11`
`12`		`- val leak = withCap(cap => mkId(cap)) // error`
	`12`	`+ val leak = withCap(cap => mkId(cap)) // error // error`
`13`	`13`	`leak { cap => cap.use() }`
`14`	`14`	`}`