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 token). The
link layer sees every module's skeleton, merges those records into the
defining module's token entry, and the refinement closure applies on
top. The conformance audit likewise treats an extension on a
dependency's @js class as bridgeable instead of flagging it.

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 external type's
+        // unqualified name (its token) for the link layer.
+        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

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