made compile errors for forking more specific

lbialy · lbialy · commit fa7053e0f916 · 2024-06-12T14:13:35.000+02:00
diff --git a/core/src/main/scala/ox/either.scala b/core/src/main/scala/ox/either.scala
@@ -1,14 +1,19 @@
 package ox
 
-import scala.annotation.implicitNotFound
 import scala.compiletime.{error, summonFrom}
 import scala.util.boundary
 import scala.util.boundary.{Label, break}
 import scala.util.control.NonFatal
 import scala.util.NotGiven
 
 object either:
-  private type NotInForkedScope = NotGiven[Forked]
+  private type WithoutScopeMarkers[A] = (Supervised, Supervised) ?=> (Forked, Forked) ?=> A
+
+  private inline def availableInScope[A]: Boolean =
+    summonFrom {
+      case _: NotGiven[A] => false
+      case _: A           => true
+    }
 
   /** Within an [[either]] block, allows unwrapping [[Either]] and [[Option]] values using [[ok()]]. The result is the right-value of an
     * `Either`, or the defined-value of the `Option`. In case a failure is encountered (a left-value of an `Either`, or a `None`), the
@@ -39,19 +44,21 @@ object either:
     *       v1.ok() ++ v2.ok()
     *   }}}
     */
-  inline def apply[E, A](inline body: (Forked, Forked) ?=> Label[Either[E, A]] ?=> A): Either[E, A] =
+  inline def apply[E, A](inline body: WithoutScopeMarkers[Label[Either[E, A]] ?=> A]): Either[E, A] =
     given Forked = ForkedEvidence // just to satisfy the context function
+    given Supervised = SupervisedEvidence // just to satisfy the context function
     boundary(Right(body))
 
   extension [E, A](inline t: Either[E, A])
     /** Unwrap the value of the `Either`, short-circuiting the computation to the enclosing [[either]], in case this is a left-value. Can't
       * be used in forked blocks without an either block in fork to prevent escaped Breaks that crash forked threads.
       */
