Tests for the new capture-variable syntax

Author: bracevac

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

@@ -4086,7 +4086,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}] = ???

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

@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+
+trait Bar:
+  type C^
+
+def useFoo[D^](x: Bar { type C = {D} } ): Any^{x.C} = ???

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

@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val bar = [C^, D <: {C}, E^ <: {C,x}, F >: {x,y} <: {C,E}] => (x: Int) => 1

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

@@ -0,0 +1,6 @@
+import language.experimental.captureChecking
+
+trait Foo[U^, V^, W^]:
+  type C = {caps.cap}
+  type D = {caps.cap}
+  type E >: {V,W} <: {U}

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

@@ -0,0 +1,16 @@
+import language.experimental.captureChecking
+import language.experimental.namedTypeArguments
+
+def test2 =
+  val x: Any^ = ???
+  def foo[A^, B^ >: {A}, T, U](x: Int) = 1
+  foo[{x}, {x}, Int, String](0)
+  foo[{}, {}, { def bar: Int }, { type D^ = {x} }](0)
+  trait Foo { type D^ }
+  foo[{}, {}, Foo, Foo](0)
+  foo[A = {x}, B = {x}](0)
+  foo[A = {x}](0)
+  foo[T = Int](0)
+  foo[T = Int, A = {x}](1)
+  foo[A = {x}, T = Int](1)
+  foo[B = {}, U = String, A = {}](1)

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

@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz  = () => [C^, D^ <: {C}, E^ <: {C,x}, F^ >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1

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

@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz2 = (i: Int) => [C^, D^ <: {C}, E^ <: {C,x}, F^ >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1

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

@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  val baz3 = (i: Int) => [C^, D^ <: {C}, E^ <: {C,x}] => () => [F^ >: {x,y} <: {C,E} : Ctx] => (x: Int) => 1

tests/pos-custom-args/captures/capset-members.scala

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

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

@@ -0,0 +1,16 @@
+import language.experimental.captureChecking
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+
+  abstract class Foo[A^, T]:
+    type C^ <: {A}
+  abstract class Bar extends Foo[{x,y,O.z}, String]:
+    override type C^ <: {x,y}
+  class Baz extends Bar:
+    final override type C = {y}