BridgeJS: Recognize cross-module extension conformances to @js protocols

A module may declare that a @js type exported by one of its dependencies
conforms to a @js protocol it defines:

    // ModuleB, depending on ModuleA
    @js protocol GraphNode { var id: String { get } }
    extension Building: GraphNode {}    // Building is ModuleA's @js struct
    @js public func store<T: BridgedSwiftGenericBridgeable & GraphNode>(_ n: T) -> T { n }

The Swift compiler sees the retroactive conformance directly, so the
generic thunk already accepted ModuleA's type - but the JS-side token
check did not: the conformance was declared in ModuleB's sources while
the token belongs to ModuleA, and neither skeleton recorded it, so a
valid call threw a spurious TypeError.

Extension conformances whose target does not resolve in-module are now
resolved against the external module index and recorded in the skeleton
(externalJSProtocolConformances, keyed by the conformer's Swift dot
path, e.g. `Models.Site`). The link layer sees every module's skeleton,
maps that dot path to the defining module's token (`Models_Site`),
merges the record into that token's entry, and the refinement closure
applies on top.

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/SwiftToSkeleton.swift

@@ -428,16 +428,25 @@ public final class SwiftToSkeleton {
     /// style, and the JS-side generic constraint check
     /// (`__bjs_tokenConformances`) must not reject a type that genuinely
     /// conforms.
+    ///
+    /// An extension may also target a `@JS` type exported by a *dependency*
+    /// module. The Swift compiler sees that retroactive conformance directly,
+    /// so the generic thunk accepts the type; those conformances are recorded
+    /// in `externalJSProtocolConformances` (keyed by the type's Swift dot
+    /// path) for the link layer to merge into the defining module's token
+    /// entry.
     private func mergeExtensionDeclaredJSProtocolConformances(into exported: inout ExportedSkeleton) {
-        var protocolsByTarget: [String: [String]] = [:]
+        var targets: [(name: String, type: TypeSyntax, protocols: [String])] = []
         for (sourceFile, _) in sourceFiles {
             let collector = ExtensionConformanceCollector(parent: self)
             collector.walk(sourceFile)
-            for (target, protocols) in collector.protocolsByTarget {
-                protocolsByTarget[target, default: []].append(contentsOf: protocols)
-            }
+            targets.append(contentsOf: collector.targets)
+        }
+        guard !targets.isEmpty else { return }
+        var protocolsByTarget: [String: [String]] = [:]
+        for target in targets {
+            protocolsByTarget[target.name, default: []].append(contentsOf: target.protocols)
         }
-        guard !protocolsByTarget.isEmpty else { return }
 
         func merge(_ existing: inout [String]?, additions: [String]) {
             var result = existing ?? []
@@ -447,21 +456,54 @@ public final class SwiftToSkeleton {
             existing = result.isEmpty ? nil : result
         }
 
+        var matchedTargets: Set<String> = []
         for index in exported.structs.indices {
             if let additions = protocolsByTarget[exported.structs[index].swiftCallName] {
                 merge(&exported.structs[index].conformedJSProtocols, additions: additions)
+                matchedTargets.insert(exported.structs[index].swiftCallName)
             }
         }
         for index in exported.classes.indices {
             if let additions = protocolsByTarget[exported.classes[index].swiftCallName] {
                 merge(&exported.classes[index].conformedJSProtocols, additions: additions)
+                matchedTargets.insert(exported.classes[index].swiftCallName)
             }
         }
         for index in exported.enums.indices {
             if let additions = protocolsByTarget[exported.enums[index].swiftCallName] {
                 merge(&exported.enums[index].conformedJSProtocols, additions: additions)
+                matchedTargets.insert(exported.enums[index].swiftCallName)
+            }
+        }
+
+        // Whatever did not match an in-module type may be a bridged type from a
+        // dependency module; record the conformance under the dependency type's
+        // Swift dot path for the link layer to resolve to its token.
+        var externalConformances: [String: [String]] = [:]
+        for target in targets where !matchedTargets.contains(target.name) {
+            var scratchErrors: [DiagnosticError] = []
+            guard let externalType = resolveExternal(for: target.type, errors: &scratchErrors) else { continue }
+            // Key by the dependency type's Swift dot path (its `swiftCallName`);
+            // the link layer resolves that to the type's token, which for a
+            // namespaced type (`Models.Building` -> `Models_Building`) is not
+            // the last name component.
+            let externalName: String?
+            switch externalType {
+            case .swiftStruct(let name), .swiftHeapObject(let name),
+                .caseEnum(let name), .rawValueEnum(let name, _), .associatedValueEnum(let name):
+                externalName = name
+            default:
+                externalName = nil
+            }
+            guard let externalName else { continue }
+            for protocolName in target.protocols
+            where !(externalConformances[externalName] ?? []).contains(protocolName) {
+                externalConformances[externalName, default: []].append(protocolName)
             }
         }
+        if !externalConformances.isEmpty {
+            exported.externalJSProtocolConformances = externalConformances
+        }
     }
 
     private static let jsTypedArrayTypealiasNames: [String: String] = [
@@ -4137,7 +4179,7 @@ extension GenericArgumentListSyntax {
 /// matches the skeleton's `swiftCallName` for both top-level and nested types.
 private final class ExtensionConformanceCollector: SyntaxVisitor {
     private let parent: SwiftToSkeleton
-    var protocolsByTarget: [String: [String]] = [:]
+    var targets: [(name: String, type: TypeSyntax, protocols: [String])] = []
 
     init(parent: SwiftToSkeleton) {
         self.parent = parent
@@ -4146,12 +4188,17 @@ private final class ExtensionConformanceCollector: SyntaxVisitor {
 
     override func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
         guard let inheritanceClause = node.inheritanceClause else { return .visitChildren }
-        let target = node.extendedType.trimmedDescription
+        var protocols: [String] = []
         for inherited in inheritanceClause.inheritedTypes {
             if let name = parent.resolveJSProtocolConstraint(for: inherited.type) {
-                protocolsByTarget[target, default: []].append(name)
+                protocols.append(name)
             }
         }
+        if !protocols.isEmpty {
+            targets.append(
+                (name: node.extendedType.trimmedDescription, type: node.extendedType, protocols: protocols)
+            )
+        }
         return .visitChildren
     }
 }

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -517,12 +517,32 @@ public struct BridgeJSLink {
     /// Swift, so the JS-side check must agree.
     private func generateTokenConformancesDeclaration() -> String {
         var inheritedByProtocol: [String: [String]] = [:]
+        // Every bridgeable type's token, keyed by its Swift dot path: external
+        // conformance records name the type by dot path (the only spelling the
+        // declaring module knows), and only the defining module's skeleton can
+        // turn that into the token (`Models.Building` -> `Models_Building`).
+        var tokenBySwiftCallName: [String: String] = [:]
+        for unified in skeletons {
+            guard let exported = unified.exported else { continue }
+            for structDef in exported.structs { tokenBySwiftCallName[structDef.swiftCallName] = structDef.abiName }
+            for klass in exported.classes { tokenBySwiftCallName[klass.swiftCallName] = klass.abiName }
+            for enumDef in exported.enums { tokenBySwiftCallName[enumDef.swiftCallName] = enumDef.abiName }
+        }
+        // Conformances a module declares through extensions on another
+        // module's @JS types, keyed by the conformer's token.
+        var externalByToken: [String: [String]] = [:]
         for unified in skeletons {
             for protocolDef in unified.exported?.protocols ?? [] {
                 if let inherited = protocolDef.inheritedJSProtocols, !inherited.isEmpty {
                     inheritedByProtocol[protocolDef.name] = inherited
                 }
             }
+            for (swiftCallName, protocols) in unified.exported?.externalJSProtocolConformances ?? [:] {
+                guard let token = tokenBySwiftCallName[swiftCallName] else { continue }
+                for protocolName in protocols where !(externalByToken[token] ?? []).contains(protocolName) {
+                    externalByToken[token, default: []].append(protocolName)
+                }
+            }
         }
         func transitiveClosure(of protocols: [String]) -> [String] {
             var seen: [String] = []
@@ -536,8 +556,12 @@ public struct BridgeJSLink {
         }
         var entries: [String] = []
         func append(token: String, protocols: [String]?) {
-            guard let protocols, !protocols.isEmpty else { return }
-            let list = transitiveClosure(of: protocols).map { "\"\($0)\"" }.joined(separator: ", ")
+            var combined = protocols ?? []
+            for protocolName in externalByToken[token] ?? [] where !combined.contains(protocolName) {
+                combined.append(protocolName)
+            }
+            guard !combined.isEmpty else { return }
+            let list = transitiveClosure(of: combined).map { "\"\($0)\"" }.joined(separator: ", ")
             entries.append("\"\(token)\": [\(list)]")
         }
         for unified in skeletons {

Plugins/BridgeJS/Sources/BridgeJSSkeleton/BridgeJSSkeleton.swift

@@ -1304,6 +1304,13 @@ public struct ExportedSkeleton: Codable {
     /// When `"none"` or `nil`, no identity tracking is performed.
     public var identityMode: String?
 
+    /// `@JS protocol` conformances this module declares through extensions on
+    /// `@JS` types exported by *other* modules, keyed by the conformer's Swift
+    /// dot path (`swiftCallName`, e.g. `Models.Building`). The Swift compiler
+    /// sees the retroactive conformance directly; this record lets the link
+    /// layer teach the JS-side token conformance check about it too.
+    public var externalJSProtocolConformances: [String: [String]]?
+
     public init(
         functions: [ExportedFunction],
         classes: [ExportedClass],

Plugins/BridgeJS/Tests/BridgeJSToolTests/GenericExportDiagnosticsTests.swift

@@ -166,6 +166,48 @@ import Testing
         }
     }
 
+    @Test
+    func crossModuleExtensionConformanceReachesTokenConformances() throws {
+        // A conformance declared in this module on a @JS type exported by a
+        // dependency is a real retroactive conformance in Swift, so the
+        // JS-side token check must accept the dependency type's token.
+        let moduleA = try makeSkeleton(
+            """
+            @JS public struct Building {
+                public var id: String
+                @JS public init(id: String) { self.id = id }
+            }
+            @JS(namespace: "Models") public struct Site {
+                public var id: String
+                @JS public init(id: String) { self.id = id }
+            }
+            """,
+            moduleName: "ModuleA"
+        )
+        let moduleB = try makeSkeleton(
+            """
+            @JS protocol GraphNode { var id: String { get } }
+            extension Building: GraphNode {}
+            // `Models` is a JS namespace, not a Swift scope: the Swift type is
+            // `Site`, but its token is the ABI name `Models_Site`.
+            extension Site: GraphNode {}
+            @JS public func store<T: BridgedSwiftGenericBridgeable & GraphNode>(_ n: T) -> T { n }
+            """,
+            moduleName: "ModuleB",
+            dependencies: [(moduleName: "ModuleA", skeleton: moduleA)]
+        )
+        var link = BridgeJSLink()
+        let encoder = JSONEncoder()
+        try link.addSkeletonFile(data: encoder.encode(moduleA))
+        try link.addSkeletonFile(data: encoder.encode(moduleB))
+        let js = try link.link().outputJs
+        #expect(
+            js.contains(
+                #"const __bjs_tokenConformances = { "Building": ["GraphNode"], "Models_Site": ["GraphNode"] };"#
+            )
+        )
+    }
+
     @Test
     func compositionConstraintIsParsed() throws {
         let skeleton = try makeSkeleton(

Sources/JavaScriptKit/Documentation.docc/Articles/BridgeJS/Exporting-Swift/Exporting-Swift-Function.md

@@ -297,6 +297,23 @@ export type Exports = {
 
 TypeScript checks the constraint at compile time, but `BridgeType` tokens are erased at runtime, so the generated JavaScript wrapper enforces it again when the call crosses the bridge: the token's type is validated against the required protocols and a non-conforming token throws a catchable `TypeError` *before* the call enters WebAssembly, e.g. `BridgeJS: type 'Int' does not conform to required protocol 'GraphNode'`. Because nothing has been lowered yet, the shared value stack stays balanced and later calls are unaffected. (The Swift entry thunk repeats the check with a conditional metatype cast as defense-in-depth, but through the generated wrapper that trap is unreachable.)
 
+Conformances count no matter how they are declared: on the type itself, in an extension in the same module, or in an extension on a `@JS` type exported by a dependency module (a retroactive conformance). Protocol refinement is honored too — a conformer of `@JS protocol Refined: Base` satisfies a constraint on `Base`, exactly as it does in Swift (see <doc:Exporting-Swift-Protocols>):
+
+```swift
+@JS protocol Site: GraphNode {          // Site refines GraphNode
+    var region: String { get }
+}
+
+@JS struct Campus: Site {               // conforms to Site, and therefore GraphNode
+    var id: String
+    var region: String
+}
+```
+
+```javascript
+exports.store({ id: "campus-1", region: "north" }, BridgeTypes.Campus); // satisfies T: GraphNode
+```
+
 Generics also work on methods. On a `@JS` class or struct they apply to both instance and static methods. A `@JS enum` (including a namespace-style enum) has no instance methods in BridgeJS, so generics there apply to static methods only. The constraint, the trailing `BridgeType` token, and the generic-or-`Void` return rule all carry over unchanged.
 
 ## Supported Features