BridgeJS: Support throws and async for closures

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ClosureCodegen.swift

@@ -16,7 +16,8 @@ public struct ClosureCodegen {
         let closureParams = signature.parameters.map { "\(sendingPrefix)\($0.closureSwiftType)" }.joined(
             separator: ", "
         )
-        let swiftEffects = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws" : "")
+        // BridgeJS only bridges `throws(JSException)` closures, so emit the typed throws clause.
+        let swiftEffects = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws(JSException)" : "")
         let swiftReturnType = signature.returnType.closureSwiftType
         return "(\(closureParams))\(swiftEffects) -> \(swiftReturnType)"
     }
@@ -72,8 +73,24 @@ public struct ClosureCodegen {
             helperEnumDeclPrinter.write("static func bridgeJSLift(_ callbackId: Int32) -> \(swiftClosureType) {")
             helperEnumDeclPrinter.indent {
                 helperEnumDeclPrinter.write("let callback = JSObject.bridgeJSLiftParameter(callbackId)")
+                // Throwing/async closures need an explicit signature with a typed effect
+                // clause: a bare multi-statement closure literal infers its thrown type as
+                // `any Error` even when assigned to a `throws(JSException)` function type.
+                // Spelling out parameter types, the effect clause, and return type pins
+                // inference to `JSException`.
                 let parameters: String
-                if signature.parameters.isEmpty {
+                if signature.isThrows || signature.isAsync {
+                    let sendingPrefix = signature.sendingParameters ? "sending " : ""
+                    let typedParams =
+                        signature.parameters.enumerated().map { index, paramType in
+                            "param\(index): \(sendingPrefix)\(paramType.closureSwiftType)"
+                        }.joined(separator: ", ")
+                    let returnType = signature.returnType.closureSwiftType
+                    // Canonical effect order is `async` before `throws` (Mangling.rst).
+                    let effects =
+                        (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws(JSException)" : "")
+                    parameters = " (\(typedParams))\(effects) -> \(returnType)"
+                } else if signature.parameters.isEmpty {
                     parameters = ""
                 } else if signature.parameters.count == 1 {
                     parameters = " param0"
@@ -146,22 +163,29 @@ public struct ClosureCodegen {
             liftedParams.append("\(paramType.swiftType).bridgeJSLiftParameter(\(argNames.joined(separator: ", ")))")
         }
 
-        let closureCallExpr = ExprSyntax("closure(\(raw: liftedParams.joined(separator: ", ")))")
+        let tryPrefix = signature.isThrows ? "try " : ""
+        let closureCallExpr = ExprSyntax("\(raw: tryPrefix)closure(\(raw: liftedParams.joined(separator: ", ")))")
+        let asyncTryPrefix = (signature.isThrows ? "try " : "") + "await "
+        let asyncClosureCallExpr = ExprSyntax(
+            "\(raw: asyncTryPrefix)closure(\(raw: liftedParams.joined(separator: ", ")))"
+        )
 
-        let abiReturnWasmType = try signature.returnType.loweringReturnInfo().returnType
+        // An async closure returns a JS `Promise` (a `JSObject`) synchronously and settles
+        // it later, like an exported `async` Swift function, so the ABI return is always
+        // the Promise object id (`i32`) regardless of the closure's logical return type.
+        let abiReturnWasmType =
+            signature.isAsync
+            ? try BridgeType.jsObject(nil).loweringReturnInfo().returnType
+            : try signature.returnType.loweringReturnInfo().returnType
 
         // Build signature using SwiftSignatureBuilder
         let funcSignature = SwiftSignatureBuilder.buildABIFunctionSignature(
             abiParameters: abiParams,
             returnType: abiReturnWasmType
         )
 
-        // Build function declaration using helper
-        let funcDecl = SwiftCodePattern.buildExposedFunctionDecl(
-            abiName: abiName,
-            signature: funcSignature
-        ) { printer in
-            printer.write("let closure = Unmanaged<\(boxType)>.fromOpaque(boxPtr).takeUnretainedValue().closure")
+        // Emits the closure call and lowers its return value onto the ABI.
+        let emitCallAndLower: (CodeFragmentPrinter) -> Void = { printer in
             if signature.returnType == .void {
                 printer.write(closureCallExpr.description)
             } else {
@@ -189,6 +213,101 @@ public struct ClosureCodegen {
             }
         }
 
+        // Emits the async closure call wrapped in a `_bjs_makePromise` and lowers the
+        // resulting Promise object onto the ABI, reusing the mechanism the exported
+        // async-function thunk uses: `_bjs_makePromise(resolve: Promise_resolve_<mangleR>,
+        // reject: Promise_reject)` with a `() async throws(JSException) -> R in` body. The
+        // closure's return type R is collected into the shared
+        // `asyncPromiseResolveReturnTypes` set, so its concrete `Promise_resolve_<R>` thunk
+        // is emitted alongside the function ones.
+        //
+        // No explicit box pin is needed across suspension: `takeUnretainedValue().closure`
+        // copies the closure value out of the box, and that copy is captured by the
+        // escaping `_bjs_makePromise` body, keeping it alive for the whole settling `Task`
+        // independent of the box's JS-owned refcount.
+        let emitAsyncCallAndLower: (CodeFragmentPrinter) -> Void = { printer in
+            printer.write("let closure = Unmanaged<\(boxType)>.fromOpaque(boxPtr).takeUnretainedValue().closure")
+            let resolveType = signature.returnType
+            let resolveName = "Promise_resolve_\(resolveType.mangleTypeName)"
+            let rejectName = "Promise_reject"
+            // A throwing async body needs an explicit `() async throws(JSException) -> R`
+            // head, otherwise Swift infers `throws(any Error)` for a multi-statement
+            // closure literal (see https://github.com/swiftlang/swift/issues/76165).
+            let closureHead: String
+            if signature.isThrows {
+                let returnSpelling = resolveType == .void ? "" : " -> \(resolveType.closureSwiftType)"
+                closureHead = " () async throws(JSException)\(returnSpelling) in"
+            } else {
+                closureHead = ""
+            }
+            printer.write("return _bjs_makePromise(resolve: \(resolveName), reject: \(rejectName)) {\(closureHead)")
+            printer.indent {
+                if resolveType == .void {
+                    printer.write(asyncClosureCallExpr.description)
+                } else {
+                    printer.write("return \(asyncClosureCallExpr)")
+                }
+            }
+            printer.write("}")
+        }
+
+        // The placeholder return statement used on the catch path so the exposed
+        // function still satisfies its ABI return type after routing the thrown
+        // JSException to JS via `_swift_js_throw`.
+        let catchPlaceholderStmt = abiReturnWasmType?.swiftReturnPlaceholderStmt
+
+        // Build function declaration using helper
+        let funcDecl = SwiftCodePattern.buildExposedFunctionDecl(
+            abiName: abiName,
+            signature: funcSignature
+        ) { printer in
+            if signature.isAsync {
+                // `emitAsyncCallAndLower` extracts `closure` from the box itself, so the
+                // unconditional unretained extraction below is skipped for the async path.
+                emitAsyncCallAndLower(printer)
+            } else if signature.isThrows {
+                printer.write(
+                    "let closure = Unmanaged<\(boxType)>.fromOpaque(boxPtr).takeUnretainedValue().closure"
+                )
+                // Route the caught JSException across the ABI like a throwing exported
+                // function; the JS wrapper checks `tmpRetException` and rethrows.
+                printer.write("do {")
+                printer.indent {
+                    emitCallAndLower(printer)
+                }
+                printer.write("} catch let error {")
+                printer.indent {
+                    printer.write("if let error = error.thrownValue.object {")
+                    printer.indent {
+                        printer.write("withExtendedLifetime(error) {")
+                        printer.indent {
+                            printer.write("_swift_js_throw(Int32(bitPattern: $0.id))")
+                        }
+                        printer.write("}")
+                    }
+                    printer.write("} else {")
+                    printer.indent {
+                        printer.write("let jsError = JSError(message: error.description)")
+                        printer.write("withExtendedLifetime(jsError.jsObject) {")
+                        printer.indent {
+                            printer.write("_swift_js_throw(Int32(bitPattern: $0.id))")
+                        }
+                        printer.write("}")
+                    }
+                    printer.write("}")
+                    if let catchPlaceholderStmt {
+                        printer.write(catchPlaceholderStmt)
+                    }
+                }
+                printer.write("}")
+            } else {
+                printer.write(
+                    "let closure = Unmanaged<\(boxType)>.fromOpaque(boxPtr).takeUnretainedValue().closure"
+                )
+                emitCallAndLower(printer)
+            }
+        }
+
         return DeclSyntax(funcDecl)
     }
 
@@ -200,6 +319,9 @@ public struct ClosureCodegen {
         guard !signatureAccessLevels.isEmpty else { return nil }
 
         var decls: [DeclSyntax] = []
+        // Async closures settle their JS `Promise` through the shared `_bjs_makePromise`
+        // + per-type `Promise_resolve_<mangleR>` / `Promise_reject` mechanism emitted by
+        // `ExportSwift`, so no closure-specific settlement helpers are needed here.
         for signature in signatureAccessLevels.keys.sorted(by: { $0.mangleName < $1.mangleName }) {
             let accessLevel = signatureAccessLevels[signature] ?? .internal
             decls.append(contentsOf: try renderClosureHelpers(signature, accessLevel: accessLevel))

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -272,9 +272,11 @@ public struct ImportTS {
                 }
             }
 
-            // Add exception check for ImportTS context (skipped for async, where
-            // errors are funneled through the JS-side reject path)
-            if !effects.isAsync && context == .importTS {
+            // Rethrow a synchronous JS-side error into Swift (skipped for async, where
+            // errors are funneled through the JS reject path). `.importTS` thunks are
+            // always throwing; `.exportSwift` closure lifts only when the bridged
+            // closure is `throws(JSException)`.
+            if !effects.isAsync && (context == .importTS || effects.isThrows) {
                 body.write("if let error = _swift_js_take_exception() { throw error }")
             }
         }
@@ -323,18 +325,25 @@ public struct ImportTS {
             let innerBody = body
             body = CodeFragmentPrinter()
 
+            // `_bjs_awaitPromise` is `throws(JSException)` (it surfaces a Promise
+            // rejection as a Swift error). Async imports are always `throws(JSException)`,
+            // so plain `try` is correct there. A non-throwing `async` closure lift has no
+            // error channel, so use `try!` to trap on a rejection rather than emit an
+            // unhandled `try` inside a non-throwing closure literal (which would not
+            // compile).
+            let tryKeyword = effects.isThrows ? "try" : "try!"
             let rejectFactory = "makeRejectClosure: { JSTypedClosure<(sending JSValue) -> Void>($0) }"
             if returnType == .void {
                 let resolveFactory = "makeResolveClosure: { JSTypedClosure<() -> Void>($0) }"
                 body.write(
-                    "try await _bjs_awaitPromise(\(resolveFactory), \(rejectFactory)) { resolveRef, rejectRef in"
+                    "\(tryKeyword) await _bjs_awaitPromise(\(resolveFactory), \(rejectFactory)) { resolveRef, rejectRef in"
                 )
             } else {
                 let resolveSwiftType = returnType.closureSwiftType
                 let resolveFactory =
                     "makeResolveClosure: { JSTypedClosure<(sending \(resolveSwiftType)) -> Void>($0) }"
                 body.write(
-                    "let resolved = try await _bjs_awaitPromise(\(resolveFactory), \(rejectFactory)) { resolveRef, rejectRef in"
+                    "let resolved = \(tryKeyword) await _bjs_awaitPromise(\(resolveFactory), \(rejectFactory)) { resolveRef, rejectRef in"
                 )
             }
             body.indent {

Plugins/BridgeJS/Sources/BridgeJSCore/SwiftToSkeleton.swift

@@ -191,7 +191,48 @@ public final class SwiftToSkeleton {
             }
 
             let isAsync = functionType.effectSpecifiers?.asyncSpecifier != nil
-            let isThrows = functionType.effectSpecifiers?.throwsClause != nil
+
+            // An async closure settles its JS `Promise` through the same
+            // `_bjs_makePromise` + per-type `Promise_resolve_<mangled>` mechanism async
+            // exported functions use, so its return type must be `isAsyncResolvable` too.
+            // Unsupported types (associated-value enums, protocols, namespace enums, and
+            // their Optional/Array/Dictionary compositions) are diagnosed with the same
+            // message async functions use.
+            if isAsync, !returnType.isAsyncResolvable {
+                errors.append(
+                    DiagnosticError(
+                        node: functionType,
+                        message:
+                            "Returning '\(returnType.swiftType)' from an async closure is not yet supported",
+                        hint:
+                            "Return a type lowerable through the async resolve ABI "
+                            + "(String/Int/Bool/Double/Float/raw-value or case-only enum/@JS struct/JSObject/Optional/Array/Dictionary), "
+                            + "or make the closure non-async."
+                    )
+                )
+                return nil
+            }
+
+            var isThrows = false
+            if let throwsClause = functionType.effectSpecifiers?.throwsClause {
+                // BridgeJS only bridges `throws(JSException)`; reject any other thrown type,
+                // mirroring the function-level check in `collectEffects`.
+                guard let thrownType = throwsClause.type,
+                    thrownType.trimmedDescription == "JSException"
+                else {
+                    errors.append(
+                        DiagnosticError(
+                            node: throwsClause,
+                            message:
+                                "Only JSException is supported for thrown type of Swift closures, "
+                                + "got \(throwsClause.type?.trimmedDescription ?? "unspecified")",
+                            hint: "Annotate the closure as `throws(JSException)`"
+                        )
+                    )
+                    return nil
+                }
+                isThrows = true
+            }
 
             return .closure(
                 ClosureSignature(
@@ -1028,22 +1069,6 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             guard let type = resolvedType else {
                 continue  // Skip unsupported types
             }
-            if case .closure(let signature, _) = type {
-                if signature.isAsync {
-                    diagnose(
-                        node: param.type,
-                        message: "Async is not supported for Swift closures yet."
-                    )
-                    continue
-                }
-                if signature.isThrows {
-                    diagnose(
-                        node: param.type,
-                        message: "Throws is not supported for Swift closures yet."
-                    )
-                    continue
-                }
-            }
             if case .nullable(let wrappedType, _) = type, wrappedType.isOptional {
                 diagnoseNestedOptional(node: param.type, type: param.type.trimmedDescription)
                 continue

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -893,8 +893,12 @@ public struct BridgeJSLink {
         functionName: String
     ) throws -> [String] {
         let printer = CodeFragmentPrinter()
+        // Sync closures read the synchronous `tmpRetException` and are always generated
+        // as throwing on the JS side. Async closures instead return the `Promise`
+        // produced by `invoke_swift_closure_*` (JS sees a `(a) => Promise<R>` function),
+        // so rejection propagates through that Promise rather than `tmpRetException`.
         let builder = ExportedThunkBuilder(
-            effects: Effects(isAsync: false, isThrows: true),
+            effects: Effects(isAsync: signature.isAsync, isThrows: signature.isAsync ? signature.isThrows : true),
             hasDirectAccessToSwiftClass: false,
             intrinsicRegistry: intrinsicRegistry
         )
@@ -3743,7 +3747,11 @@ extension BridgeType {
             let paramTypes = signature.parameters.enumerated().map { index, param in
                 "arg\(index): \(param.tsType)"
             }.joined(separator: ", ")
-            return "(\(paramTypes)) => \(signature.returnType.tsType)"
+            // An async closure crosses the boundary as a JS `Promise`, so its TS type is
+            // `(...) => Promise<R>` (a rejection models a throw).
+            let returnTS =
+                signature.isAsync ? "Promise<\(signature.returnType.tsType)>" : signature.returnType.tsType
+            return "(\(paramTypes)) => \(returnTS)"
         case .array(let elementType):
             let inner = elementType.tsType
             if inner.contains("|") || inner.contains("=>") {