BridgeJS: Replace per-type ABI switches with unified BridgeTypeDescriptor

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -916,7 +916,6 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        // Handle containers and optionals first (recursive/special structure)
         switch type {
         case .nullable(let wrappedType, _):
             return lowerOptionalStatements(wrappedType: wrappedType, accessor: accessor, varPrefix: varPrefix)
@@ -928,24 +927,14 @@ struct StackCodegen {
             break
         }
 
-        // Handle types that need accessor transformation before lowering
-        switch type {
-        case .jsObject(let className?) where className != "JSObject":
-            return ["\(raw: accessor).jsObject.bridgeJSLowerStackReturn()"]
-        case .swiftProtocol(let protocolName):
-            let wrapperName = "Any\(protocolName)"
-            return ["(\(raw: accessor) as! \(raw: wrapperName)).bridgeJSLowerStackReturn()"]
-        default:
-            break
-        }
-
-        // Family-based lowering
-        switch type.abiFamily {
-        case .directScalar, .directMultiWord:
-            return ["\(raw: accessor).bridgeJSLowerStackReturn()"]
-        case .taggedPayload, .stackBased:
-            return ["\(raw: accessor).bridgeJSLowerReturn()"]
-        case .void:
+        let desc = type.descriptor
+        let transformed = desc.accessorTransform.apply(accessor)
+        switch desc.lowerMethod {
+        case .stackReturn:
+            return ["\(raw: transformed).bridgeJSLowerStackReturn()"]
+        case .fullReturn, .pushParameter:
+            return ["\(raw: transformed).bridgeJSLowerReturn()"]
+        case .none:
             return []
         }
     }
@@ -1060,8 +1049,7 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        // Stack-based types use the generic Optional conformance directly
-        if wrappedType.abiFamily == .stackBased {
+        if wrappedType.descriptor.optionalUsesStackABI {
             return ["\(raw: accessor).bridgeJSLowerReturn()"]
         }
 
@@ -1089,23 +1077,16 @@ struct StackCodegen {
         unwrappedVar: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        // Handle types needing accessor transformation
-        switch wrappedType {
-        case .jsObject(let className?) where className != "JSObject":
-            return ["\(raw: unwrappedVar).jsObject.bridgeJSLowerStackReturn()"]
-        default:
-            break
-        }
-
-        // Family-based lowering for unwrapped optional values
-        switch wrappedType.abiFamily {
-        case .directScalar, .directMultiWord:
-            return ["\(raw: unwrappedVar).bridgeJSLowerStackReturn()"]
-        case .taggedPayload:
-            return ["_swift_js_push_i32(\(raw: unwrappedVar).bridgeJSLowerParameter())"]
-        case .stackBased:
-            return ["\(raw: unwrappedVar).bridgeJSLowerReturn()"]
-        case .void:
+        let desc = wrappedType.descriptor
+        let transformed = desc.accessorTransform.apply(unwrappedVar)
+        switch desc.lowerMethod {
+        case .stackReturn:
+            return ["\(raw: transformed).bridgeJSLowerStackReturn()"]
+        case .fullReturn:
+            return ["\(raw: transformed).bridgeJSLowerReturn()"]
+        case .pushParameter:
+            return ["_swift_js_push_i32(\(raw: transformed).bridgeJSLowerParameter())"]
+        case .none:
             return ["preconditionFailure(\"BridgeJS: unsupported optional wrapped type\")"]
         }
     }
@@ -1730,101 +1711,22 @@ extension BridgeType {
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
         default:
-            return liftParameterInfoForNonOptional()
-        }
-    }
-
-    private func liftParameterInfoForNonOptional() -> LiftingIntrinsicInfo {
-        switch abiFamily {
-        case .directScalar(let wasmType):
-            let name: String
-            switch self {
-            case .closure: name = "callbackId"
-            default: name = "value"
-            }
-            return LiftingIntrinsicInfo(parameters: [(name, wasmType)])
-        case .directMultiWord:
-            switch self {
-            case .string:
-                return .string
-            case .jsValue:
-                return .jsValue
-            case .rawValueEnum(_, let rawType):
-                return rawType.liftingIntrinsicInfo
-            default:
-                fatalError("Unexpected directMultiWord type: \(self)")
-            }
-        case .taggedPayload:
-            return .associatedValueEnum
-        case .stackBased:
-            return LiftingIntrinsicInfo(parameters: [])
-        case .void:
-            return .void
+            return LiftingIntrinsicInfo(parameters: descriptor.wasmParams)
         }
     }
 
     struct LoweringIntrinsicInfo: Sendable {
         let returnType: WasmCoreType?
-
-        static let bool = LoweringIntrinsicInfo(returnType: .i32)
-        static let int = LoweringIntrinsicInfo(returnType: .i32)
-        static let float = LoweringIntrinsicInfo(returnType: .f32)
-        static let double = LoweringIntrinsicInfo(returnType: .f64)
-        static let string = LoweringIntrinsicInfo(returnType: nil)
-        static let jsObject = LoweringIntrinsicInfo(returnType: .i32)
-        static let jsValue = LoweringIntrinsicInfo(returnType: nil)
-        static let swiftHeapObject = LoweringIntrinsicInfo(returnType: .pointer)
-        static let unsafePointer = LoweringIntrinsicInfo(returnType: .pointer)
-        static let void = LoweringIntrinsicInfo(returnType: nil)
-        static let caseEnum = LoweringIntrinsicInfo(returnType: .i32)
-        static let rawValueEnum = LoweringIntrinsicInfo(returnType: .i32)
-        static let associatedValueEnum = LoweringIntrinsicInfo(returnType: nil)
-        static let swiftStruct = LoweringIntrinsicInfo(returnType: nil)
-        static let optional = LoweringIntrinsicInfo(returnType: nil)
-        static let array = LoweringIntrinsicInfo(returnType: nil)
     }
 
     func loweringReturnInfo() throws -> LoweringIntrinsicInfo {
         switch self {
         case .nullable:
-            return .optional
+            return LoweringIntrinsicInfo(returnType: nil)
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
         default:
-            return loweringReturnInfoForNonOptional()
-        }
-    }
-
-    private func loweringReturnInfoForNonOptional() -> LoweringIntrinsicInfo {
-        switch abiFamily {
-        case .directScalar(let wasmType):
-            return LoweringIntrinsicInfo(returnType: wasmType)
-        case .directMultiWord, .stackBased, .taggedPayload:
-            return LoweringIntrinsicInfo(returnType: nil)
-        case .void:
-            return .void
-        }
-    }
-}
-
-extension SwiftEnumRawType {
-    var liftingIntrinsicInfo: BridgeType.LiftingIntrinsicInfo {
-        switch self {
-        case .bool: return .bool
-        case .int, .int32, .int64, .uint, .uint32, .uint64: return .int
-        case .float: return .float
-        case .double: return .double
-        case .string: return .string
-        }
-    }
-
-    var loweringIntrinsicInfo: BridgeType.LoweringIntrinsicInfo {
-        switch self {
-        case .bool: return .bool
-        case .int, .int32, .int64, .uint, .uint32, .uint64: return .int
-        case .float: return .float
-        case .double: return .double
-        case .string: return .string
+            return LoweringIntrinsicInfo(returnType: descriptor.wasmReturnType)
         }
     }
 }

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -695,19 +695,6 @@ enum SwiftCodePattern {
 extension BridgeType {
     struct LoweringParameterInfo {
         let loweredParameters: [(name: String, type: WasmCoreType)]
-
-        static let bool = LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        static let int = LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        static let float = LoweringParameterInfo(loweredParameters: [("value", .f32)])
-        static let double = LoweringParameterInfo(loweredParameters: [("value", .f64)])
-        static let string = LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        static let jsObject = LoweringParameterInfo(loweredParameters: [("value", .i32)])
-        static let jsValue = LoweringParameterInfo(loweredParameters: [
-            ("kind", .i32),
-            ("payload1", .i32),
-            ("payload2", .f64),
-        ])
-        static let void = LoweringParameterInfo(loweredParameters: [])
     }
 
     func loweringParameterInfo(context: BridgeContext = .importTS) throws -> LoweringParameterInfo {
@@ -732,57 +719,22 @@ extension BridgeType {
     }
 
     private func loweringParameterInfoForNonOptional(context: BridgeContext) throws -> LoweringParameterInfo {
-        // Special context-dependent overrides
-        if context == .importTS {
-            switch self {
-            case .swiftStruct:
-                return LoweringParameterInfo(loweredParameters: [("objectId", .i32)])
-            default:
-                break
-            }
+        switch self {
+        case .swiftStruct where context == .importTS:
+            return LoweringParameterInfo(loweredParameters: [("objectId", .i32)])
+        case .string:
+            return LoweringParameterInfo(loweredParameters: [("value", .i32)])
+        case .rawValueEnum(_, .string):
+            return LoweringParameterInfo(loweredParameters: [("value", .i32)])
+        default:
+            break
         }
 
-        switch abiFamily {
-        case .directScalar(let wasmType):
-            let name: String
-            switch self {
-            case .closure: name = "funcRef"
-            case .swiftHeapObject, .unsafePointer: name = "pointer"
-            default: name = "value"
-            }
-            return LoweringParameterInfo(loweredParameters: [(name, wasmType)])
-        case .directMultiWord:
-            switch self {
-            case .string:
-                return .string
-            case .jsValue:
-                return .jsValue
-            case .rawValueEnum(_, let rawType):
-                let wasmType = rawType.wasmCoreType ?? .i32
-                return LoweringParameterInfo(loweredParameters: [("value", wasmType)])
-            default:
-                fatalError("Unexpected directMultiWord type: \(self)")
-            }
-        case .taggedPayload:
-            return LoweringParameterInfo(loweredParameters: [("caseId", .i32)])
-        case .stackBased:
-            return LoweringParameterInfo(loweredParameters: [])
-        case .void:
-            return .void
-        }
+        return LoweringParameterInfo(loweredParameters: descriptor.wasmParams)
     }
 
     struct LiftingReturnInfo {
         let valueToLift: WasmCoreType?
-
-        static let bool = LiftingReturnInfo(valueToLift: .i32)
-        static let int = LiftingReturnInfo(valueToLift: .i32)
-        static let float = LiftingReturnInfo(valueToLift: .f32)
-        static let double = LiftingReturnInfo(valueToLift: .f64)
-        static let string = LiftingReturnInfo(valueToLift: .i32)
-        static let jsObject = LiftingReturnInfo(valueToLift: .i32)
-        static let jsValue = LiftingReturnInfo(valueToLift: nil)
-        static let void = LiftingReturnInfo(valueToLift: nil)
     }
 
     func liftingReturnInfo(
@@ -807,7 +759,6 @@ extension BridgeType {
     }
 
     private func liftingReturnInfoForNonOptional(context: BridgeContext) -> LiftingReturnInfo {
-        // Special context-dependent overrides
         if context == .importTS {
             switch self {
             case .swiftStruct:
@@ -816,29 +767,7 @@ extension BridgeType {
                 break
             }
         }
-
-        switch abiFamily {
-        case .directScalar(let wasmType):
-            return LiftingReturnInfo(valueToLift: wasmType)
-        case .directMultiWord:
-            switch self {
-            case .string:
-                return .string
-            case .jsValue:
-                return .jsValue
-            case .rawValueEnum(_, let rawType):
-                let wasmType = rawType.wasmCoreType ?? .i32
-                return LiftingReturnInfo(valueToLift: wasmType)
-            default:
-                fatalError("Unexpected directMultiWord type: \(self)")
-            }
-        case .taggedPayload:
-            return LiftingReturnInfo(valueToLift: .i32)
-        case .stackBased:
-            return LiftingReturnInfo(valueToLift: nil)
-        case .void:
-            return .void
-        }
+        return LiftingReturnInfo(valueToLift: descriptor.importReturnType)
     }
 }