Tests: Add reproducer for Swift 6.3 typed-throws async closure miscompile

Author: krodak

Tests/BridgeJSRuntimeTests/TypedThrowsAsyncClosureBugTests.swift

@@ -0,0 +1,155 @@
+import XCTest
+import JavaScriptKit
+import JavaScriptEventLoop
+
+/// Reproducer for a Swift 6.3 wasm32 miscompile: a `JSException` thrown from a
+/// `throws(JSException)` async closure VALUE loses its payload across the async
+/// unwind, while the same throw from an async function or an untyped async
+/// closure preserves it. The buggy case below asserts the current (incorrect)
+/// behavior so the suite stays green; flip it once the compiler is fixed.
+
+// MARK: - Payload types
+
+struct PlainValuePayloadError: Error, Equatable {
+    let marker: String
+}
+
+final class MarkerBox: @unchecked Sendable {
+    let marker: String
+    init(_ marker: String) { self.marker = marker }
+}
+struct ReferencePayloadError: Error {
+    let box: MarkerBox
+}
+
+// MARK: - Control "async function" forms (payload must survive)
+
+private func asyncFunctionThrowsValue() async throws(PlainValuePayloadError) {
+    throw PlainValuePayloadError(marker: "ALIVE")
+}
+
+private func asyncFunctionThrowsReference() async throws(ReferencePayloadError) {
+    throw ReferencePayloadError(box: MarkerBox("ALIVE"))
+}
+
+private func asyncFunctionThrowsJSException() async throws(JSException) {
+    throw JSException(JSError(message: "ALIVE").jsValue)
+}
+
+final class TypedThrowsAsyncClosureBugTests: XCTestCase {
+
+    func testControl_valuePayload_asyncFunction() async throws {
+        do {
+            try await asyncFunctionThrowsValue()
+            XCTFail("expected throw")
+        } catch let error as PlainValuePayloadError {
+            print("[REPRO] value / async function           payload: \(error.marker)")
+            XCTAssertEqual(error.marker, "ALIVE")
+        }
+    }
+
+    func testControl_valuePayload_typedThrowsAsyncClosure() async throws {
+        let closure: () async throws(PlainValuePayloadError) -> Void = {
+            () async throws(PlainValuePayloadError) -> Void in
+            throw PlainValuePayloadError(marker: "ALIVE")
+        }
+        do {
+            try await closure()
+            XCTFail("expected throw")
+        } catch let error as PlainValuePayloadError {
+            print("[REPRO] value / typed-throws async closure payload: \(error.marker)")
+            XCTAssertEqual(error.marker, "ALIVE")
+        }
+    }
+
+    func testControl_valuePayload_untypedAsyncClosure() async throws {
+        let closure: () async throws -> Void = {
+            throw PlainValuePayloadError(marker: "ALIVE")
+        }
+        do {
+            try await closure()
+            XCTFail("expected throw")
+        } catch let error as PlainValuePayloadError {
+            print("[REPRO] value / untyped async closure     payload: \(error.marker)")
+            XCTAssertEqual(error.marker, "ALIVE")
+        }
+    }
+
+    func testControl_referencePayload_asyncFunction() async throws {
+        do {
+            try await asyncFunctionThrowsReference()
+            XCTFail("expected throw")
+        } catch let error as ReferencePayloadError {
+            print("[REPRO] ref   / async function           payload: \(error.box.marker)")
+            XCTAssertEqual(error.box.marker, "ALIVE")
+        }
+    }
+
+    func testControl_referencePayload_typedThrowsAsyncClosure() async throws {
+        let closure: () async throws(ReferencePayloadError) -> Void = {
+            () async throws(ReferencePayloadError) -> Void in
+            throw ReferencePayloadError(box: MarkerBox("ALIVE"))
+        }
+        do {
+            try await closure()
+            XCTFail("expected throw")
+        } catch let error as ReferencePayloadError {
+            print("[REPRO] ref   / typed-throws async closure payload: \(error.box.marker)")
+            XCTAssertEqual(error.box.marker, "ALIVE")
+        }
+    }
+
+    func testControl_jsException_asyncFunction() async throws {
+        do {
+            try await asyncFunctionThrowsJSException()
+            XCTFail("expected throw")
+        } catch let error as JSException {
+            let alive = error.thrownValue.object != nil
+            print("[REPRO] jsexc / async function           object!=nil: \(alive)")
+            XCTAssertTrue(alive, "async function should preserve the thrown JS object")
+            XCTAssertEqual(error.thrownValue.object?.message.string, "ALIVE")
+        }
+    }
+
+    func testControl_jsException_untypedAsyncClosure() async throws {
+        let closure: () async throws -> Void = {
+            throw JSException(JSError(message: "ALIVE").jsValue)
+        }
+        do {
+            try await closure()
+            XCTFail("expected throw")
+        } catch let error as JSException {
+            let alive = error.thrownValue.object != nil
+            print("[REPRO] jsexc / untyped async closure     object!=nil: \(alive)")
+            XCTAssertTrue(alive, "untyped async closure should preserve the thrown JS object")
+            XCTAssertEqual(error.thrownValue.object?.message.string, "ALIVE")
+        } catch {
+            XCTFail("unexpected error type: \(error)")
+        }
+    }
+
+    /// Asserts the current (buggy) behavior: the JSException payload is lost.
+    /// When the compiler is fixed this test will fail; flip to XCTAssertTrue(alive).
+    func testBug_jsException_typedThrowsAsyncClosure() async throws {
+        let closure: () async throws(JSException) -> Void = { () async throws(JSException) -> Void in
+            throw JSException(JSError(message: "ALIVE").jsValue)
+        }
+        do {
+            try await closure()
+            XCTFail("expected throw")
+        } catch let error as JSException {
+            let alive = error.thrownValue.object != nil
+            print("[REPRO] jsexc / typed-throws async closure object!=nil: \(alive)  <-- BUG: payload lost")
+
+            XCTAssertFalse(
+                alive,
+                """
+                Swift 6.3 wasm32 typed-throws async closure value is expected to LOSE \
+                the JSException payload. If this assertion now fails, the compiler bug \
+                appears fixed -- flip this to XCTAssertTrue(alive) and re-enable the \
+                message round-trip check.
+                """
+            )
+        }
+    }
+}