BridgeJS: Reuse existing validation for exported type names

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/SwiftToSkeleton.swift

@@ -1765,18 +1765,8 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
         return name
     }
 
-    private static let reservedTypeNames: Set<String> = [
-        "arguments", "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default",
-        "delete", "do", "else", "enum", "eval", "export", "extends", "false", "finally", "for", "function",
-        "if", "implements", "import", "in", "instanceof", "interface", "let", "new", "null", "package",
-        "private", "protected", "public", "return", "static", "super", "switch", "this", "throw", "true",
-        "try", "typeof", "var", "void", "while", "with", "yield",
-        "any", "bigint", "boolean", "never", "number", "object", "string", "symbol", "undefined", "unknown",
-    ]
-
     private func extractValidatedJSName(
-        from jsAttribute: AttributeSyntax,
-        isTypeName: Bool = false
+        from jsAttribute: AttributeSyntax
     ) -> String? {
         guard let jsName = extractJSName(from: jsAttribute) else { return nil }
         guard SwiftToSkeleton.isValidJSIdentifier(jsName) else {
@@ -1786,10 +1776,6 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             )
             return nil
         }
-        if isTypeName && Self.reservedTypeNames.contains(jsName) {
-            diagnose(node: jsAttribute, message: "`\(jsName)` cannot be used as an exported type name")
-            return nil
-        }
         return jsName
     }
 
@@ -2039,7 +2025,7 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             return .skipChildren
         }
 
-        let jsName = extractValidatedJSName(from: jsAttribute, isTypeName: true)
+        let jsName = extractValidatedJSName(from: jsAttribute)
 
         if let aliasTarget = parent.extractAliasTarget(from: jsAttribute) {
             recordAlias(node: node, jsAttribute: jsAttribute, aliasTarget: aliasTarget)
@@ -2196,7 +2182,7 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             return .skipChildren
         }
 
-        let jsName = extractValidatedJSName(from: jsAttribute, isTypeName: true)
+        let jsName = extractValidatedJSName(from: jsAttribute)
 
         if let aliasTarget = parent.extractAliasTarget(from: jsAttribute) {
             recordAlias(node: node, jsAttribute: jsAttribute, aliasTarget: aliasTarget)
@@ -2322,7 +2308,7 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             return .skipChildren
         }
 
