Tests for the new capture-variable syntax

Author: bracevac

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -4096,7 +4096,7 @@ object Parsers {
      *  TypeDefRHS ::= Type
      *               | CaptureSet -- under captureChecking
      */
-    def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = { // FIXME: ^-qualified members should automatically receive the CapSet interval!
+    def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
 
       def typeDefRHS(): Tree =
         if Feature.ccEnabled && in.token == LBRACE && !isDclIntroNext then

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

@@ -0,0 +1,39 @@
+import language.experimental.captureChecking
+import caps.*
+
+
+def main() =
+  trait Channel[T] extends caps.Capability:
+    def send(msg: T): Unit
+    def recv(): T
+
+  trait Logger extends caps.Capability:
+    def log(msg: String): Unit
+
+  // we can close over anything subsumed by the 'trusted' brand capability, but nothing else
+  def runSecure[C >: {trusted} <: {trusted}](block: () ->{C} Unit): Unit = block()
+
+  // This is a 'brand" capability to mark what can be mentioned in trusted code
+  object trusted extends caps.Capability
+
+  val trustedLogger: Logger^{trusted} = ???
+  val trustedChannel: Channel[String]^{trusted} = ???
+
+  val untrustedLogger: Logger^ = ???
+  val untrustedChannel: Channel[String]^ = ???
+
+  runSecure: () =>
+    trustedLogger.log("Hello from trusted code") // ok
+
+  runSecure: () =>
+    trustedChannel.send("I can send")
+    trustedLogger.log(trustedChannel.recv()) // ok
+
+  runSecure: () =>
+    "I am pure"                             // ok
+
+  runSecure: () => // error
+    untrustedLogger.log("I can't be used here")
+
+  runSecure: () => // error
+    untrustedChannel.send("I can't be used here")

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

@@ -0,0 +1,39 @@
+import language.experimental.captureChecking
+import caps.*
+
+
+def main() =
+  trait Channel[T] extends caps.Capability:
+    def send(msg: T): Unit
+    def recv(): T
+
+  trait Logger extends caps.Capability:
+    def log(msg: String): Unit
+
+  // we can close over anything subsumed by the 'trusted' brand capability, but nothing else
+  def runSecure(block: () ->{trusted} Unit): Unit = block()
+
+  // This is a 'brand" capability to mark what can be mentioned in trusted code
+  object trusted extends caps.Capability
+
+  val trustedLogger: Logger^{trusted} = ???
+  val trustedChannel: Channel[String]^{trusted} = ???
+
+  val untrustedLogger: Logger^ = ???
+  val untrustedChannel: Channel[String]^ = ???
+
+  runSecure: () =>
+    trustedLogger.log("Hello from trusted code") // ok
+
+  runSecure: () =>
+    trustedChannel.send("I can send")
+    trustedLogger.log(trustedChannel.recv()) // ok
+
+  runSecure: () =>
+    "I am pure" : Unit                             // ok
+
+  runSecure: () => // error
+    untrustedLogger.log("I can't be used here")
+
+  runSecure: () => // error
+    untrustedChannel.send("I can't be used here")

tests/neg-custom-args/captures/capset-members2.check

@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/capset-members2.scala:5:9 -----------------------------------------------------
+5 |  type C^[T] // error
+  |         ^
+  |         capture-set member declarations cannot have type parameters

tests/neg-custom-args/captures/capset-members2.scala

@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+import caps.*
+
+trait Foo:
+  type C^[T] // error
+

tests/neg-custom-args/captures/capset-members3.check

@@ -0,0 +1,6 @@
+-- [E095] Syntax Error: tests/neg-custom-args/captures/capset-members3.scala:5:10 --------------------------------------
+5 |  type C^ _ // error
+  |          ^
+  |          =, >:, or <: expected, but '_' found
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/capset-members3.scala

@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+import caps.*
+
+trait Foo:
+  type C^ _ // error
+

tests/neg-custom-args/captures/capset-members4.scala

@@ -0,0 +1,27 @@
+import language.experimental.captureChecking
+import language.experimental.modularity
+import caps.*
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  val z: Any^ = ???
+  def onlyWithZ[C^](using c: Contains[C, z.type]) = ???
+
+  trait IncludesZ[C^]:
+    val c: Contains[C, z.type]
+
+  trait Foo:
+    type C >: {x} <: {x,y,z} : IncludesZ
+
+  val foo: Foo = ???
+/*   new Foo {
+    override given IncludesZ[C]: // FIXME: doesn't work yet
+      val c: Contains[C, z.type] = summon
+    cap type C = {x,z}
+  } */
+  onlyWithZ(using foo.C.c)
+  onlyWithZ[{z}]
+  onlyWithZ[{x,z}]
+  onlyWithZ[{x,y,z}]
+  onlyWithZ[{x,y}] // error

tests/neg-custom-args/captures/lexical-control.scala

@@ -0,0 +1,27 @@
+import language.experimental.captureChecking
+import caps.*
+
+trait Label extends Capability:
+  type Fv^ // the capability set occurring freely in the `block` passed to `boundary` below.
+
+def boundary[T, C^](block: Label{type Fv = {C} } ->{C} T): T = ??? // link label and block capture set
+def suspend[U](label: Label)[D^ <: {label.Fv}](handler: () ->{D} U): U = ??? // note the path
+
+def test =
+  val x = 1
+  boundary: outer =>
+    val y = 2
+    boundary: inner =>
+      val z = 3
+      val w = suspend(outer) {() => z} // ok
+      val v = suspend(inner) {() => y} // ok
+      val u = suspend(inner): () =>
+        suspend(outer) {() => y} // ok
+        suspend(outer) {() => y} // ok
+        y
+      suspend(outer) { () => // error
+        suspend(outer) {() => y }
+      }
+      suspend(outer): () => // error  (leaks the inner label)
+        println(inner)
+        x + y + z

tests/pos-custom-args/captures/cap-paramlists.scala

@@ -0,0 +1,23 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  def foo[A >: {y} <: {x},
+          B^,
+          C^ <: {x},
+          D^ : Ctx,
+          E^ <: {C},
+          F^ <: {C},
+          G^ <: {x, y},
+          H >: {x} <: {x,y} : Ctx, T, U]()[I^ <: {y, G, H},
+                                               J^ <: {O.z},
+                                               K^ <: {x, O.z},
+                                               L^ <: {x, y, O.z},
+                                               M^ >: {x, y, O.z} <: {C} : Ctx,
+                                               N^ >: {x} <: {x},
+                                               O^ >: {O.z} <: {O.z}] = ???