Merge pull request #706 from Avasil/bracket-dont-evaluate-use-on-cancel

Bracket: Do not evaluate "use" if "acquire" is canceled

.scalafmt.conf

@@ -7,4 +7,5 @@ continuationIndent.defnSite = 2
 assumeStandardLibraryStripMargin = true
 danglingParentheses = true
 rewrite.rules = [AvoidInfix, SortImports, RedundantBraces, RedundantParens, SortModifiers]
-docstrings = JavaDoc
+docstrings = JavaDoc
+lineEndings=preserve

core/shared/src/main/scala/cats/effect/internals/IOBracket.scala

@@ -71,16 +71,21 @@ private[effect] object IOBracket {
     def run(): Unit = result match {
       case Right(a) =>
         val frame = new BracketReleaseFrame[A, B](a, release)
-        val onNext = {
-          val fb = try use(a)
-          catch { case NonFatal(e) => IO.raiseError(e) }
-          fb.flatMap(frame)
-        }
+
         // Registering our cancelable token ensures that in case
         // cancellation is detected, `release` gets called
         deferredRelease.complete(frame.cancel)
-        // Actual execution
-        IORunLoop.startCancelable(onNext, conn, cb)
+
+        // Check if IO wasn't already cancelled in acquire
+        if (!conn.isCanceled) {
+          val onNext = {
+            val fb = try use(a)
+            catch { case NonFatal(e) => IO.raiseError(e) }
+            fb.flatMap(frame)
+          }
+          // Actual execution
+          IORunLoop.startCancelable(onNext, conn, cb)
+        }
 
       case error @ Left(_) =>
         deferredRelease.complete(IO.unit)

laws/shared/src/test/scala/cats/effect/IOTests.scala

@@ -758,6 +758,26 @@ class IOTests extends BaseTestsSuite {
     effect shouldBe 1
   }
 
+  testAsync("bracket does not evaluate use on cancel") { implicit ec =>
+    implicit val contextShift = ec.contextShift[IO]
+    implicit val timer = ec.timer[IO]
+
+    var use = false
+    var release = false
+
+    val task = IO
+      .sleep(2.second)
+      .bracket(_ => IO { use = true })(_ => IO { release = true })
+      .timeoutTo[Unit](1.second, IO.never)
+
+    val f = task.unsafeToFuture()
+    ec.tick(2.second)
+
+    f.value shouldBe None
+    use shouldBe false
+    release shouldBe true
+  }
+
   test("unsafeRunSync works for IO.cancelBoundary") {
     val io = IO.cancelBoundary *> IO(1)
     io.unsafeRunSync() shouldBe 1