Update test to show where the difference lies

Author: odersky

tests/neg-custom-args/captures/effect-swaps.check

@@ -1,19 +1,21 @@
--- Error: tests/neg-custom-args/captures/effect-swaps.scala:62:6 -------------------------------------------------------
-61 |    Result:
-62 |      Future: // error, escaping label from Result
-   |    ^
-   |local reference contextual$1 from (using contextual$1: boundary.Label[box Result[box Future[box T^?]^{fr, contextual$1, contextual$1}, box E^?]^?]^):
-   |  box Result[box Future[box T^?]^{fr, contextual$1, contextual$1}, box E^?]^? leaks into outer capture set of type parameter T of method apply in object boundary
-63 |        fr.await.ok
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/effect-swaps.scala:64:8 ----------------------------------
+63 |      Result:
+64 |        Future: // error, escaping label from Result
+   |      ^
+   |      Found:    Result.Ok[box Future[box T^?]^{fr, contextual$1}]
+   |      Required: Result[Future[T], Nothing]
+65 |          fr.await.ok
    |--------------------------------------------------------------------------------------------------------------------
    |Inline stack trace
    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   |This location contains code that was inlined from effect-swaps.scala:37
-37 |    boundary:
-   |    ^^^^^^^^
+   |This location contains code that was inlined from effect-swaps.scala:41
+41 |    boundary(Ok(body))
+   |             ^^^^^^^^
     --------------------------------------------------------------------------------------------------------------------
--- Error: tests/neg-custom-args/captures/effect-swaps.scala:66:11 ------------------------------------------------------
-66 |    Result.make: // error, escaping label from Result
-   |    ^^^^^^^^^^^
+   |
+   | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/effect-swaps.scala:68:15 ------------------------------------------------------
+68 |        Result.make: //lbl ?=> // error, escaping label from Result
+   |        ^^^^^^^^^^^
    |local reference contextual$9 from (using contextual$9: boundary.Label[Result[box Future[box T^?]^{fr, contextual$9}, box E^?]]^):
    |  box Future[box T^?]^{fr, contextual$9} leaks into outer capture set of type parameter T of method make in object Result

tests/neg-custom-args/captures/effect-swaps.scala

@@ -14,55 +14,57 @@ end boundary
 
 import boundary.{Label, break}
 
-class Async
+@capability trait Async
+object Async:
+  def blocking[T](body: Async ?=> T): T = ???
+
 class Future[+T]:
   this: Future[T]^ =>
-  def await(using Async^): T = ???
+  def await(using Async): T = ???
 object Future:
-  def apply[T](op: Async^ ?=> T)(using Async): Future[T]^{op} = ???
+  def apply[T](op: Async ?=> T)(using Async): Future[T]^{op} = ???
+
+enum Result[+T, +E]:
+  case Ok[+T](value: T) extends Result[T, Nothing]
+  case Err[+E](error: E) extends Result[Nothing, E]
 
-abstract class Result[+T, +E]
-case class Ok[+T](value: T)  extends Result[T, Nothing]
-case class Err[+E](value: E) extends Result[Nothing, E]
 
 object Result:
-  extension [T, E](r: Result[T, E])
+  extension [T, E](r: Result[T, E]^)(using Label[Err[E]])
 
     /** `_.ok` propagates Err to current Label */
-    inline def ok(using Label[Result[Nothing, E]]): T = r match
-      case r: Ok[_] => r.value
-      case err => break(err.asInstanceOf[Err[E]])
+    def ok: T = r match
+      case Ok(value) => value
+      case Err(value) => break[Err[E]](Err(value))
 
   transparent inline def apply[T, E](inline body: Label[Result[T, E]] ?=> T): Result[T, E] =
-    boundary:
-      val result = body
-      Ok(result)
+    boundary(Ok(body))
 
   // same as apply, but not an inline method
   def make[T, E](body: Label[Result[T, E]] ?=> T): Result[T, E] =
-    boundary:
-      val result = body
-      Ok(result)
+    boundary(Ok(body))
 
 end Result
 
 def test[T, E](using Async) =
-  val good1: List[Future[Result[T, E]]] => Future[Result[List[T], E]] = frs =>
-    Future:
-      Result:
-        frs.map(_.await.ok) // OK
+  import Result.*
+  Async.blocking: async ?=>
+    val good1: List[Future[Result[T, E]]] => Future[Result[List[T], E]] = frs =>
+      Future:
+        Result:
+          frs.map(_.await.ok) // OK
 
-  val good2: Result[Future[T], E] => Future[Result[T, E]] = rf =>
-    Future:
-      Result:
-        rf.ok.await  // OK, Future argument has type Result[T]
+    val good2: Result[Future[T], E] => Future[Result[T, E]] = rf =>
+      Future:
+        Result:
+          rf.ok.await  // OK, Future argument has type Result[T]
 
-  def fail3(fr: Future[Result[T, E]]^) =
-    Result:
-      Future: // error, escaping label from Result
-        fr.await.ok
+    def fail3(fr: Future[Result[T, E]]^) =
+      Result:
+        Future: // error, escaping label from Result
+          fr.await.ok
 
-  def fail4(fr: Future[Result[T, E]]^) =
-    Result.make: // error, escaping label from Result
-      Future:
-        fr.await.ok
+    def fail4[T, E](fr: Future[Result[T, E]]^) =
+        Result.make: //lbl ?=> // error, escaping label from Result
+          Future: fut ?=>
+            fr.await.ok