BridgeJS: Tests and fixtures for generic imports

Author: krodak

Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSCodegenTests.swift

@@ -141,6 +141,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

@@ -139,6 +139,126 @@ 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. The
+        // shared codec runtime (combinators + primitive codecs) gates
+        // independently: it is emitted because the fixture bridges an optional
+        // struct through the container stack ABI.
+        let nonGenericJS = try linkedJS(forFixture: "SwiftStructImports.swift")
+        #expect(!nonGenericJS.contains("__bjs_codecByTypeId"))
+        #expect(nonGenericJS.contains("__bjs_optionalCodec(structHelpers.Point)"))
+        #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: () => {"))
+
+        // Builds that bridge no containers at all pay nothing for the shared
+        // codec runtime either.
+        let containerFreeJS = try linkedJS(forFixture: "PrimitiveParameters.swift")
+        #expect(!containerFreeJS.contains("__bjs_arrayCodec"))
+        #expect(!containerFreeJS.contains("__bjs_optionalCodec"))
+        #expect(!containerFreeJS.contains("__bjs_dictCodec"))
+        #expect(!containerFreeJS.contains("__bjs_primitiveCodecs"))
+        #expect(!containerFreeJS.contains("__bjs_stringCodec"))
+    }
+
+    @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.
+        let structSource = """
+            @JS public struct Point {
+                public var x: Int
+                @JS public init(x: Int) { self.x = x }
+            }
+            """
+        let first = try makeSkeleton(
+            structSource + """
+
+                @JSFunction func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T
+                """,
+            moduleName: "FirstModule"
+        )
+        let second = try makeSkeleton(structSource, moduleName: "SecondModule")
+        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 moduleWithoutGenericsStillRegistersItsTypeCodecs() throws {
+        // A module cannot know whether a dependent module will pass its types to
+        // a generic function, so a module with @JS types but no generic
+        // declaration of its own still registers a codec for each of them, and
+        // the linked glue drives every module's registration export. This is
+        // what lets a type defined in Core be the generic argument of a generic
+        // import declared in App.
+        let core = try makeSkeleton(
+            """
+            @JS public struct Vector3D {
+                public var x: Int
+                @JS public init(x: Int) { self.x = x }
+            }
+            """,
+            moduleName: "Core"
+        )
+        let app = try makeSkeleton(
+            """
+            @JSFunction func identity<T: BridgedSwiftGenericBridgeable>(_ value: T) throws(JSException) -> T
+            """,
+            moduleName: "App"
+        )
+
+        // Core declares nothing imported at all, yet still registers its types.
+        #expect(core.imported == nil)
+        let coreEntries = try #require(core.typeRegistrationEntries)
+        #expect(coreEntries.contains { $0.swiftName == "Vector3D" })
+
+        let js = try BridgeJSLink(skeletons: [core, app], sharedMemory: false).link().outputJs
+        #expect(js.contains("instance.exports[\"bjs_Core_register_type_handles\"]();"))
+        #expect(js.contains("instance.exports[\"bjs_App_register_type_handles\"]();"))
+        // `lower(v)` is unique to a codec literal in a registration array;
+        // `structHelpers.Vector3D` on its own is emitted for every @JS struct.
+        #expect(js.contains("structHelpers.Vector3D.lower(v);"))
+    }
+
     @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/GenericCodecExpressionTests.swift

@@ -0,0 +1,41 @@
+import Testing
+
+@testable import BridgeJSLink
+@testable import BridgeJSSkeleton
+
+/// The codec a generic call site instantiates for each supported wrapped form
+/// of a generic parameter (`T`, `[T]`, `T?`, `[String: T]`).
+@Suite struct GenericCodecExpressionTests {
+    @Test func bareGenericUsesTheElementCodecDirectly() {
+        #expect(GenericJSCodegen.genericCodecExpression(type: .generic("T"), codec: "c") == "c")
+    }
+
+    @Test func wrappedGenericsInstantiateTheSharedCombinators() {
+        #expect(
+            GenericJSCodegen.genericCodecExpression(type: .array(.generic("T")), codec: "c")
+                == "__bjs_arrayCodec(c)"
+        )
+        #expect(
+            GenericJSCodegen.genericCodecExpression(type: .dictionary(.generic("T")), codec: "c")
+                == "__bjs_dictCodec(c)"
+        )
+    }
+
+    /// The optional combinator carries the null-vs-undefined flavour in its
+    /// second argument, so the generic path must not drop `JSOptionalKind`.
+    @Test func optionalGenericPreservesTheOptionalKind() {
+        #expect(
+            GenericJSCodegen.genericCodecExpression(type: .nullable(.generic("T"), .null), codec: "c")
+                == "__bjs_optionalCodec(c)"
+        )
+        #expect(
+            GenericJSCodegen.genericCodecExpression(type: .nullable(.generic("T"), .undefined), codec: "c")
+                == "__bjs_optionalCodec(c, true)"
+        )
+    }
+
+    @Test func nonGenericTypesHaveNoGenericCodec() {
+        #expect(GenericJSCodegen.genericCodecExpression(type: .string, codec: "c") == nil)
+        #expect(GenericJSCodegen.genericCodecExpression(type: .array(.integer(.int)), codec: "c") == nil)
+    }
+}

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"
+        )
+    }
+}