-        let jsName = extractValidatedJSName(from: jsAttribute, isTypeName: true)
+        let jsName = extractValidatedJSName(from: jsAttribute)
 
         if let aliasTarget = parent.extractAliasTarget(from: jsAttribute), jsName != nil {
             recordAlias(node: node, jsAttribute: jsAttribute, aliasTarget: aliasTarget)
@@ -2393,7 +2379,7 @@ private final class ExportSwiftAPICollector: SyntaxAnyVisitor {
             return .skipChildren
         }
 
-        let jsName = extractValidatedJSName(from: jsAttribute, isTypeName: true)
+        let jsName = extractValidatedJSName(from: jsAttribute)
 
         if let aliasTarget = parent.extractAliasTarget(from: jsAttribute) {
             recordAlias(node: node, jsAttribute: jsAttribute, aliasTarget: aliasTarget)

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -1346,7 +1346,6 @@ public struct BridgeJSLink {
     }
 
     public func link(sharedMemory: Bool = false) throws -> (outputJs: String, outputDts: String) {
-        try validateRenamedTypeExports()
         intrinsicRegistry.reset()
         importedModuleRegistry.configure(skeletons: skeletons)
         intrinsicRegistry.classNamespaces = skeletons.reduce(into: [:]) { result, unified in
@@ -1374,198 +1373,6 @@ public struct BridgeJSLink {
         return (outputJs, outputDts)
     }
 
-    private func validateRenamedTypeExports() throws {
-        let exported = skeletons.compactMap(\.exported)
-        guard
-            exported.contains(where: { skeleton in
-                skeleton.classes.contains { $0.resolvedJSName != $0.name }
-                    || skeleton.structs.contains { $0.resolvedJSName != $0.name }
-                    || skeleton.enums.contains { $0.resolvedJSName != $0.name }
-                    || skeleton.protocols.contains { $0.resolvedJSName != $0.name }
-            })
-        else { return }
-
-        var renamedNamespaces: [[String]] = []
-        for skeleton in exported {
-            renamedNamespaces += skeleton.classes.filter { $0.resolvedJSName != $0.name }.map(\.tsPathComponents)
-            renamedNamespaces += skeleton.structs.filter { $0.resolvedJSName != $0.name }.map(\.tsPathComponents)
-            renamedNamespaces += skeleton.enums.filter { $0.resolvedJSName != $0.name }.map(\.tsPathComponents)
-        }
-        func isRenamed(_ type: any NamespacedExportedType) -> Bool {
-            type.resolvedJSName != type.name
-                || renamedNamespaces.contains { type.tsPathComponents.starts(with: $0) }
-        }
-
-        struct Symbol {
-            let owner: String
-            let renamed: Bool
-            let isNamespace: Bool
-            let canContainNamespace: Bool
-        }
-        var symbols: [[String]: [Symbol]] = [:]
-        let reservedBindingNames = JSGlueVariableScope.reservedVariables.union([
-            "exports", "js", "_exports", "bjs", "swiftHeapObjectFinalizationRegistry",
-            "Object", "Array", "Map", "WeakMap", "WeakRef", "FinalizationRegistry", "Promise", "Symbol",
-            "Math", "Number", "BigInt", "Error", "TypeError", "RangeError", "Uint8Array", "ArrayBuffer",
-            "DataView", "globalThis",
-        ])
-
-        func claim(
-            _ path: [String],
-            owner: String,
-            renamed: Bool,
-            isNamespace: Bool = false,
-            canContainNamespace: Bool = false
-        ) throws {
-            let symbol = Symbol(
-                owner: owner,
-                renamed: renamed,
-                isNamespace: isNamespace,
-                canContainNamespace: canContainNamespace
-            )
-            for existing in symbols[path] ?? [] {
-                guard existing.owner != owner, existing.renamed || renamed else { continue }
-                if existing.isNamespace && isNamespace { continue }
-                if existing.isNamespace && canContainNamespace && existing.owner.hasPrefix(owner + ".") { continue }
-                if isNamespace && existing.canContainNamespace && owner.hasPrefix(existing.owner + ".") { continue }
-                throw BridgeJSLinkError(
-                    message:
-                        "JavaScript export name '\(path.joined(separator: "."))' for '\(owner)' collides with '\(existing.owner)' after renaming a type"
-                )
-            }
-            symbols[path, default: []].append(symbol)
-        }
-
-        func claimNamespaces(_ path: [String], owner: String) throws {
-            for count in 1..<path.count {
-                try claim(Array(path.prefix(count)), owner: owner, renamed: false, isNamespace: true)
-            }
-        }
-
-        func claimMembers(
-            _ path: [String],
-            owner: String,
-            renamed: Bool,
-            methods: [ExportedFunction],
-            properties: [ExportedProperty]
-        ) throws {
-            for method in methods {
-                try claim(path + [method.resolvedJSName], owner: owner + "." + method.name, renamed: renamed)
-            }
-            for property in properties {
-                try claim(path + [property.resolvedJSName], owner: owner + "." + property.name, renamed: renamed)
-            }
-        }
-
-        for unified in skeletons {
-            guard let skeleton = unified.exported else { continue }
-            for klass in skeleton.classes {
-                let owner = unified.moduleName + "." + klass.swiftCallName
-                let renamed = isRenamed(klass)
-                if renamed && reservedBindingNames.contains(klass.resolvedJSName) {
-                    throw BridgeJSLinkError(
-                        message: "JavaScript class name '\(klass.resolvedJSName)' conflicts with a generated binding"
-                    )
-                }
-                try claimNamespaces(klass.tsPathComponents, owner: owner)
-                try claim(klass.tsPathComponents, owner: owner, renamed: renamed, canContainNamespace: true)
-                try claim([klass.resolvedJSName], owner: owner, renamed: renamed, canContainNamespace: true)
-                try claimMembers(
-                    klass.tsPathComponents,
-                    owner: owner,
-                    renamed: renamed,
-                    methods: klass.methods.filter(\.effects.isStatic),
-                    properties: klass.properties.filter(\.isStatic)
-                )
-                for name in ["__construct", "prototype"]
-                    + (shouldUseIdentityCache(for: klass) ? ["__identityCache"] : [])
-                {
-                    try claim(klass.tsPathComponents + [name], owner: owner + "." + name, renamed: false)
-                }
-            }
-            for structDef in skeleton.structs {
-                let owner = unified.moduleName + "." + structDef.swiftCallName
-                try claimNamespaces(structDef.tsPathComponents, owner: owner)
-                try claim(
-                    structDef.tsPathComponents,
-                    owner: owner,
-                    renamed: isRenamed(structDef),
-                    canContainNamespace: true
-                )
-                try claimMembers(
-                    structDef.tsPathComponents,
-                    owner: owner,
-                    renamed: isRenamed(structDef),
-                    methods: structDef.methods.filter(\.effects.isStatic),
-                    properties: structDef.properties.filter(\.isStatic)
-                )
-                if structDef.constructor != nil {
-                    try claim(structDef.tsPathComponents + ["init"], owner: owner + ".init", renamed: false)
-                }
-            }
-            for enumDef in skeleton.enums {
-                let owner = unified.moduleName + "." + enumDef.swiftCallName
-                let renamed = isRenamed(enumDef)
-                let namespace = enumDef.resolvedJSNamespace ?? []
-                try claimNamespaces(enumDef.tsPathComponents, owner: owner)
-                try claim(
-                    enumDef.tsPathComponents,
-                    owner: owner,
-                    renamed: renamed,
-                    isNamespace: enumDef.enumType == .namespace,
-                    canContainNamespace: true
-                )
-                if enumDef.enumType != .namespace {
-                    if renamed && reservedBindingNames.contains(enumDef.valuesName) {
-                        throw BridgeJSLinkError(
-                            message:
-                                "JavaScript enum binding '\(enumDef.valuesName)' conflicts with a generated binding"
-                        )
-                    }
-                    try claim([enumDef.valuesName], owner: owner, renamed: renamed)
-                    try claim(namespace + [enumDef.valuesName], owner: owner, renamed: renamed)
-                    if enumDef.emitStyle != .tsEnum {
-                        try claim(namespace + [enumDef.resolvedJSName + "Tag"], owner: owner, renamed: renamed)
-                        try claim([enumDef.objectTypeName], owner: owner, renamed: renamed)
-                    }
-                }
-                try claimMembers(
-                    enumDef.tsPathComponents,
-                    owner: owner,
-                    renamed: renamed,
-                    methods: enumDef.staticMethods,
-                    properties: enumDef.staticProperties
-                )
-            }
-            for proto in skeleton.protocols {
-                try claim(
-                    [proto.resolvedJSName],
-                    owner: unified.moduleName + "." + proto.name,
-                    renamed: proto.resolvedJSName != proto.name
-                )
-            }
-            for function in skeleton.functions {
-                let path = (function.namespace ?? []) + [function.resolvedJSName]
-                let owner = unified.moduleName + "." + function.abiName
-                try claimNamespaces(path, owner: owner)
-                try claim(path, owner: owner, renamed: false)
-            }
-        }
-        for unified in skeletons {
-            for imported in unified.imported?.children ?? [] {
-                for type in imported.types {
-                    try claim([type.name], owner: unified.moduleName + ".import." + type.name, renamed: false)
-                }
-            }
-        }
-        let reservedNames =
-            ["Exports", "Imports", "createInstantiator"]
-            + (exported.contains { !$0.classes.isEmpty } ? ["SwiftHeapObject"] : [])
-        for name in reservedNames {
-            try claim([name], owner: "BridgeJS.\(name)", renamed: false)
-        }
-    }
-
     private func collectTypeOwnerModules() -> [String: String] {
         var result: [String: String] = [:]
         func record(_ name: String, _ moduleName: String) {

Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift

@@ -43,7 +43,7 @@ final class JSGlueVariableScope {
 
     private let intrinsicRegistry: JSIntrinsicRegistry
 
-    static let reservedVariables: Set<String> = [
+    private var variables: Set<String> = [
         reservedSwift,
         reservedInstance,
         reservedMemory,
@@ -77,8 +77,6 @@ final class JSGlueVariableScope {
         reservedRegisterTypeHandles,
     ]
 
-    private var variables = JSGlueVariableScope.reservedVariables
-
     init(intrinsicRegistry: JSIntrinsicRegistry) {
         self.intrinsicRegistry = intrinsicRegistry
     }

Plugins/BridgeJS/Tests/BridgeJSToolTests/DiagnosticsTests.swift

@@ -752,15 +752,6 @@ import Testing
         #expect(diagnostics.description.contains("A separate name for JavaScript is not supported here"))
     }
 
-    @Test(arguments: ["class", "default", "await", "string", "number"])
-    func reservedExportedTypeNamesAreRejected(name: String) throws {
-        let source = """
-            @JS("\(name)") class Box { @JS init() {} }
-            """
-        let diagnostics = try #require(moduleDiagnostics(source: source))
-        #expect(diagnostics.description.contains("cannot be used as an exported type name"))
-    }
-
     @Test
     func jsNameOnProtocolRequirementDiagnostic() throws {
         let source = """