BridgeJS: Add reusable instrinsics for stack-based types

Author: krodak

Benchmarks/Sources/Generated/BridgeJS.swift

@@ -798,60 +798,56 @@ struct StackCodegen {
     /// - Returns: An ExprSyntax representing the lift expression
     func liftExpression(for type: BridgeType) -> ExprSyntax {
         switch type {
-        case .string:
-            return "String.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .int, .uint:
-            return "Int.bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .bool:
-            return "Bool.bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .float:
-            return "Float.bridgeJSLiftParameter(_swift_js_pop_param_f32())"
-        case .double:
-            return "Double.bridgeJSLiftParameter(_swift_js_pop_param_f64())"
-        case .jsObject:
-            return "JSObject.bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .swiftHeapObject(let className):
-            return "\(raw: className).bridgeJSLiftParameter(_swift_js_pop_param_pointer())"
+        case .string, .int, .uint, .bool, .float, .double,
+            .jsObject, .swiftStruct, .swiftHeapObject:
+            return "\(raw: type.swiftType).bridgeJSLiftParameter()"
         case .unsafePointer:
             return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_pointer())"
         case .swiftProtocol(let protocolName):
-            // Protocols use their Any wrapper type for lifting
-            let wrapperName = "Any\(protocolName)"
-            return "\(raw: wrapperName).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .caseEnum(let enumName):
-            return "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .rawValueEnum(let enumName, let rawType):
+            return "Any\(raw: protocolName).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
+        case .caseEnum:
+            return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
+        case .rawValueEnum(_, let rawType):
             switch rawType {
             case .string:
                 return
-                    "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
+                    "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
             case .float:
-                return "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_f32())"
+                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_f32())"
             case .double:
-                return "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_f64())"
+                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_f64())"
             case .bool, .int, .int32, .int64, .uint, .uint32, .uint64:
-                return "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
+                return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
             }
-        case .associatedValueEnum(let enumName):
-            return "\(raw: enumName).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .swiftStruct(let structName):
-            return "\(raw: structName).bridgeJSLiftParameter()"
+        case .associatedValueEnum:
+            return "\(raw: type.swiftType).bridgeJSLiftParameter(_swift_js_pop_param_int32())"
         case .optional(let wrappedType):
             return liftOptionalExpression(wrappedType: wrappedType)
-        case .void:
-            // Void shouldn't be lifted, but return a placeholder
-            return "()"
-        case .namespaceEnum:
-            // Namespace enums are not passed as values
-            return "()"
-        case .closure:
-            return "JSObject.bridgeJSLiftParameter(_swift_js_pop_param_int32())"
         case .array(let elementType):
             return liftArrayExpression(elementType: elementType)
+        case .closure:
+            return "JSObject.bridgeJSLiftParameter()"
+        case .void, .namespaceEnum:
+            return "()"
         }
     }
 
     func liftArrayExpression(elementType: BridgeType) -> ExprSyntax {
+        switch elementType {
+        case .int, .uint, .float, .double, .string, .bool,
+            .jsObject, .swiftStruct, .caseEnum, .swiftHeapObject,
+            .unsafePointer, .rawValueEnum, .associatedValueEnum:
+            return "[\(raw: elementType.swiftType)].bridgeJSLiftParameter()"
+        case .swiftProtocol(let protocolName):
+            return "[Any\(raw: protocolName)].bridgeJSLiftParameter()"
+        case .optional, .array, .closure:
+            return liftArrayExpressionInline(elementType: elementType)
+        case .void, .namespaceEnum:
+            fatalError("Invalid array element type: \(elementType)")
+        }
+    }
+
+    private func liftArrayExpressionInline(elementType: BridgeType) -> ExprSyntax {
         let elementLift = liftExpression(for: elementType)
         let swiftTypeName = elementType.swiftType
         return """
@@ -870,45 +866,9 @@ struct StackCodegen {
 
     private func liftOptionalExpression(wrappedType: BridgeType) -> ExprSyntax {
         switch wrappedType {
-        case .string:
-            return
-                "Optional<String>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .int, .uint:
-            return "Optional<Int>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .bool:
-            return "Optional<Bool>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .float:
-            return "Optional<Float>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_f32())"
-        case .double:
-            return "Optional<Double>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_f64())"
-        case .caseEnum(let enumName):
-            return
-                "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .rawValueEnum(let enumName, let rawType):
-            switch rawType {
-            case .string:
-                return
-                    "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-            case .float:
-                return
-                    "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_f32())"
-            case .double:
-                return
-                    "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_f64())"
-            case .bool, .int, .int32, .int64, .uint, .uint32, .uint64:
-                return
-                    "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-            }
-        case .swiftStruct(let nestedName):
-            return "Optional<\(raw: nestedName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32())"
-        case .swiftHeapObject(let className):
-            return
-                "Optional<\(raw: className)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_pointer())"
-        case .associatedValueEnum(let enumName):
-            return
-                "Optional<\(raw: enumName)>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
-        case .jsObject:
-            return "Optional<JSObject>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
+        case .string, .int, .uint, .bool, .float, .double, .jsObject,
+            .swiftStruct, .swiftHeapObject, .caseEnum, .associatedValueEnum, .rawValueEnum:
+            return "Optional<\(raw: wrappedType.swiftType)>.bridgeJSLiftParameter()"
         case .array(let elementType):
             let arrayLift = liftArrayExpression(elementType: elementType)
             let swiftTypeName = elementType.swiftType
@@ -922,9 +882,8 @@ struct StackCodegen {
                     }
                 }()
                 """
-        default:
-            // Fallback for other optional types
-            return "Optional<Int>.bridgeJSLiftParameter(_swift_js_pop_param_int32(), _swift_js_pop_param_int32())"
+        case .void, .namespaceEnum, .closure, .optional, .unsafePointer, .swiftProtocol:
+            fatalError("Invalid optional wrapped type: \(wrappedType)")
         }
     }
 
@@ -999,6 +958,29 @@ struct StackCodegen {
         elementType: BridgeType,
         accessor: String,
         varPrefix: String
+    ) -> [CodeBlockItemSyntax] {
+        switch elementType {
+        case .int, .uint, .float, .double, .string, .bool,
+            .jsObject, .swiftStruct, .caseEnum, .swiftHeapObject,
+            .unsafePointer, .rawValueEnum, .associatedValueEnum:
+            return ["\(raw: accessor).bridgeJSLowerReturn()"]
+        case .swiftProtocol(let protocolName):
+            return ["\(raw: accessor).map { $0 as! Any\(raw: protocolName) }.bridgeJSLowerReturn()"]
+        case .optional, .array, .closure:
+            return lowerArrayStatementsInline(
+                elementType: elementType,
+                accessor: accessor,
+                varPrefix: varPrefix
+            )
+        case .void, .namespaceEnum:
+            fatalError("Invalid array element type: \(elementType)")
+        }
+    }
+
+    private func lowerArrayStatementsInline(
+        elementType: BridgeType,
+        accessor: String,
+        varPrefix: String
     ) -> [CodeBlockItemSyntax] {
         var statements: [CodeBlockItemSyntax] = []
         let elementVarName = "__bjs_elem_\(varPrefix)"