BridgeJS: Tests and fixtures for generic imports

Author: krodak

Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSCodegenTests.swift

@@ -40,6 +40,9 @@ import Testing
                 swiftParts.append(s)
             }
         }
+        if let typeRegistration = GenericTypeRegistrationCodegen().render(for: skeleton) {
+            swiftParts.append(typeRegistration)
+        }
         let combinedSwift =
             swiftParts
             .map { $0.trimmingCharacters(in: .newlines) }

Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift

@@ -126,6 +126,86 @@ import Testing
         try snapshot(bridgeJSLink: bridgeJSLink, name: "MixedModules")
     }
 
+    private func linkedJS(forFixture input: String) throws -> String {
+        let url = Self.inputsDirectory.appendingPathComponent(input)
+        let name = url.deletingPathExtension().lastPathComponent
+        let sourceFile = Parser.parse(source: try String(contentsOf: url, encoding: .utf8))
+        let importSwift = SwiftToSkeleton(
+            progress: .silent,
+            moduleName: "TestModule",
+            exposeToGlobal: false,
+            externalModuleIndex: .empty
+        )
+        importSwift.addSourceFile(sourceFile, inputFilePath: "\(name).swift")
+        let importResult = try importSwift.finalize()
+        var bridgeJSLink = BridgeJSLink(sharedMemory: false)
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let unifiedData = try encoder.encode(importResult)
+        try bridgeJSLink.addSkeletonFile(data: unifiedData)
+        return try bridgeJSLink.link().0
+    }
+
+    @Test
+    func genericRuntimeIsGatedToGenericBuilds() throws {
+        let genericJS = try linkedJS(forFixture: "GenericImports.swift")
+        #expect(genericJS.contains("__bjs_codecByTypeId"))
+        #expect(genericJS.contains("__bjs_primitiveCodecs"))
+        #expect(genericJS.contains("bjs[\"bjs_TestModule_register_type_handles\"] = function(base, count) {"))
+        #expect(genericJS.contains("instance.exports[\"bjs_TestModule_register_type_handles\"]();"))
+        // Eager registration hook: called by the instantiate.js template right
+        // after WASI initialization (the lazy guard remains as a fallback).
+        #expect(genericJS.contains("afterInitialize: () => {"))
+
+        // Modules with @JS types but no generic declarations still emit a Swift
+        // registration export (their types may be used by a dependent module's
+        // generic function), so the link layer must install a no-op hook for the
+        // wasm import — but the generic runtime itself must be omitted.
+        let nonGenericJS = try linkedJS(forFixture: "SwiftStructImports.swift")
+        #expect(!nonGenericJS.contains("__bjs_codecByTypeId"))
+        #expect(!nonGenericJS.contains("__bjs_primitiveCodecs"))
+        #expect(nonGenericJS.contains("bjs[\"bjs_TestModule_register_type_handles\"] = function() {};"))
+        #expect(!nonGenericJS.contains("instance.exports[\"bjs_TestModule_register_type_handles\"]();"))
+        // Without the generic runtime the hook is not emitted at all; the
+        // instantiate template calls it with optional chaining.
+        #expect(!nonGenericJS.contains("afterInitialize: () => {"))
+    }
+
+    @Test
+    func sameTypeNameAcrossModulesLinksWithHandleIdentity() throws {
+        // Type identity is pointer-based (each type owns a BridgeJSTypeHandle),
+        // so two modules defining a same-named @JS type must link fine: each
+        // module registers its own handle IDs against its own codec array.
+        func makeSkeleton(moduleName: String, source: String) throws -> BridgeJSSkeleton {
+            let swiftAPI = SwiftToSkeleton(
+                progress: .silent,
+                moduleName: moduleName,
+                exposeToGlobal: false,
+                externalModuleIndex: .empty
+            )
+            swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "\(moduleName).swift")
+            return try swiftAPI.finalize()
+        }
+        let structSource = """
+            @JS public struct Point {
+                public var x: Int
+                @JS public init(x: Int) { self.x = x }
+            }
+            """
+        let first = try makeSkeleton(
+            moduleName: "FirstModule",
+            source: structSource + """
+
+                @JSFunction func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T
+                """
+        )
+        let second = try makeSkeleton(moduleName: "SecondModule", source: structSource)
+        let bridgeJSLink = BridgeJSLink(skeletons: [first, second], sharedMemory: false)
+        let js = try bridgeJSLink.link().outputJs
+        #expect(js.contains("bjs[\"bjs_FirstModule_register_type_handles\"] = function(base, count) {"))
+        #expect(js.contains("bjs[\"bjs_SecondModule_register_type_handles\"] = function(base, count) {"))
+    }
+
     @Test
     func perClassIdentityModeFromAnnotation() throws {
         let url = Self.inputsDirectory.appendingPathComponent("IdentityModeClass.swift")

Plugins/BridgeJS/Tests/BridgeJSToolTests/CodegenTestSupport.swift

@@ -0,0 +1,51 @@
+import Foundation
+import SwiftParser
+import SwiftSyntax
+import Testing
+
+@testable import BridgeJSLink
+@testable import BridgeJSCore
+@testable import BridgeJSSkeleton
+
+func makeSkeleton(
+    _ source: String,
+    moduleName: String = "TestModule",
+    dependencies: [(moduleName: String, skeleton: BridgeJSSkeleton)] = []
+) throws -> BridgeJSSkeleton {
+    let swiftAPI = SwiftToSkeleton(
+        progress: .silent,
+        moduleName: moduleName,
+        exposeToGlobal: false,
+        externalModuleIndex: ExternalModuleIndex(dependencies: dependencies)
+    )
+    swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "\(moduleName).swift")
+    return try swiftAPI.finalize()
+}
+
+func expectDiagnostic(
+    source: String,
+    moduleName: String = "App",
+    contains message: String,
+    sourceLocation: Testing.SourceLocation = #_sourceLocation
+) {
+    do {
+        _ = try makeSkeleton(source, moduleName: moduleName)
+        Issue.record("Expected diagnostic but resolution succeeded", sourceLocation: sourceLocation)
+    } catch let error as BridgeJSCoreDiagnosticError {
+        let combined = error.diagnostics.map(\.diagnostic.message).joined(separator: "\n")
+        #expect(combined.contains(message), sourceLocation: sourceLocation)
+    } catch {
+        Issue.record("Unexpected error: \(error)", sourceLocation: sourceLocation)
+    }
+}
+
+func linkSource(_ source: String, moduleName: String = "TestModule") throws -> (js: String, dts: String) {
+    let skeleton = try makeSkeleton(source, moduleName: moduleName)
+    var bridgeJSLink = BridgeJSLink(sharedMemory: false)
+    let encoder = JSONEncoder()
+    encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+    let unifiedData = try encoder.encode(skeleton)
+    try bridgeJSLink.addSkeletonFile(data: unifiedData)
+    let result = try bridgeJSLink.link()
+    return (result.outputJs, result.outputDts)
+}

