BridgeJS: Generic function infrastructure and import implementation

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ExportSwift.swift

@@ -22,13 +22,20 @@ public class ExportSwift {
     let moduleName: String
     private let exposeToGlobal: Bool
     private var skeleton: ExportedSkeleton
+    private let hasGenerics: Bool
     private var sourceFiles: [(sourceFile: SourceFileSyntax, inputFilePath: String)] = []
 
-    public init(progress: ProgressReporting, moduleName: String, skeleton: ExportedSkeleton) {
+    public init(
+        progress: ProgressReporting,
+        moduleName: String,
+        skeleton: ExportedSkeleton,
+        hasGenerics: Bool = false
+    ) {
         self.progress = progress
         self.moduleName = moduleName
         self.exposeToGlobal = skeleton.exposeToGlobal
         self.skeleton = skeleton
+        self.hasGenerics = hasGenerics
     }
 
     /// Finalizes the export process and generates the bridge code
@@ -77,7 +84,7 @@ public class ExportSwift {
         }
 
         try withSpan("Render Structs") { [self] in
-            let structCodegen = StructCodegen()
+            let structCodegen = StructCodegen(hasGenerics: hasGenerics)
             for structDef in skeleton.structs {
                 decls.append(contentsOf: structCodegen.renderStructHelpers(structDef))
                 decls.append(contentsOf: try renderSingleExportedStruct(struct: structDef))
@@ -817,9 +824,29 @@ public class ExportSwift {
         // Generate ConvertibleToJSValue extension
         decls.append(contentsOf: renderConvertibleToJSValueExtension(klass: klass))
 
+        if hasGenerics, klass.isFinal == true {
+            decls.append(contentsOf: renderClassGenericConformance(klass: klass))
+        }
+
         return decls
     }
 
+    private func renderClassGenericConformance(klass: ExportedClass) -> [DeclSyntax] {
+        let typeName = klass.swiftCallName
+        let printer = CodeFragmentPrinter()
+        printer.write("extension \(typeName): _BridgedSwiftGenericBridgeable {")
+        printer.indent {
+            printer.write(
+                "@_spi(BridgeJS) public static var bridgeJSTypeName: StaticString { \"\(klass.abiName)\" }"
+            )
+            printer.write(
+                "@_spi(BridgeJS) public static let bridgeJSTypeID: Int32 = _swift_js_resolve_type_id(\(typeName).bridgeJSTypeName)"
+            )
+        }
+        printer.write("}")
+        return ["\(raw: printer.lines.joined(separator: "\n"))"]
+    }
+
     /// Generates a ConvertibleToJSValue extension for the exported class
     ///
     /// # Example
@@ -887,6 +914,8 @@ struct StackCodegen {
             return "JSObject.bridgeJSStackPop()"
         case .void, .namespaceEnum:
             return "()"
+        case .generic:
+            fatalError("Generic type parameters are not supported in exported declarations")
         }
     }
 
@@ -899,7 +928,7 @@ struct StackCodegen {
             return "\(raw: typeName)<\(raw: wrappedType.swiftType)>.bridgeJSStackPop()"
         case .jsObject(let className?):
             return "\(raw: typeName)<JSObject>.bridgeJSStackPop().map { \(raw: className)(unsafelyWrapping: $0) }"
-        case .nullable, .void, .namespaceEnum, .closure, .unsafePointer, .swiftProtocol:
+        case .nullable, .void, .namespaceEnum, .closure, .unsafePointer, .swiftProtocol, .generic:
             fatalError("Invalid nullable wrapped type: \(wrappedType)")
         }
     }
@@ -932,6 +961,8 @@ struct StackCodegen {
             return lowerArrayStatements(elementType: elementType, accessor: accessor, varPrefix: varPrefix)
         case .dictionary(let valueType):
             return lowerDictionaryStatements(valueType: valueType, accessor: accessor, varPrefix: varPrefix)
+        case .generic:
+            fatalError("Generic type parameters are not supported in exported declarations")
         }
     }
 
@@ -1242,6 +1273,11 @@ struct EnumCodegen {
 
 struct StructCodegen {
     private let stackCodegen = StackCodegen()
+    private let hasGenerics: Bool
+
+    init(hasGenerics: Bool = false) {
+        self.hasGenerics = hasGenerics
+    }
 
     func renderStructHelpers(_ structDef: ExportedStruct) -> [DeclSyntax] {
         let typeName = structDef.swiftCallName
@@ -1312,10 +1348,27 @@ struct StructCodegen {
             returnType: .i32
         )
 
-        return [
+        var decls: [DeclSyntax] = [
             bridgedStructExtension, "\(raw: lowerExternDeclPrinter.lines.joined(separator: "\n"))",
             "\(raw: liftExternDeclPrinter.lines.joined(separator: "\n"))",
         ]
+
+        if hasGenerics {
+            let genericConformancePrinter = CodeFragmentPrinter()
+            genericConformancePrinter.write("extension \(typeName): _BridgedSwiftGenericBridgeable {")
+            genericConformancePrinter.indent {
+                genericConformancePrinter.write(
+                    "@_spi(BridgeJS) public static var bridgeJSTypeName: StaticString { \"\(structDef.abiName)\" }"
+                )
+                genericConformancePrinter.write(
+                    "@_spi(BridgeJS) public static let bridgeJSTypeID: Int32 = _swift_js_resolve_type_id(\(typeName).bridgeJSTypeName)"
+                )
+            }
+            genericConformancePrinter.write("}")
+            decls.append("\(raw: genericConformancePrinter.lines.joined(separator: "\n"))")
+        }
+
+        return decls
     }
 
     private func generateStructLiftCode(structDef: ExportedStruct) -> [String] {
@@ -1593,6 +1646,7 @@ extension BridgeType {
             let effectsStr = (signature.isAsync ? " async" : "") + (signature.isThrows ? " throws" : "")
             let closureType = "(\(paramTypes))\(effectsStr) -> \(signature.returnType.swiftType)"
             return useJSTypedClosure ? "JSTypedClosure<\(closureType)>" : closureType
+        case .generic(let name): return name
         }
     }
 
@@ -1675,6 +1729,8 @@ extension BridgeType {
             return LiftingIntrinsicInfo(parameters: [("callbackId", .i32)])
         case .array, .dictionary:
             return LiftingIntrinsicInfo(parameters: [])
+        case .generic:
+            throw BridgeJSCoreError("Generic type parameters are not supported in exported declarations")
         }
     }
 
@@ -1726,6 +1782,8 @@ extension BridgeType {
             return .jsObject
         case .array, .dictionary:
             return .array
+        case .generic:
+            throw BridgeJSCoreError("Generic type parameters are not supported in exported declarations")
         }
     }
 }

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -143,6 +143,11 @@ public struct ImportTS {
         }
 
         func lowerParameter(param: Parameter) throws {
+            if case .generic = param.type {
+                stackLoweringStmts.insert("\(param.name).bridgeJSStackPush()", at: 0)
+                return
+            }
+
             let loweringInfo = try param.type.loweringParameterInfo(context: context)
 
             switch param.type {
@@ -241,6 +246,12 @@ public struct ImportTS {
             abiParameterForwardings.insert(contentsOf: ["resolveRef", "rejectRef"], at: 0)
         }
 
+        func appendTypeIDParameter(genericParameterName: String) {
+            let abiParamName = "\(genericParameterName.lowercased())TypeId"
+            abiParameterSignatures.append((abiParamName, .i32))
+            abiParameterForwardings.append("\(genericParameterName).bridgeJSTypeID")
+        }
+
         func call() throws {
             for stmt in stackLoweringStmts {
                 body.write(stmt.description)
@@ -298,6 +309,8 @@ public struct ImportTS {
             } else {
                 let liftExpr: String
                 switch returnType {
+                case .generic(let name):
+                    liftExpr = "\(name).bridgeJSStackPop()"
                 case .closure(let signature, _):
                     liftExpr = "_BJS_Closure_\(signature.mangleName).bridgeJSLift(ret)"
                 default:
@@ -363,7 +376,8 @@ public struct ImportTS {
             name: String,
             parameters: [Parameter],
             returnType: BridgeType,
-            effects: Effects
+            effects: Effects,
+            genericParameters: [String] = []
         ) -> DeclSyntax {
             let printer = CodeFragmentPrinter()
             let signature = SwiftSignatureBuilder.buildFunctionSignature(
@@ -372,7 +386,12 @@ public struct ImportTS {
                 effects: effects,
                 useWildcardLabels: true
             )
-            printer.write("func \(name.backtickIfNeeded())\(signature) {")
+            let genericClause =
+                genericParameters.isEmpty
+                ? ""
+                : "<" + genericParameters.map { "\($0): _BridgedSwiftGenericBridgeable" }.joined(separator: ", ")
+                    + ">"
+            printer.write("func \(name.backtickIfNeeded())\(genericClause)\(signature) {")
             printer.indent {
                 printer.write(lines: body.lines)
             }
@@ -432,6 +451,9 @@ public struct ImportTS {
         for param in function.parameters {
             try builder.lowerParameter(param: param)
         }
+        for genericParam in function.genericParameters {
+            builder.appendTypeIDParameter(genericParameterName: genericParam)
+        }
         try builder.call()
         try builder.liftReturnValue()
         topLevelDecls.append(builder.renderImportDecl())
@@ -440,7 +462,8 @@ public struct ImportTS {
                 name: Self.thunkName(function: function),
                 parameters: function.parameters,
                 returnType: function.returnType,
-                effects: function.effects
+                effects: function.effects,
+                genericParameters: function.genericParameters
             )
             .with(\.leadingTrivia, Self.renderDocumentation(documentation: function.documentation))
         ]
@@ -957,6 +980,8 @@ extension BridgeType {
             return LoweringParameterInfo(loweredParameters: params, useBorrowing: wrappedInfo.useBorrowing)
         case .array, .dictionary:
             return LoweringParameterInfo(loweredParameters: [])
+        case .generic:
+            return LoweringParameterInfo(loweredParameters: [])
         }
     }
 
@@ -1029,6 +1054,8 @@ extension BridgeType {
             return LiftingReturnInfo(valueToLift: wrappedInfo.valueToLift)
         case .array, .dictionary:
             return LiftingReturnInfo(valueToLift: nil)
+        case .generic:
+            return LiftingReturnInfo(valueToLift: nil)
         }
     }
 }