BridgeJS: Move usesSideChannelForOptionalReturn and usesStackLifting into descriptor, unify return-type switches

Author: krodak

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)")
             }
         }
 
@@ -778,30 +720,15 @@ struct StackCodegen {
     func liftExpression(for type: BridgeType) -> ExprSyntax {
         switch type {
         case .string, .int, .uint, .bool, .float, .double,
-            .jsObject(nil), .jsValue, .swiftStruct, .swiftHeapObject:
+            .jsObject(nil), .jsValue, .swiftStruct, .swiftHeapObject, .unsafePointer:
             return "\(raw: type.swiftType).bridgeJSLiftParameter()"
         case .jsObject(let className?):
             return "\(raw: className)(unsafelyWrapping: JSObject.bridgeJSLiftParameter())"
-        case .unsafePointer:
-            return "\(raw: type.swiftType).bridgeJSLiftParameter()"
-        case .swiftProtocol(let protocolName):
-            return "Any\(raw: protocolName).bridgeJSLiftParameter(_swift_js_pop_i32())"
-        case .caseEnum:
-            return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_i32())"
-        case .rawValueEnum(_, let rawType):
-            switch rawType {
-            case .string:
-                return
-                    "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_i32(), _swift_js_pop_i32())"
-            case .float:
-                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_f32())"
-            case .double:
-                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_f64())"
-            case .bool, .int, .int32, .int64, .uint, .uint32, .uint64:
-                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_i32())"
-            }
-        case .associatedValueEnum:
+        case .swiftProtocol, .caseEnum, .associatedValueEnum:
             return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_i32())"
+        case .rawValueEnum:
+            let popArgs = type.descriptor.wasmParams.map { "_swift_js_pop_\($0.type.rawValue)()" }.joined(separator: ", ")
+            return "\(raw: type.swiftType).bridgeJSLiftParameter(\(raw: popArgs))"
         case .nullable(let wrappedType, let kind):
             return liftNullableExpression(wrappedType: wrappedType, kind: kind)
         case .array(let elementType):
@@ -819,12 +746,8 @@ struct StackCodegen {
         switch elementType {
         case .jsObject(let className?) where className != "JSObject":
             return liftArrayExpressionInline(elementType: elementType)
-        case .swiftProtocol(let protocolName):
-            return "[Any\(raw: protocolName)].bridgeJSLiftParameter()"
         case .nullable, .closure:
             return liftArrayExpressionInline(elementType: elementType)
-        case .void, .namespaceEnum:
-            fatalError("Invalid array element type: \(elementType)")
         default:
             return "[\(raw: elementType.swiftType)].bridgeJSLiftParameter()"
         }
@@ -943,23 +866,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(let protocolName):
-            return ["\(raw: accessor).map { $0 as! Any\(raw: protocolName) }.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(
@@ -991,22 +907,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(let protocolName):
-            return ["\(raw: accessor).mapValues { $0 as! Any\(raw: protocolName) }.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(