Fix to run finalizers once when there's an exception during releasing (#336)

Author: adamw

core/src/main/scala/ox/resource.scala

@@ -29,9 +29,7 @@ def releaseCloseableAfterScope(toRelease: AutoCloseable)(using OxUnsupervised):
   * [[uninterruptible]]. To use multiple resources, consider creating a [[supervised]] scope and [[useInScope]] method.
   */
 inline def use[R, T](inline acquire: R, inline release: R => Unit)(inline f: R => T): T =
-  val r = acquire
-  try f(r)
-  finally uninterruptible(release(r))
+  useInterruptible(acquire, r => uninterruptible(release(r)))(f)
 
 /** Use the given resource, acquired using `acquire` and released using `release` in the given `f` code block. Releasing might be
   * interrupted. To use multiple resources, consider creating a [[supervised]] scope and [[useInScope]] method.

core/src/main/scala/ox/unsupervised.scala

@@ -30,10 +30,8 @@ private[ox] def scopedWithCapability[T](capability: Ox)(f: Ox ?=> T): T =
     es.tail.foreach(e.addSuppressed)
     throw e
 
-  val herd = capability.herd
-  val finalizers = capability.finalizers
   def runFinalizers(result: Either[Throwable, T]): T =
-    val fs = finalizers.get
+    val fs = capability.finalizers.get
     if fs.isEmpty then result.fold(throw _, identity)
     else
       val es = uninterruptible {
@@ -51,17 +49,23 @@ private[ox] def scopedWithCapability[T](capability: Ox)(f: Ox ?=> T): T =
     end if
   end runFinalizers
 
-  val previousScope = currentScope.get()
-  currentScope.set(capability)
-  try
-    val t =
-      try f(using capability)
-      finally herd.interruptAllAndJoinUntilCompleted()
+  def runWithCurrentScopeSet =
+    val result =
+      try
+        Right(
+          try f(using capability)
+          finally capability.herd.interruptAllAndJoinUntilCompleted()
+        )
+      catch case e: Throwable => Left(e)
 
     // running the finalizers only once we are sure that all child threads have been terminated, so that no new
     // finalizers are added, and none are lost
-    runFinalizers(Right(t))
-  catch case e: Throwable => runFinalizers(Left(e))
+    runFinalizers(result)
+  end runWithCurrentScopeSet
+
+  val previousScope = currentScope.get()
+  try
+    currentScope.set(capability)
+    runWithCurrentScopeSet
   finally currentScope.set(previousScope)
-  end try
 end scopedWithCapability

core/src/test/scala/ox/ResourceTest.scala

@@ -50,7 +50,7 @@ class ResourceTest extends AnyFlatSpec with Matchers:
     trail.get shouldBe Vector("allocate 1", "allocate 2", "release 2", "release 1", "exception")
   }
 
-  it should "release resources when there's an exception during releasing" in {
+  it should "release resources when there's an exception during releasing (normal resutl)" in {
     val trail = Trail()
 
     try
@@ -60,22 +60,50 @@ class ResourceTest extends AnyFlatSpec with Matchers:
           1
         } { n =>
           trail.add(s"release $n")
-          throw new RuntimeException()
+          throw new RuntimeException("e1")
         }
         val r2 = useInScope {
           trail.add("allocate 2");
           2
         } { n =>
           trail.add(s"release $n")
-          throw new RuntimeException()
+          throw new RuntimeException("e2")
         }
         r1 shouldBe 1
         r2 shouldBe 2
-        throw new RuntimeException
+        r1 + r2
       }
-    catch case _ => trail.add("exception")
+    catch case e => trail.add(s"exception ${e.getMessage}")
     end try
-    trail.get shouldBe Vector("allocate 1", "allocate 2", "release 2", "release 1", "exception")
+    trail.get shouldBe Vector("allocate 1", "allocate 2", "release 2", "release 1", "exception e2")
+  }
+
+  it should "release resources when there's an exception during releasing (exceptional resutl)" in {
+    val trail = Trail()
+
+    try
+      unsupervised {
+        val r1 = useInScope {
+          trail.add("allocate 1");
+          1
+        } { n =>
+          trail.add(s"release $n")
+          throw new RuntimeException("e1")
+        }
+        val r2 = useInScope {
+          trail.add("allocate 2");
+          2
+        } { n =>
+          trail.add(s"release $n")
+          throw new RuntimeException("e2")
+        }
+        r1 shouldBe 1
+        r2 shouldBe 2
+        throw new RuntimeException("e3")
+      }
+    catch case e => trail.add(s"exception ${e.getMessage}")
+    end try
+    trail.get shouldBe Vector("allocate 1", "allocate 2", "release 2", "release 1", "exception e3")
   }
 
   it should "release registered resources" in {