add box adaptation test cases

Author: Linyxus

tests/neg-custom-args/captures/box-adapt-boxing.scala

@@ -0,0 +1,38 @@
+trait Cap
+
+def main(io: {*} Cap, fs: {*} Cap): Unit = {
+  val test1: {} Unit -> Unit = _ => { // error
+    type Op = [T] -> ({io} T -> Unit) -> Unit
+    val f: ({io} Cap) -> Unit = ???
+    val op: Op = ???
+    op[{io} Cap](f)
+    // expected type of f: {io} (box {io} Cap) -> Unit
+    // actual type: ({io} Cap) -> Unit
+    // adapting f to the expected type will also
+    //   charge the environment with {io}
+  }
+
+  val test2: {} Unit -> Unit = _ => {
+    type Box[X] = X
+    type Op0[X] = Box[X] -> Unit
+    type Op1[X] = Unit -> Box[X]
+    val f: Unit -> ({io} Cap) -> Unit = ???
+    val test: {} Op1[{io} Op0[{io} Cap]] = f
+    // expected: {} Unit -> box {io} (box {io} Cap) -> Unit
+    // actual: Unit -> ({io} Cap) -> Unit
+    //
+    // although adapting `({io} Cap) -> Unit` to
+    // `box {io} (box {io} Cap) -> Unit` will leak the
+    // captured variables {io}, but since it is inside a box,
+    // we will charge neither the outer type nor the environment
+  }
+
+  val test3 = {
+    type Box[X] = X
+    type Id[X] = Box[X] -> Unit
+    type Op[X] = Unit -> Box[X]
+    val f: Unit -> ({io} Cap) -> Unit = ???
+    val g: Op[{fs} Id[{io} Cap]] = f // error
+    val h: {} Op[{io} Id[{io} Cap]] = f
+  }
+}

tests/neg-custom-args/captures/box-adapt-cases.scala

@@ -0,0 +1,29 @@
+trait Cap { def use(): Int }
+
+def test1(): Unit = {
+  type Id[X] = [T] -> (op: X => T) -> T
+
+  val x: Id[{*} Cap] = ???
+  x(cap => cap.use())  // error
+}
+
+def test2(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: X -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  x(cap => cap.use())  // error
+}
+
+def test3(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {io} X -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  x(cap => cap.use())  // ok
+}
+
+def test4(io: {*} Cap, fs: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {io} X -> T) -> T
+
+  val x: Id[{io, fs} Cap] = ???
+  x(cap => cap.use())  // error
+}

tests/neg-custom-args/captures/box-adapt-cov.scala

@@ -0,0 +1,14 @@
+trait Cap
+
+def test1(io: {*} Cap) = {
+  type Op[X] = [T] -> Unit -> X
+  val f: Op[{io} Cap] = ???
+  val x: [T] -> Unit -> ({io} Cap) = f  // error
+}
+
+def test2(io: {*} Cap) = {
+  type Op[X] = [T] -> Unit -> {io} X
+  val f: Op[{io} Cap] = ???
+  val x: Unit -> ({io} Cap) = f[Unit]  // error
+  val x1: {io} Unit -> ({io} Cap) = f[Unit]  // ok
+}

tests/neg-custom-args/captures/box-adapt-cs.scala

@@ -0,0 +1,19 @@
+trait Cap { def use(): Int }
+
+def test1(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {io} X -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  val f: ({*} Cap) -> Unit = ???
+  x(f)  // ok
+  // actual: {*} Cap -> Unit
+  // expected: {io} box {io} Cap -> Unit
+}
+
+def test2(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {*} X -> T) -> T
+
+  val x: Id[{*} Cap] = ???
+  val f: ({io} Cap) -> Unit = ???
+  x(f)  // error
+}

tests/neg-custom-args/captures/box-adapt-depfun.scala

@@ -0,0 +1,23 @@
+trait Cap { def use(): Int }
+
+def test1(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {io} X -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  x(cap => cap.use())  // ok
+}
+
+def test2(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {io} (x: X) -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  x(cap => cap.use())
+  // should work when the expected type is a dependent function
+}
+
+def test3(io: {*} Cap): Unit = {
+  type Id[X] = [T] -> (op: {} (x: X) -> T) -> T
+
+  val x: Id[{io} Cap] = ???
+  x(cap => cap.use()) // error
+}

tests/neg-custom-args/captures/box-adapt-typefun.scala

@@ -0,0 +1,13 @@
+trait Cap { def use(): Int }
+
+def test1(io: {*} Cap): Unit = {
+  type Op[X] = [T] -> X -> Unit
+  val f: [T] -> ({io} Cap) -> Unit = ???
+  val op: Op[{io} Cap] = f // error
+}
+
+def test2(io: {*} Cap): Unit = {
+  type Lazy[X] = [T] -> Unit -> X
+  val f: Lazy[{io} Cap] = ???
+  val test: [T] -> Unit -> ({io} Cap) = f // error
+}