Work around KT-58685 (#3881)

Implement `withLock` and `withPermit` without try/finally,
as the idiomatic implementation leads to incorrect code
being produced by the compiler.

kotlinx-coroutines-core/common/src/sync/Mutex.kt

@@ -122,12 +122,18 @@ public suspend inline fun <T> Mutex.withLock(owner: Any? = null, action: () -> T
         callsInPlace(action, InvocationKind.EXACTLY_ONCE)
     }
 
+    // Cannot use 'finally' in this function because of KT-58685
+    // See kotlinx.coroutines.sync.MutexTest.testWithLockJsMiscompilation
+
     lock(owner)
-    try {
-        return action()
-    } finally {
+    val result = try {
+        action()
+    } catch (e: Throwable) {
         unlock(owner)
+        throw e
     }
+    unlock(owner)
+    return result
 }
 
 

kotlinx-coroutines-core/common/src/sync/Semaphore.kt

@@ -83,12 +83,18 @@ public suspend inline fun <T> Semaphore.withPermit(action: () -> T): T {
         callsInPlace(action, InvocationKind.EXACTLY_ONCE)
     }
 
+    // Cannot use 'finally' in this function because of KT-58685
+    // See kotlinx.coroutines.sync.SemaphoreTest.testWithPermitJsMiscompilation
+
     acquire()
-    try {
-        return action()
-    } finally {
+    val result = try {
+        action()
+    } catch (e: Throwable) {
         release()
+        throw e
     }
+    release()
+    return result
 }
 
 @Suppress("UNCHECKED_CAST")

kotlinx-coroutines-core/common/test/sync/MutexTest.kt

@@ -148,4 +148,20 @@ class MutexTest : TestBase() {
         assertFailsWith<IllegalStateException> { mutex.lock(owner) }
         assertFailsWith<IllegalStateException> { select { mutex.onLock(owner) {} } }
     }
+
+    @Test
+    fun testWithLockJsMiscompilation() = runTest {
+        // This is a reproducer for KT-58685
+        // On Kotlin/JS IR, the compiler miscompiles calls to 'unlock' in an inlined finally
+        // This is visible on the withLock function
+        // Until the compiler bug is fixed, this test case checks that we do not suffer from it
+        val mutex = Mutex()
+        assertFailsWith<IndexOutOfBoundsException> {
+            try {
+                mutex.withLock { null } ?: throw IndexOutOfBoundsException() // should throw…
+            } catch (e: Exception) {
+                throw e // …but instead fails here
+            }
+        }
+    }
 }

kotlinx-coroutines-core/common/test/sync/SemaphoreTest.kt

@@ -168,4 +168,20 @@ class SemaphoreTest : TestBase() {
         assertFailsWith<IllegalArgumentException> { Semaphore(1, -1) }
         assertFailsWith<IllegalArgumentException> { Semaphore(1, 2) }
     }
-}
+
+    @Test
+    fun testWithPermitJsMiscompilation() = runTest {
+        // This is a reproducer for KT-58685
+        // On Kotlin/JS IR, the compiler miscompiles calls to 'release' in an inlined finally
+        // This is visible on the withPermit function
+        // Until the compiler bug is fixed, this test case checks that we do not suffer from it
+        val semaphore = Semaphore(1)
+        assertFailsWith<IndexOutOfBoundsException> {
+            try {
+                semaphore.withPermit { null } ?: throw IndexOutOfBoundsException() // should throw…
+            } catch (e: Exception) {
+                throw e // …but instead fails here
+            }
+        }
+    }
+}