BridgeJS: Add OptionalConvention, move side-channel/stack flags to descriptor, unify return-type switches

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ClosureCodegen.swift

@@ -148,14 +148,12 @@ public struct ClosureCodegen {
         let abiReturnWasmType: WasmCoreType?
         if signature.returnType == .void {
             abiReturnWasmType = nil
-        } else if let wasmType = try signature.returnType.loweringReturnInfo().returnType {
+        } else if let wasmType = try signature.returnType.loweringReturnInfo() {
             abiReturnWasmType = wasmType
         } else {
             abiReturnWasmType = nil
         }
 
-        let throwReturn = abiReturnWasmType?.swiftReturnPlaceholderStmt ?? "return"
-
         // Build signature using SwiftSignatureBuilder
         let funcSignature = SwiftSignatureBuilder.buildABIFunctionSignature(
             abiParameters: abiParams,

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -134,39 +134,26 @@ public class ExportSwift {
             case .closure(let signature, _):
                 typeNameForIntrinsic = param.type.swiftType
                 liftingExpr = ExprSyntax("_BJS_Closure_\(raw: signature.mangleName).bridgeJSLift(\(raw: param.name))")
-            case .swiftStruct(let structName):
-                typeNameForIntrinsic = structName
-                liftingExpr = ExprSyntax("\(raw: structName).bridgeJSLiftParameter()")
             case .array:
                 typeNameForIntrinsic = param.type.swiftType
                 liftingExpr = StackCodegen().liftExpression(for: param.type)
             case .nullable(let wrappedType, let kind):
-                let optionalSwiftType: String
-                if case .null = kind {
-                    optionalSwiftType = "Optional"
-                } else {
-                    optionalSwiftType = "JSUndefinedOr"
-                }
-                if case .swiftProtocol(let protocolName) = wrappedType {
-                    let wrapperName = "Any\(protocolName)"
-                    typeNameForIntrinsic = "\(optionalSwiftType)<\(wrapperName)>"
-                    liftingExpr = ExprSyntax(
-                        "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
-                    )
-                } else {
-                    typeNameForIntrinsic = "\(optionalSwiftType)<\(wrappedType.swiftType)>"
-                    liftingExpr = ExprSyntax(
-                        "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
-                    )
-                }
-            case .swiftProtocol(let protocolName):
-                let wrapperName = "Any\(protocolName)"
-                typeNameForIntrinsic = wrapperName
+                let optionalSwiftType: String =
+                    if case .null = kind { "Optional" } else { "JSUndefinedOr" }
+                let wrappedName: String =
+                    if case .cast(let name) = wrappedType.descriptor.accessorTransform { name } else {
+                        wrappedType.swiftType
+                    }
+                typeNameForIntrinsic = "\(optionalSwiftType)<\(wrappedName)>"
                 liftingExpr = ExprSyntax(
-                    "\(raw: wrapperName).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
+                    "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
                 )
             default:
-                typeNameForIntrinsic = param.type.swiftType
+                if case .cast(let name) = param.type.descriptor.accessorTransform {
+                    typeNameForIntrinsic = name
+                } else {
+                    typeNameForIntrinsic = param.type.swiftType
+                }
                 liftingExpr = ExprSyntax(
                     "\(raw: typeNameForIntrinsic).bridgeJSLiftParameter(\(raw: argumentsToLift.joined(separator: ", ")))"
                 )
@@ -211,26 +198,9 @@ public class ExportSwift {
             if returnType == .void {
                 return CodeBlockItemSyntax(item: .init(ExpressionStmtSyntax(expression: callExpr)))
             } else {
-                switch returnType {
-                case .swiftProtocol(let protocolName):
-                    let wrapperName = "Any\(protocolName)"
-                    return CodeBlockItemSyntax(
-                        item: .init(DeclSyntax("let ret = \(raw: callExpr) as! \(raw: wrapperName)"))
-                    )
-                case .nullable(let wrappedType, _):
-                    if case .swiftProtocol(let protocolName) = wrappedType {
-                        let wrapperName = "Any\(protocolName)"
-                        return CodeBlockItemSyntax(
-                            item: .init(
-                                DeclSyntax("let ret = (\(raw: callExpr)).flatMap { $0 as? \(raw: wrapperName) }")
-                            )
-                        )
-                    } else {
-                        return CodeBlockItemSyntax(item: .init(DeclSyntax("let ret = \(raw: callExpr)")))
-                    }
-                default:
-                    return CodeBlockItemSyntax(item: .init(DeclSyntax("let ret = \(raw: callExpr)")))
-                }
+                let binding = returnType.descriptor.accessorTransform
+                    .applyToReturnBinding("\(callExpr)", isOptional: returnType.isOptional)
+                return CodeBlockItemSyntax(item: .init(DeclSyntax("\(raw: binding)")))
             }
         }
 
@@ -244,20 +214,9 @@ public class ExportSwift {
             if returnType == .void {
                 append("\(raw: name)")
             } else {
-                switch returnType {
-                case .swiftProtocol(let protocolName):
-                    let wrapperName = "Any\(protocolName)"
-                    append("let ret = \(raw: name) as! \(raw: wrapperName)")
-                case .nullable(let wrappedType, _):
-                    if case .swiftProtocol(let protocolName) = wrappedType {
-                        let wrapperName = "Any\(protocolName)"
-                        append("let ret = \(raw: name).flatMap { $0 as? \(raw: wrapperName) }")
-                    } else {
-                        append("let ret = \(raw: name)")
-                    }
-                default:
-                    append("let ret = \(raw: name)")
-                }
+                let binding = returnType.descriptor.accessorTransform
+                    .applyToReturnBinding(name, isOptional: returnType.isOptional)
+                append("\(raw: binding)")
             }
         }
 
@@ -274,14 +233,7 @@ public class ExportSwift {
         /// Generates intermediate variables for stack-using parameters if needed for LIFO compatibility
         private func generateParameterLifting() {
             let stackParamIndices = parameters.enumerated().compactMap { index, param -> Int? in
-                switch param.type {
-                case .swiftStruct, .nullable(.swiftStruct, _),
-                    .associatedValueEnum, .nullable(.associatedValueEnum, _),
-                    .array:
-                    return index
-                default:
-                    return nil
-                }
+                param.type.descriptor.usesStackLifting ? index : nil
             }
 
             guard stackParamIndices.count > 1 else { return }
@@ -298,23 +250,13 @@ public class ExportSwift {
 
         func callPropertyGetter(propertyName: String, returnType: BridgeType) {
             let (_, selfExpr) = removeFirstLiftedParameter()
+            let expr = "\(selfExpr).\(propertyName)"
             if returnType == .void {
-                append("\(raw: selfExpr).\(raw: propertyName)")
+                append("\(raw: expr)")
             } else {
-                switch returnType {
-                case .swiftProtocol(let protocolName):
-                    let wrapperName = "Any\(protocolName)"
-                    append("let ret = \(raw: selfExpr).\(raw: propertyName) as! \(raw: wrapperName)")
-                case .nullable(let wrappedType, _):
-                    if case .swiftProtocol(let protocolName) = wrappedType {
-                        let wrapperName = "Any\(protocolName)"
-                        append("let ret = \(raw: selfExpr).\(raw: propertyName).flatMap { $0 as? \(raw: wrapperName) }")
-                    } else {
-                        append("let ret = \(raw: selfExpr).\(raw: propertyName)")
-                    }
-                default:
-                    append("let ret = \(raw: selfExpr).\(raw: propertyName)")
-                }
+                let binding = returnType.descriptor.accessorTransform
+                    .applyToReturnBinding(expr, isOptional: returnType.isOptional)
+                append("\(raw: binding)")
             }
         }
 
@@ -339,8 +281,7 @@ public class ExportSwift {
         }
 
         private func _lowerReturnValue(returnType: BridgeType) throws {
-            let loweringInfo = try returnType.loweringReturnInfo()
-            abiReturnType = loweringInfo.returnType
+            abiReturnType = try returnType.loweringReturnInfo()
             if returnType == .void {
                 return
             }
@@ -784,6 +725,7 @@ struct StackCodegen {
             return "\(raw: type.swiftType).bridgeJSLiftParameter()"
         case .jsObject(let className?):
             return "\(raw: className)(unsafelyWrapping: JSObject.bridgeJSLiftParameter())"
+
         case .nullable(let wrappedType, let kind):
             return liftNullableExpression(wrappedType: wrappedType, kind: kind)
         case .array(let elementType):
@@ -803,8 +745,6 @@ struct StackCodegen {
             return liftArrayExpressionInline(elementType: elementType)
         case .nullable, .closure:
             return liftArrayExpressionInline(elementType: elementType)
-        case .void, .namespaceEnum:
-            fatalError("Invalid array element type: \(elementType)")
         default:
             return "[\(raw: elementType.swiftType)].bridgeJSLiftParameter()"
         }
@@ -917,23 +857,16 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        // Types needing accessor transformation
-        switch elementType {
-        case .jsObject(let className?) where className != "JSObject":
-            return ["\(raw: accessor).map { $0.jsObject }.bridgeJSLowerReturn()"]
-        case .swiftProtocol:
-            return ["\(raw: accessor).map { $0 as! \(raw: elementType.swiftType) }.bridgeJSLowerReturn()"]
-        case .nullable, .closure:
-            return lowerArrayStatementsInline(
-                elementType: elementType,
-                accessor: accessor,
-                varPrefix: varPrefix
-            )
-        case .void, .namespaceEnum:
-            fatalError("Invalid array element type: \(elementType)")
-        default:
-            return ["\(raw: accessor).bridgeJSLowerReturn()"]
+        if case .nullable = elementType {
+            return lowerArrayStatementsInline(elementType: elementType, accessor: accessor, varPrefix: varPrefix)
+        }
+        if case .closure = elementType {
+            return lowerArrayStatementsInline(elementType: elementType, accessor: accessor, varPrefix: varPrefix)
         }
+        if let mapClosure = elementType.descriptor.accessorTransform.mapClosure {
+            return ["\(raw: accessor).map { \(raw: mapClosure) }.bridgeJSLowerReturn()"]
+        }
+        return ["\(raw: accessor).bridgeJSLowerReturn()"]
     }
 
     private func lowerArrayStatementsInline(
@@ -965,22 +898,16 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        switch valueType {
-        case .jsObject(let className?) where className != "JSObject":
-            return ["\(raw: accessor).mapValues { $0.jsObject }.bridgeJSLowerReturn()"]
-        case .swiftProtocol:
-            return ["\(raw: accessor).mapValues { $0 as! \(raw: valueType.swiftType) }.bridgeJSLowerReturn()"]
-        case .nullable, .closure:
-            return lowerDictionaryStatementsInline(
-                valueType: valueType,
-                accessor: accessor,
-                varPrefix: varPrefix
-            )
-        case .void, .namespaceEnum:
-            fatalError("Invalid dictionary value type: \(valueType)")
-        default:
-            return ["\(raw: accessor).bridgeJSLowerReturn()"]
+        if case .nullable = valueType {
+            return lowerDictionaryStatementsInline(valueType: valueType, accessor: accessor, varPrefix: varPrefix)
+        }
+        if case .closure = valueType {
+            return lowerDictionaryStatementsInline(valueType: valueType, accessor: accessor, varPrefix: varPrefix)
+        }
+        if let mapClosure = valueType.descriptor.accessorTransform.mapClosure {
+            return ["\(raw: accessor).mapValues { \(raw: mapClosure) }.bridgeJSLowerReturn()"]
         }
+        return ["\(raw: accessor).bridgeJSLowerReturn()"]
     }
 
     private func lowerDictionaryStatementsInline(
@@ -1022,7 +949,7 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        if wrappedType.descriptor.optionalUsesStackABI {
+        if wrappedType.descriptor.optionalConvention == .stackABI {
             return ["\(raw: accessor).bridgeJSLowerReturn()"]
         }
 
@@ -1655,20 +1582,6 @@ extension BridgeType {
     struct LiftingIntrinsicInfo: Sendable {
         let parameters: [(name: String, type: WasmCoreType)]
 
-        static let bool = LiftingIntrinsicInfo(parameters: [("value", .i32)])
-        static let int = LiftingIntrinsicInfo(parameters: [("value", .i32)])
-        static let float = LiftingIntrinsicInfo(parameters: [("value", .f32)])
-        static let double = LiftingIntrinsicInfo(parameters: [("value", .f64)])
-        static let string = LiftingIntrinsicInfo(parameters: [("bytes", .i32), ("length", .i32)])
-        static let jsObject = LiftingIntrinsicInfo(parameters: [("value", .i32)])
-        static let jsValue = LiftingIntrinsicInfo(parameters: [("kind", .i32), ("payload1", .i32), ("payload2", .f64)])
-        static let swiftHeapObject = LiftingIntrinsicInfo(parameters: [("value", .pointer)])
-        static let unsafePointer = LiftingIntrinsicInfo(parameters: [("pointer", .pointer)])
-        static let void = LiftingIntrinsicInfo(parameters: [])
-        static let caseEnum = LiftingIntrinsicInfo(parameters: [("value", .i32)])
-        static let associatedValueEnum = LiftingIntrinsicInfo(parameters: [
-            ("caseId", .i32)
-        ])
     }
 
     func liftParameterInfo() throws -> LiftingIntrinsicInfo {
@@ -1688,18 +1601,14 @@ extension BridgeType {
         }
     }
 
-    struct LoweringIntrinsicInfo: Sendable {
-        let returnType: WasmCoreType?
-    }
-
-    func loweringReturnInfo() throws -> LoweringIntrinsicInfo {
+    func loweringReturnInfo() throws -> WasmCoreType? {
         switch self {
         case .nullable:
-            return LoweringIntrinsicInfo(returnType: nil)
+            return nil
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
         default:
-            return LoweringIntrinsicInfo(returnType: descriptor.wasmReturnType)
+            return descriptor.wasmReturnType
         }
     }
 }

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -1535,15 +1535,15 @@ public struct BridgeJSLink {
 
         switch enumDefinition.enumType {
         case .simple:
-            let fragment = IntrinsicJSFragment.simpleEnumHelper(enumDefinition: enumDefinition)
+            let fragment = IntrinsicJSFragment.caseEnumHelper(enumDefinition: enumDefinition)
             _ = try fragment.printCode([enumValuesName], context)
             jsTopLevelLines.append(contentsOf: printer.lines)
         case .rawValue:
             guard enumDefinition.rawType != nil else {
                 throw BridgeJSLinkError(message: "Raw value enum \(enumDefinition.name) is missing rawType")
             }
 
-            let fragment = IntrinsicJSFragment.rawValueEnumHelper(enumDefinition: enumDefinition)
+            let fragment = IntrinsicJSFragment.caseEnumHelper(enumDefinition: enumDefinition)
             _ = try fragment.printCode([enumValuesName], context)
             jsTopLevelLines.append(contentsOf: printer.lines)
         case .associatedValue:
@@ -2172,7 +2172,7 @@ extension BridgeJSLink {
                 printer.write("} catch (error) {")
                 printer.indent {
                     printer.write("setException(error);")
-                    if let abiReturnType = returnType.abiReturnType {
+                    if !returnType.isOptional, let abiReturnType = returnType.descriptor.wasmReturnType {
                         printer.write("return \(abiReturnType.placeholderValue)")
                     }
                 }