BridgeJS: Tests for same-named types across modules

- Link two skeletons that both export a `Point` struct and a `run`
  function with identical Swift names but different public JS names, and
  assert the generated glue keeps module-qualified struct hooks, helper
  keys, and thunk names distinct while the TS surface stays flat
  (snapshot: SameNamedTypesAcrossModules).
- Assert that two modules exporting the same public name (type or
  function) at the same namespace path fail to link with the new
  duplicate-export diagnostic.

Author: krodak

Plugins/BridgeJS/Tests/BridgeJSToolTests/BridgeJSLinkTests.swift

@@ -126,6 +126,127 @@ import Testing
         try snapshot(bridgeJSLink: bridgeJSLink, name: "MixedModules")
     }
 
+    private func buildSkeleton(
+        moduleName: String,
+        source: String,
+        inputFilePath: String = "input.swift"
+    ) throws -> BridgeJSSkeleton {
+        let swiftAPI = SwiftToSkeleton(
+            progress: .silent,
+            moduleName: moduleName,
+            exposeToGlobal: false,
+            externalModuleIndex: .empty
+        )
+        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: inputFilePath)
+        return try swiftAPI.finalize()
+    }
+
+    @Test
+    func sameNamedTypesAcrossModulesLinkWithDistinctABINames() throws {
+        // Both modules export a `Point` struct and a `run` function with identical Swift
+        // names but different public JS names (one is namespaced). The module-qualified
+        // ABI names must keep the generated glue (struct hooks, helper keys, and
+        // function thunk names) distinct, while the public JS/TS surface stays flat.
+        let moduleA = try buildSkeleton(
+            moduleName: "ModuleA",
+            source: """
+                @JS public struct Point {
+                    public let x: Double
+                    public let y: Double
+                    @JS public init(x: Double, y: Double) {
+                        self.x = x
+                        self.y = y
+                    }
+                }
+                @JS public enum Validation {
+                    case valid
+                    case invalid(reason: String)
+                }
+                @JS public func run(point: Point, validation: Validation) -> Point {
+                    point
+                }
+                """
+        )
+        let moduleB = try buildSkeleton(
+            moduleName: "ModuleB",
+            source: """
+                @JS(namespace: "Inner") public struct Point {
+                    public let x: Double
+                    public let y: Double
+                    @JS public init(x: Double, y: Double) {
+                        self.x = x
+                        self.y = y
+                    }
+                }
+                @JS(namespace: "Inner") public func run() {
+                }
+                """
+        )
+        let bridgeJSLink = BridgeJSLink(skeletons: [moduleA, moduleB], sharedMemory: false)
+
+        let (outputJs, outputDts) = try bridgeJSLink.link()
+
+        // Struct hooks and helper keys are module-qualified and distinct.
+        #expect(outputJs.contains("swift_js_struct_lower_ModuleA_Point"))
+        #expect(outputJs.contains("swift_js_struct_lower_ModuleB_Point"))
+        #expect(outputJs.contains("structHelpers.ModuleA_Point"))
+        #expect(outputJs.contains("structHelpers.ModuleB_Point"))
+        // Associated-value enum helper keys are module-qualified.
+        #expect(outputJs.contains("enumHelpers.ModuleA_Validation"))
+        // Exported function thunk names are module-qualified and distinct.
+        #expect(outputJs.contains("instance.exports.bjs_ModuleA_run"))
+        #expect(outputJs.contains("instance.exports.bjs_ModuleB_Inner_run"))
+        // The public TS surface stays flat (no module prefixes).
+        #expect(!outputDts.contains("ModuleA"))
+        #expect(!outputDts.contains("ModuleB"))
+
+        try snapshot(bridgeJSLink: bridgeJSLink, name: "SameNamedTypesAcrossModules")
+    }
+
+    @Test
+    func duplicatePublicNamesAcrossModulesProduceDiagnostic() throws {
+        let source = """
+            @JS public struct Point {
+                public let x: Double
+                @JS public init(x: Double) {
+                    self.x = x
+                }
+            }
+            """
+        let moduleA = try buildSkeleton(moduleName: "ModuleA", source: source)
+        let moduleB = try buildSkeleton(moduleName: "ModuleB", source: source)
+        let bridgeJSLink = BridgeJSLink(skeletons: [moduleA, moduleB], sharedMemory: false)
+
+        do {
+            _ = try bridgeJSLink.link()
+            Issue.record("Expected duplicate public export name diagnostic, but linking succeeded")
+        } catch let error as BridgeJSLinkError {
+            #expect(error.message.contains("Duplicate exported name 'Point'"))
+            #expect(error.message.contains("ModuleA"))
+            #expect(error.message.contains("ModuleB"))
+        }
+    }
+
+    @Test
+    func duplicatePublicFunctionNamesAcrossModulesProduceDiagnostic() throws {
+        let moduleA = try buildSkeleton(
+            moduleName: "ModuleA",
+            source: "@JS public func run() {}"
+        )
+        let moduleB = try buildSkeleton(
+            moduleName: "ModuleB",
+            source: "@JS public func run() {}"
+        )
+        let bridgeJSLink = BridgeJSLink(skeletons: [moduleA, moduleB], sharedMemory: false)
+
+        do {
+            _ = try bridgeJSLink.link()
+            Issue.record("Expected duplicate public export name diagnostic, but linking succeeded")
+        } catch let error as BridgeJSLinkError {
+            #expect(error.message.contains("Duplicate exported name 'run'"))
+        }
+    }
+
     @Test
     func perClassIdentityModeFromAnnotation() throws {
         let url = Self.inputsDirectory.appendingPathComponent("IdentityModeClass.swift")

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/SameNamedTypesAcrossModules.d.ts

@@ -0,0 +1,50 @@
+// NOTICE: This is auto-generated code by BridgeJS from JavaScriptKit,
+// DO NOT EDIT.
+//
+// To update this file, just rebuild your project or run
+// `swift package bridge-js`.
+
+export const ValidationValues: {
+    readonly Tag: {
+        readonly Valid: 0;
+        readonly Invalid: 1;
+    };
+};
+
+export type ValidationTag =
+  { tag: typeof ValidationValues.Tag.Valid } | { tag: typeof ValidationValues.Tag.Invalid; reason: string }
+
+export interface Point {
+    x: number;
+    y: number;
+}
+export type ValidationObject = typeof ValidationValues;
+
+export namespace Inner {
+    export interface Point {
+        x: number;
+        y: number;
+    }
+}
+export type Exports = {
+    run(point: Point, validation: ValidationTag): Point;
+    Validation: ValidationObject
+    Inner: {
+        run(): void;
+        Point: {
+            init(x: number, y: number): Point;
+        },
+    },
+    Point: {
+        init(x: number, y: number): Point;
+    },
+}
+export type Imports = {
+}
+export function createInstantiator(options: {
+    imports: Imports;
+}, swift: any): Promise<{
+    addImports: (importObject: WebAssembly.Imports) => void;
+    setInstance: (instance: WebAssembly.Instance) => void;
+    createExports: (instance: WebAssembly.Instance) => Exports;
+}>;