Plugins/BridgeJS/Tests/BridgeJSToolTests/GenericExportDiagnosticsTests.swift

@@ -0,0 +1,65 @@
+import Testing
+
+@testable import BridgeJSCore
+
+@Suite struct GenericExportDiagnosticsTests {
+
+    @Test
+    func genericExportedFunctionRejected() {
+        expectDiagnostic(
+            source: """
+                @JS public func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) -> T { value }
+                """,
+            contains: "Generic parameters on exported @JS functions are not supported yet"
+        )
+    }
+
+    @Test
+    func genericMethodOnExportedClassRejected() {
+        expectDiagnostic(
+            source: """
+                @JS final class Box {
+                    @JS init() {}
+                    @JS func wrap<T: BridgedSwiftGenericBridgeable>(_ value: T) -> T { value }
+                }
+                """,
+            contains: "Generic parameters on exported @JS functions are not supported yet"
+        )
+    }
+
+    @Test
+    func genericMethodOnExportedStructRejected() {
+        expectDiagnostic(
+            source: """
+                @JS struct Pair {
+                    @JS init() {}
+                    @JS func first<T: BridgedSwiftGenericBridgeable>(_ value: T) -> T { value }
+                }
+                """,
+            contains: "Generic parameters on exported @JS functions are not supported yet"
+        )
+    }
+
+    @Test
+    func genericStaticMethodOnExportedEnumRejected() {
+        expectDiagnostic(
+            source: """
+                @JS enum Factory {
+                    case primary
+                    @JS static func one<T: BridgedSwiftGenericBridgeable>(_ value: T) -> T { value }
+                }
+                """,
+            contains: "Generic parameters on exported @JS functions are not supported yet"
+        )
+    }
+
+    @Test
+    func unconstrainedGenericExportedFunctionRejected() {
+        expectDiagnostic(
+            source: """
+                @JS public func identity<T>(_ value: T) -> T { value }
+                """,
+            contains: "Generic parameters on exported @JS functions are not supported yet"
+        )
+    }
+}

Plugins/BridgeJS/Tests/BridgeJSToolTests/GenericImportDiagnosticsTests.swift

