BridgeJS: Module-qualify JS helper identifiers minted from @js type names

The link step minted the struct/enum helper factories, the `const`s holding
them, and the keys of the shared `structHelpers` / `enumHelpers` tables from
the type name alone, so two modules declaring a same-named `@JS` type emitted
duplicate top-level `const`s in one glue scope (a load-time SyntaxError).

Qualify all of them with the declaring module, reusing the
`__bjs_codec_<Module>_<Type>` naming already used for the codec helpers:

    __bjs_createStructHelpers_<Module>_<AbiName>
    __bjs_createEnumHelpers_<Module>_<Name>
    __bjs_helpers_<Module>_<Name>
    structHelpers.<Module>_<AbiName> / enumHelpers.<Module>_<Name>

Declaration sites take the module from the skeleton being emitted; reference
sites, which only see a `BridgeType` (a bare type name), resolve it through
the existing `typeOwnerModules` map.

That map cannot disambiguate a name declared by two modules, and three things
downstream stay minted from the bare name regardless: the top-level
`const <Enum>Values` object, the `class <Name>` declaration, and the
`bjs["swift_js_struct_*_<AbiName>"]` wasm import names, which the Swift side
derives from the same name. Reject those inputs at link time with a message
naming both modules and the type, instead of emitting glue that throws at load
time or binds one module's values to the other module's helpers.

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -521,7 +521,9 @@ public struct BridgeJSLink {
 
     private func generateAddImports(needsImportsObject: Bool) throws -> CodeFragmentPrinter {
         let printer = CodeFragmentPrinter()
-        let allStructs = skeletons.compactMap { $0.exported?.structs }.flatMap { $0 }
+        let allStructs = skeletons.flatMap { unified in
+            (unified.exported?.structs ?? []).map { (moduleName: unified.moduleName, structDef: $0) }
+        }
         printer.write("return {")
         try printer.indent {
             printer.write(lines: [
@@ -669,19 +671,24 @@ public struct BridgeJSLink {
                 }
                 printer.write("}")
                 if !allStructs.isEmpty {
-                    for structDef in allStructs {
+                    for (moduleName, structDef) in allStructs {
+                        // The `bjs` import names are part of the wasm ABI and are
+                        // minted from the ABI name alone on both sides, so they
+                        // cannot be module-qualified here. `validateNoCrossModuleTypeNameCollisions`
+                        // rejects the inputs that would make them collide.
+                        let key = HelperNaming.qualified(base: structDef.abiName, module: moduleName)
                         printer.write("bjs[\"swift_js_struct_lower_\(structDef.abiName)\"] = function(objectId) {")
                         printer.indent {
                             printer.write(
-                                "\(JSGlueVariableScope.reservedStructHelpers).\(structDef.abiName).lower(\(JSGlueVariableScope.reservedSwift).memory.getObject(objectId));"
+                                "\(JSGlueVariableScope.reservedStructHelpers).\(key).lower(\(JSGlueVariableScope.reservedSwift).memory.getObject(objectId));"
                             )
                         }
                         printer.write("}")
 
                         printer.write("bjs[\"swift_js_struct_lift_\(structDef.abiName)\"] = function() {")
                         printer.indent {
                             printer.write(
-                                "const value = \(JSGlueVariableScope.reservedStructHelpers).\(structDef.abiName).lift();"
+                                "const value = \(JSGlueVariableScope.reservedStructHelpers).\(key).lift();"
                             )
                             printer.write("return \(JSGlueVariableScope.reservedSwift).memory.retain(value);")
                         }
@@ -1255,12 +1262,18 @@ public struct BridgeJSLink {
 
             let bodyPrinter = CodeFragmentPrinter()
             let allStructs = exportedSkeletons.flatMap { $0.structs }
-            for structDef in allStructs {
+            for (moduleName, structDef) in skeletons.flatMap({ unified in
+                (unified.exported?.structs ?? []).map { (unified.moduleName, $0) }
+            }) {
                 let structPrinter = CodeFragmentPrinter()
                 let structScope = JSGlueVariableScope(intrinsicRegistry: intrinsicRegistry)
-                let fragment = IntrinsicJSFragment.structHelper(structDefinition: structDef, allStructs: allStructs)
+                let fragment = IntrinsicJSFragment.structHelper(
+                    structDefinition: structDef,
+                    allStructs: allStructs,
+                    moduleName: moduleName
+                )
                 _ = try fragment.printCode(
-                    [structDef.abiName],
+                    [],
                     IntrinsicJSFragment.PrintCodeContext(
                         scope: structScope,
                         printer: structPrinter,
@@ -1271,13 +1284,16 @@ public struct BridgeJSLink {
                 bodyPrinter.write(lines: structPrinter.lines)
             }
 
-            let allAssocEnums = exportedSkeletons.flatMap {
-                $0.enums.filter { $0.enumType == .associatedValue }
-            }
-            for enumDef in allAssocEnums {
+            for (moduleName, enumDef) in skeletons.flatMap({ unified in
+                (unified.exported?.enums ?? []).filter { $0.enumType == .associatedValue }
+                    .map { (unified.moduleName, $0) }
+            }) {
                 let enumPrinter = CodeFragmentPrinter()
                 let enumScope = JSGlueVariableScope(intrinsicRegistry: intrinsicRegistry)
-                let fragment = IntrinsicJSFragment.associatedValueEnumHelperFactory(enumDefinition: enumDef)
+                let fragment = IntrinsicJSFragment.associatedValueEnumHelperFactory(
+                    enumDefinition: enumDef,
+                    moduleName: moduleName
+                )
                 _ = try fragment.printCode(
                     [enumDef.valuesName],
                     IntrinsicJSFragment.PrintCodeContext(
@@ -1402,6 +1418,7 @@ public struct BridgeJSLink {
     }
 
     public func link() throws -> (outputJs: String, outputDts: String) {
+        try validateNoCrossModuleTypeNameCollisions()
         intrinsicRegistry.reset()
         importedModuleRegistry.configure(skeletons: skeletons)
         intrinsicRegistry.classNamespaces = skeletons.reduce(into: [:]) { result, unified in
@@ -1419,6 +1436,74 @@ public struct BridgeJSLink {
         return (outputJs, outputDts)
     }
 
+    /// Rejects skeletons in which two modules declare an exported type under the
+    /// same name.
+    ///
+    /// Declaration-site identifiers are module-qualified, but three things
+    /// downstream of them are minted from the bare type name and cannot be:
+    ///
+    /// - `BridgeType` carries only a type name, so a reference to `Point` from
+    ///   module *B* cannot tell which module's `structHelpers` entry it means.
+    /// - The top-level `const <Enum>Values` object and the `class <Name>`
+    ///   declaration are part of the public JS surface, so both modules would
+    ///   emit the same `const` / `class` in one glue module.
+    /// - `bjs["swift_js_struct_lower_<AbiName>"]` is a wasm import name minted
+    ///   from the ABI name on the Swift side too, so both modules import the
+    ///   same one.
+    ///
+    /// Emitting glue anyway would either throw at load time or silently bind one
+    /// module's values to the other module's helpers, so this fails the link.
+    func validateNoCrossModuleTypeNameCollisions() throws {
+        /// The identifier minted for a declaration, and where it comes from.
+        struct Declaration {
+            let moduleName: String
+            let kind: String
+        }
+        var declarations: [String: [Declaration]] = [:]
+        func record(_ mintedName: String, kind: String, module: String) {
+            // Two declarations from the *same* module colliding is a separate,
+            // pre-existing issue (`@JS` types of the same name in different
+            // namespaces); this check is only about cross-module collisions.
+            guard !(declarations[mintedName] ?? []).contains(where: { $0.moduleName == module }) else { return }
+            declarations[mintedName, default: []].append(Declaration(moduleName: module, kind: kind))
+        }
+
+        for unified in skeletons {
+            guard let skeleton = unified.exported else { continue }
+            let module = unified.moduleName
+            for structDef in skeleton.structs {
+                record(structDef.abiName, kind: "struct", module: module)
+            }
+            for klass in skeleton.classes {
+                record(klass.name, kind: "class", module: module)
+            }
+            // Namespace enums declare no runtime value of their own; they only
+            // contribute to the merged namespace objects, which already merge
+            // across modules.
+            for enumDef in skeleton.enums where enumDef.enumType != .namespace {
+                record(enumDef.name, kind: "enum", module: module)
+            }
+        }
+
+        for (mintedName, declarations) in declarations.sorted(by: { $0.key < $1.key }) where declarations.count > 1 {
+            let modules = declarations.map(\.moduleName).sorted()
+            let kinds = Set(declarations.map(\.kind)).sorted().joined(separator: "/")
+            throw BridgeJSLinkError(
+                message: """
+                    Duplicate @JS \(kinds) '\(mintedName)' declared by modules \
+                    \(modules.map { "'\($0)'" }.joined(separator: " and ")).
+
+                    The generated JavaScript glue mints identifiers from the type name \
+                    (the helper tables, the top-level declarations, and the wasm import names \
+                    the Swift side derives from the same name), so the two declarations \
+                    would collide in a single glue module.
+
+                    Rename one of them so that each module declares a distinct name.
+                    """
+            )
+        }
+    }
+
     /// Maps every type name a `BridgeType` can carry to the module that declares
     /// it, so identifiers minted from type names can be module-qualified.
     ///
@@ -1463,12 +1548,13 @@ public struct BridgeJSLink {
     private func enumHelperAssignments() -> CodeFragmentPrinter {
         let printer = CodeFragmentPrinter()
 
-        for skeleton in skeletons.compactMap(\.exported) {
+        for unified in skeletons {
+            guard let skeleton = unified.exported else { continue }
             for enumDef in skeleton.enums where enumDef.enumType == .associatedValue {
-                printer.write(
-                    "const \(enumDef.name)Helpers = __bjs_create\(enumDef.valuesName)Helpers();"
-                )
-                printer.write("\(JSGlueVariableScope.reservedEnumHelpers).\(enumDef.name) = \(enumDef.name)Helpers;")
+                let key = HelperNaming.qualified(base: enumDef.name, module: unified.moduleName)
+                let local = HelperNaming.helperConstant(key)
+                printer.write("const \(local) = \(HelperNaming.enumHelperFactory(key))();")
+                printer.write("\(JSGlueVariableScope.reservedEnumHelpers).\(key) = \(local);")
                 printer.nextLine()
             }
         }
@@ -1479,14 +1565,13 @@ public struct BridgeJSLink {
     private func structHelperAssignments() -> CodeFragmentPrinter {
         let printer = CodeFragmentPrinter()
 
-        for skeleton in skeletons.compactMap(\.exported) {
+        for unified in skeletons {
+            guard let skeleton = unified.exported else { continue }
             for structDef in skeleton.structs {
-                printer.write(
-                    "const \(structDef.abiName)Helpers = __bjs_create\(structDef.abiName)Helpers();"
-                )
-                printer.write(
-                    "\(JSGlueVariableScope.reservedStructHelpers).\(structDef.abiName) = \(structDef.abiName)Helpers;"
-                )
+                let key = HelperNaming.qualified(base: structDef.abiName, module: unified.moduleName)
+                let local = HelperNaming.helperConstant(key)
+                printer.write("const \(local) = \(HelperNaming.structHelperFactory(key))();")
+                printer.write("\(JSGlueVariableScope.reservedStructHelpers).\(key) = \(local);")
                 printer.nextLine()
             }
         }
@@ -4278,8 +4363,10 @@ private struct DocCComment {
     }
 }
 
-struct BridgeJSLinkError: Error {
+struct BridgeJSLinkError: Error, CustomStringConvertible {
     let message: String
+
+    var description: String { message }
 }
 
 extension BridgeType {