BridgeJS: Add BridgeABIFamily and refactor ExportSwift/ImportTS to use family-based dispatch

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -888,25 +888,38 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
+        // Handle containers and optionals first (recursive/special structure)
         switch type {
-        case .string, .int, .uint, .bool, .float, .double, .jsValue,
-            .jsObject(nil), .swiftHeapObject, .unsafePointer, .closure,
-            .caseEnum, .rawValueEnum:
-            return ["\(raw: accessor).bridgeJSLowerStackReturn()"]
-        case .jsObject(_?):
-            return ["\(raw: accessor).jsObject.bridgeJSLowerStackReturn()"]
-        case .swiftProtocol:
-            return ["(\(raw: accessor) as! \(raw: type.swiftType)).bridgeJSLowerStackReturn()"]
-        case .associatedValueEnum, .swiftStruct:
-            return ["\(raw: accessor).bridgeJSLowerReturn()"]
+
         case .nullable(let wrappedType, _):
             return lowerOptionalStatements(wrappedType: wrappedType, accessor: accessor, varPrefix: varPrefix)
-        case .void, .namespaceEnum:
-            return []
         case .array(let elementType):
             return lowerArrayStatements(elementType: elementType, accessor: accessor, varPrefix: varPrefix)
         case .dictionary(let valueType):
             return lowerDictionaryStatements(valueType: valueType, accessor: accessor, varPrefix: varPrefix)
+        default:
+            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:
+            return []
         }
     }
 
@@ -915,6 +928,7 @@ 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()"]
@@ -1019,11 +1033,9 @@ struct StackCodegen {
         accessor: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
-        switch wrappedType {
-        case .array, .dictionary, .swiftStruct:
+        // Stack-based types use the generic Optional conformance directly
+        if wrappedType.abiFamily == .stackBased {
             return ["\(raw: accessor).bridgeJSLowerReturn()"]
-        default:
-            break
         }
 
         var statements: [String] = []
@@ -1050,20 +1062,23 @@ struct StackCodegen {
         unwrappedVar: String,
         varPrefix: String
     ) -> [CodeBlockItemSyntax] {
+        // Handle types needing accessor transformation
         switch wrappedType {
-        case .string, .int, .uint, .bool, .float, .double, .jsValue:
-            return ["\(raw: unwrappedVar).bridgeJSLowerStackReturn()"]
-        case .caseEnum, .rawValueEnum:
-            return ["\(raw: unwrappedVar).bridgeJSLowerStackReturn()"]
-        case .swiftHeapObject:
-            return ["\(raw: unwrappedVar).bridgeJSLowerStackReturn()"]
-        case .associatedValueEnum:
-            return ["_swift_js_push_i32(\(raw: unwrappedVar).bridgeJSLowerParameter())"]
-        case .jsObject(nil):
-            return ["\(raw: unwrappedVar).bridgeJSLowerStackReturn()"]
-        case .jsObject(_?):
+        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:
             return ["preconditionFailure(\"BridgeJS: unsupported optional wrapped type\")"]
         }
     }
@@ -1677,17 +1692,6 @@ extension BridgeType {
 
     func liftParameterInfo() throws -> LiftingIntrinsicInfo {
         switch self {
-        case .bool: return .bool
-        case .int, .uint: return .int
-        case .float: return .float
-        case .double: return .double
-        case .string: return .string
-        case .jsObject: return .jsObject
-        case .jsValue: return .jsValue
-        case .swiftHeapObject: return .swiftHeapObject
-        case .unsafePointer: return .unsafePointer
-        case .swiftProtocol: return .jsObject
-        case .void: return .void
         case .nullable(let wrappedType, _):
             let wrappedInfo = try wrappedType.liftParameterInfo()
             if wrappedInfo.parameters.isEmpty {
@@ -1696,19 +1700,39 @@ extension BridgeType {
             var optionalParams: [(name: String, type: WasmCoreType)] = [("isSome", .i32)]
             optionalParams.append(contentsOf: wrappedInfo.parameters)
             return LiftingIntrinsicInfo(parameters: optionalParams)
-        case .caseEnum: return .caseEnum
-        case .rawValueEnum(_, let rawType):
-            return rawType.liftingIntrinsicInfo
-        case .associatedValueEnum:
-            return .associatedValueEnum
-        case .swiftStruct:
-            return LiftingIntrinsicInfo(parameters: [])
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
-        case .closure:
-            return LiftingIntrinsicInfo(parameters: [("callbackId", .i32)])
-        case .array, .dictionary:
+        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
         }
     }
 
@@ -1735,31 +1759,23 @@ extension BridgeType {
 
     func loweringReturnInfo() throws -> LoweringIntrinsicInfo {
         switch self {
-        case .bool: return .bool
-        case .int, .uint: return .int
-        case .float: return .float
-        case .double: return .double
-        case .string: return .string
-        case .jsObject: return .jsObject
-        case .jsValue: return .jsValue
-        case .swiftHeapObject: return .swiftHeapObject
-        case .unsafePointer: return .unsafePointer
-        case .swiftProtocol: return .jsObject
-        case .void: return .void
-        case .nullable: return .optional
-        case .caseEnum: return .caseEnum
-        case .rawValueEnum(_, let rawType):
-            return rawType.loweringIntrinsicInfo
-        case .associatedValueEnum:
-            return .associatedValueEnum
-        case .swiftStruct:
-            return .swiftStruct
+        case .nullable:
+            return .optional
         case .namespaceEnum:
             throw BridgeJSCoreError("Namespace enums are not supported to pass as parameters")
-        case .closure:
-            return .jsObject
-        case .array, .dictionary:
-            return .array
+        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
         }
     }
 }