@@ -0,0 +1,146 @@
+import Foundation
+import SwiftParser
+import SwiftSyntax
+import Testing
+
+@testable import BridgeJSCore
+@testable import BridgeJSSkeleton
+
+@Suite struct GenericImportDiagnosticsTests {
+
+    @Test
+    func genericParameterRequiresBridgeableConstraint() {
+        expectDiagnostic(
+            source: """
+                @JSFunction func identity<T>(_ value: T) throws(JSException) -> T
+                """,
+            contains: "Generic parameter 'T' must be constrained to 'BridgedSwiftGenericBridgeable'"
+        )
+    }
+
+    @Test
+    func genericWhereClauseUnsupported() {
+        expectDiagnostic(
+            source: """
+                @JSFunction func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T where T: Sendable
+                """,
+            contains: "'where' clauses are not supported on @JSFunction"
+        )
+    }
+
+    @Test
+    func asyncGenericImportUnsupported() {
+        expectDiagnostic(
+            source: """
+                @JSFunction func identityAsync<T: BridgedSwiftGenericBridgeable>(_ value: T) async throws(JSException) -> T
+                """,
+            contains: "Generic @JSFunction declarations cannot be 'async' yet."
+        )
+    }
+
+    @Test
+    func genericImportedMethodIsParsed() throws {
+        let skeleton = try makeSkeleton(
+            """
+            @JSClass struct Box {
+                @JSFunction func member<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T
+            }
+            """,
+            moduleName: "App"
+        )
+        let imported = try #require(skeleton.imported)
+        let types = imported.children.flatMap { $0.types }
+        let box = try #require(types.first { $0.name == "Box" })
+        let method = try #require(box.methods.first { $0.name == "member" })
+        #expect(method.genericParameters == ["T"])
+    }
+
+    @Test(arguments: [
+        ("[[T]]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: [[T]]) throws(JSException)"),
+        ("[T?]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: [T?]) throws(JSException)"),
+        ("T??", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: T??) throws(JSException)"),
+        ("[Int: T]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: [Int: T]) throws(JSException)"),
+    ])
+    func unsupportedGenericWrapperFormsInParameter(label: String, source: String) {
+        expectDiagnostic(
+            source: source,
+            contains: "may only be used as a bare type"
+        )
+    }
+
+    @Test(arguments: [
+        ("[[T]]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: T) throws(JSException) -> [[T]]"),
+        ("[T?]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: T) throws(JSException) -> [T?]"),
+        ("T??", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: T) throws(JSException) -> T??"),
+        ("[Int: T]", "@JSFunction func f<T: BridgedSwiftGenericBridgeable>(_ v: T) throws(JSException) -> [Int: T]"),
+    ])
+    func unsupportedGenericWrapperFormsInReturn(label: String, source: String) {
+        expectDiagnostic(
+            source: source,
+            contains: "may only be used as a bare type"
+        )
+    }
+
+    @Test
+    func genericImportedMethodAsyncIsRejected() {
+        expectDiagnostic(
+            source: """
+                @JSClass struct Box {
+                    @JSFunction func member<T: BridgedSwiftGenericBridgeable>(_ value: T) async throws(JSException) -> T
+                }
+                """,
+            contains: "Generic @JSFunction declarations cannot be 'async' yet."
+        )
+    }
+
+    @Test
+    func genericImportedMethodUnconstrainedParamIsRejected() {
+        expectDiagnostic(
+            source: """
+                @JSClass struct Box {
+                    @JSFunction func member<T>(_ value: T) throws(JSException) -> T
+                }
+                """,
+            contains:
+                "Generic parameter 'T' must be constrained to 'BridgedSwiftGenericBridgeable' to be used with @JSFunction."
+        )
+    }
+
+    @Test
+    func genericImportedFunctionUnusedTypeParamIsRejected() {
+        expectDiagnostic(
+            source: """
+                @JSFunction func unused<T: BridgedSwiftGenericBridgeable>() throws(JSException) -> Int
+                """,
+            contains:
+                "The generic parameter 'T' must be used in a parameter or return type of a generic @JSFunction declaration."
+        )
+    }
+
+    @Test
+    func genericImportedMethodUnusedTypeParamIsRejected() {
+        expectDiagnostic(
+            source: """
+                @JSClass struct Box {
+                    @JSFunction func member<T: BridgedSwiftGenericBridgeable>() throws(JSException) -> Int
+                }
+                """,
+            contains:
+                "The generic parameter 'T' must be used in a parameter or return type of a generic @JSFunction declaration."
+        )
+    }
+
+    @Test
+    func genericImportedReturnOnlyTypeParamIsAllowed() throws {
+        let skeleton = try makeSkeleton(
+            """
+            @JSFunction func make<T: BridgedSwiftGenericBridgeable>() throws(JSException) -> T
+            """,
+            moduleName: "App"
+        )
+        let imported = try #require(skeleton.imported)
+        let functions = imported.children.flatMap { $0.functions }
+        let function = try #require(functions.first { $0.name == "make" })
+        #expect(function.genericParameters == ["T"])
+    }
+}

Plugins/BridgeJS/Tests/BridgeJSToolTests/GenericMethodOnlyModuleCodegenTests.swift

@@ -0,0 +1,20 @@
+import Testing
+
+@Suite struct GenericMethodOnlyModuleCodegenTests {
+    @Test
+    func importMethodOnlyEmitsJSRuntimeInfrastructure() throws {
+        // A module with generic imports but no exported @JS types still needs a
+        // populated codec table for the primitives, so it registers them itself.
+        let js = try linkSource(
+            """
+            @JSClass struct OnlyConsumer {
+                @JSFunction func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T
+            }
+            """
+        ).js
+        #expect(js.contains("const __bjs_codecByTypeId = new Map();"))
+        #expect(js.contains("function __bjs_codecForTypeId(typeId) {"))
+        #expect(js.contains("bjs[\"bjs_TestModule_register_type_handles\"] = function(base, count) {"))
+        #expect(js.contains("instance.exports[\"bjs_TestModule_register_type_handles\"]();"))
+    }
+}