-    transparent inline def ok()(using
-        @implicitNotFound(
+    transparent inline def ok(): A =
+      inline if availableInScope[Forked] && !availableInScope[Supervised] then
+        error(
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
-        ) notForked: NotInForkedScope
-    ): A =
+        )
+
       summonFrom {
         case given boundary.Label[Either[E, Nothing]] =>
           t match
@@ -66,11 +73,12 @@ object either:
     /** Unwrap the value of the `Option`, short-circuiting the computation to the enclosing [[either]], in case this is a `None`. Can't be
       * used in forked blocks without an either block in fork to prevent escaped Breaks that crash forked threads.
       */
-    transparent inline def ok()(using
-        @implicitNotFound(
+    transparent inline def ok(): A =
+      inline if availableInScope[Forked] then
+        error(
           "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
-        ) notForked: NotInForkedScope
-    ): A =
+        )
+
       summonFrom {
         case given boundary.Label[Either[Unit, Nothing]] =>
           t match
@@ -87,11 +95,12 @@ object either:
     /** Fail the computation by short-circuiting the enclosing [[either]] block with en error of type `E`. Can't be used in forked blocks
       * without an either block in fork to prevent escaped Breaks that crash forked threads.
       */
-    transparent inline def fail()(using
-        @implicitNotFound(
-          "This use of .fail() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
-        ) notForked: NotInForkedScope
-    ): Nothing =
+    transparent inline def fail(): Nothing =
+      inline if availableInScope[Forked] then
+        error(
+          "This use of .ok() belongs to either block outside of the fork and is therefore illegal. Use either block inside of the forked block."
+        )
+
       summonFrom {
         case given boundary.Label[Either[E, Nothing]] => break(Left(e))
         case given boundary.Label[Either[Nothing, Nothing]] =>
diff --git a/core/src/main/scala/ox/supervised.scala b/core/src/main/scala/ox/supervised.scala
@@ -4,6 +4,9 @@ import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.{CompletableFuture, ConcurrentHashMap}
 import scala.reflect.ClassTag
 
+sealed abstract class Supervised
+object SupervisedEvidence extends Supervised
+
 /** Starts a new concurrency scope, which allows starting forks in the given code block `f`. Forks can be started using [[fork]],
   * [[forkUser]], [[forkCancellable]] and [[forkUnsupervised]]. All forks are guaranteed to complete before this scope completes.
   *
@@ -12,19 +15,19 @@ import scala.reflect.ClassTag
   *     [[fork]] (daemon) don't have to complete successfully for the scope to end.
   *   - the scope also ends once the first supervised fork (including the `f` main body) fails with an exception
   *   - when the scope **ends**, all running forks are cancelled
-  *   - the scope **completes** (that is, this method returns) only once all forks started by `f` have completed (either successfully, or with
-  *     an exception)
+  *   - the scope **completes** (that is, this method returns) only once all forks started by `f` have completed (either successfully, or
+  *     with an exception)
   *
   * Upon successful completion, returns the result of evaluating `f`. Upon failure, the exception that caused the scope to end is re-thrown
   * (regardless if the exception was thrown from the main body, or from a fork). Any other exceptions that occur when completing the scope
   * are added as suppressed.
   *
   * @see
-  * [[unsupervised]] Starts a scope in unsupervised mode
+  *   [[unsupervised]] Starts a scope in unsupervised mode
   * @see
-  * [[supervisedError]] Starts a scope in supervised mode, with the additional ability to report application errors
+  *   [[supervisedError]] Starts a scope in supervised mode, with the additional ability to report application errors
   */
-def supervised[T](f: Ox ?=> T): T = supervisedError(NoErrorMode)(f)
+def supervised[T](f: Supervised ?=> Ox ?=> T): T = supervisedError(NoErrorMode)(f)
 
 /** Starts a new concurrency scope, which allows starting forks in the given code block `f`. Forks can be started using [[fork]],
   * [[forkError]], [[forkUser]], [[forkUserError]], [[forkCancellable]] and [[forkUnsupervised]]. All forks are guaranteed to complete
@@ -36,12 +39,12 @@ def supervised[T](f: Ox ?=> T): T = supervisedError(NoErrorMode)(f)
   * @see
   *   [[forkError]] On details how to use application errors.
   */
-def supervisedError[E, F[_], T](em: ErrorMode[E, F])(f: OxError[E, F] ?=> F[T]): F[T] =
+def supervisedError[E, F[_], T](em: ErrorMode[E, F])(f: Supervised ?=> OxError[E, F] ?=> F[T]): F[T] =
   val s = DefaultSupervisor[E]
   val capability = OxError(s, em)
   try
     val scopeResult = scopedWithCapability(capability) {
-      val mainBodyFork = forkUserError(using capability)(f(using capability))
+      val mainBodyFork = forkUserError(using capability)(f(using SupervisedEvidence)(using capability))
       val supervisorResult = s.join() // might throw if any supervised fork threw
       if supervisorResult == ErrorModeSupervisorResult.Success then
         // if no exceptions, the main f-fork must be done by now
diff --git a/core/src/test/scala/ox/ForkEitherInteropTest.scala b/core/src/test/scala/ox/ForkEitherInteropTest.scala
@@ -12,8 +12,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
          import ox.either.*
          
          val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-         either {
-           unsupervised {
+         unsupervised {
+          either {
              forkUnsupervised {
                e1.ok()
              }
@@ -28,8 +28,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
          import ox.either.*
 
          val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-         either {
-           unsupervised {
+         unsupervised {
+           either {
              forkCancellable {
                e1.ok()
              }
@@ -44,8 +44,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
        import ox.either.*
 
        val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-       either {
-         supervised {
+       supervised {
+         either {
            fork {
              e1.ok()
            }
@@ -61,8 +61,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
        import ox.either.*
 
        val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-       either {
-         supervised {
+       supervised {
+         either {
            forkUser {
              e1.ok()
            }
@@ -78,8 +78,8 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
        import ox.either.*
 
        val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-       either {
-         supervisedError(EitherMode[Throwable]) {
+       supervisedError(EitherMode[Throwable]) {
+         either {
            val f = forkError {
              e1.ok()
              Right(23)
@@ -98,12 +98,15 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
        import ox.either.*
 
        val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-       either {
-         supervisedError(EitherMode[String]) {
-           forkUserError {
+       supervisedError(EitherMode[String]) {
+         either {
+           val f = forkUserError {
              e1.ok()
              Right(23)
            }
+
+           f.join()
+           Left("oops")
          }
        }"""
     }
@@ -115,14 +118,30 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
          import ox.either.*
 
          val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
-         either {
-           supervised {
+         supervised {
+           either {
              forkAll(Vector(() => e1.ok()))
            }
          }"""
     }
   }
 
+  "fork/either interop" should "disallow usage of fork in either blocks" in {
+    assertReceivesForkedScopeError {
+      """import ox.*
+         import ox.either.*
+
+         val e1: Either[Throwable, Unit] = Left(Exception("uh oh"))
+         supervised { 
+           either { 
+             fork { 
+               e1.ok() 
+             }
+           }
+         }"""
+    }
+  }
+
   "either in fork" should "allow usage of either.ok() combinator" in {
     """
     import ox.*
@@ -141,7 +160,7 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
     """ should compile
   }
 
-  "fork/either interop" should "pass logical tests" in {
+  "fork/either interop" should "work with either scopes nested in forks" in {
     import ox.*
     import ox.either.*
 
@@ -163,6 +182,23 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
     outer.shouldEqual(Right("outer"))
   }
 
+  "fork/either interop" should "allow ok() combinators if supervised block guarantees either block correctness" in {
+    import ox.*
+    import ox.either.*
+
+    val sth: Either[Throwable, String] = Right("it works!")
+
+    val res = either {
+      supervised {
+        fork {
+          sth.ok()
+        }.join()
+      }
+    }
+
+    res.shouldEqual(Right("it works!"))
+  }
+
   private transparent inline def assertReceivesForkedScopeError(inline code: String): Unit =
     val errs = typeCheckErrors(code)
     if !errs
