BridgeJS: Skip importing TS declarations with invalid Swift identifiers

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -156,7 +156,7 @@ public struct ImportTS {
         func renderThunkDecl(name: String, parameters: [Parameter], returnType: BridgeType) -> DeclSyntax {
             return DeclSyntax(
                 FunctionDeclSyntax(
-                    name: .identifier(name),
+                    name: .identifier(name.backtickIfNeeded()),
                     signature: FunctionSignatureSyntax(
                         parameterClause: FunctionParameterClauseSyntax(parametersBuilder: {
                             for param in parameters {
@@ -315,7 +315,9 @@ public struct ImportTS {
                         bindingsBuilder: {
                             PatternBindingListSyntax {
                                 PatternBindingSyntax(
-                                    pattern: IdentifierPatternSyntax(identifier: .identifier(property.name)),
+                                    pattern: IdentifierPatternSyntax(
+                                        identifier: .identifier(property.name.backtickIfNeeded())
+                                    ),
                                     typeAnnotation: TypeAnnotationSyntax(
                                         type: IdentifierTypeSyntax(name: .identifier(property.type.swiftType))
                                     ),
@@ -466,3 +468,9 @@ extension BridgeType {
         }
     }
 }
+
+extension String {
+    func backtickIfNeeded() -> String {
+        return self.isValidSwiftIdentifier(for: .variableName) ? self : "`\(self)`"
+    }
+}

Plugins/BridgeJS/Sources/TS2Skeleton/JavaScript/src/processor.js

@@ -142,6 +142,10 @@ export class TypeProcessor {
      */
     visitFunctionLikeDecl(node) {
         if (!node.name) return null;
+        const name = node.name.getText();
+        if (!isValidSwiftDeclName(name)) {
+            return null;
+        }
 
         const signature = this.checker.getSignatureFromDeclaration(node);
         if (!signature) return null;
@@ -158,7 +162,7 @@ export class TypeProcessor {
         const documentation = this.getFullJSDocText(node);
 
         return {
-            name: node.name.getText(),
+            name,
             parameters,
             returnType: bridgeReturnType,
             documentation,
@@ -206,11 +210,17 @@ export class TypeProcessor {
      */
     visitPropertyDecl(node) {
         if (!node.name) return null;
+
+        const propertyName = node.name.getText();
+        if (!isValidSwiftDeclName(propertyName)) {
+            return null;
+        }
+
         const type = this.checker.getTypeAtLocation(node)
         const bridgeType = this.visitType(type, node);
         const isReadonly = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
         const documentation = this.getFullJSDocText(node);
-        return { name: node.name.getText(), type: bridgeType, isReadonly, documentation };
+        return { name: propertyName, type: bridgeType, isReadonly, documentation };
     }
 
     /**
@@ -225,7 +235,7 @@ export class TypeProcessor {
     }
 
     /**
-     * @param {ts.ClassDeclaration} node 
+     * @param {ts.ClassDeclaration} node
      * @returns {ImportTypeSkeleton | null}
      */
     visitClassDecl(node) {
@@ -442,4 +452,16 @@ function isTypeReference(type) {
         isObjectType(type) &&
         (type.objectFlags & ts.ObjectFlags.Reference) !== 0
     );
-}
+}
+
+/**
+ * Check if a declaration name is valid for Swift generation
+ * @param {string} name - Declaration name to check
+ * @returns {boolean} True if the name is valid for Swift
+ * @private
+ */
+export function isValidSwiftDeclName(name) {
+    // https://docs.swift.org/swift-book/documentation/the-swift-programming-language/lexicalstructure/
+    const swiftIdentifierRegex = /^[_\p{ID_Start}][\p{ID_Continue}\u{200C}\u{200D}]*$/u;
+    return swiftIdentifierRegex.test(name);
+}

Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/InvalidPropertyNames.d.ts

@@ -0,0 +1,23 @@
+interface ArrayBufferLike {
+    readonly byteLength: number;
+    readonly [Symbol.toStringTag]: string;
+    slice(begin: number, end: number): ArrayBufferLike;
+}
+
+interface WeirdNaming {
+    normalProperty: string;
+    "property-with-dashes": number;
+    "123invalidStart": boolean;
+    "property with spaces": string;
+    readonly [Symbol.species]: any;
+    [Symbol.asyncIterator](): AsyncIterator<any>;
+    "@specialChar": number;
+    "constructor": string; // This should be valid
+    for: string;
+    Any: string;
+    as(): void;
+    "try"(): void;
+}
+
+export function createArrayBuffer(): ArrayBufferLike;
+export function createWeirdObject(): WeirdNaming;

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/InvalidPropertyNames.Import.d.ts

@@ -0,0 +1,29 @@
+// 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 interface ArrayBufferLike {
+    slice(begin: number, end: number): ArrayBufferLike;
+    readonly byteLength: number;
+}
+export interface WeirdNaming {
+    as(): void;
+    normalProperty: string;
+    for: string;
+    Any: string;
+}
+export type Exports = {
+}
+export type Imports = {
+    createArrayBuffer(): ArrayBufferLike;
+    createWeirdObject(): WeirdNaming;
+}
+export function createInstantiator(options: {
+    imports: Imports;
+}, swift: any): Promise<{
+    addImports: (importObject: WebAssembly.Imports) => void;
+    setInstance: (instance: WebAssembly.Instance) => void;
+    createExports: (instance: WebAssembly.Instance) => Exports;
+}>;

Plugins/BridgeJS/Tests/BridgeJSToolTests/__Snapshots__/BridgeJSLinkTests/InvalidPropertyNames.Import.js

@@ -0,0 +1,168 @@
+// 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 async function createInstantiator(options, swift) {
+    let instance;
+    let memory;
+    let setException;
+    const textDecoder = new TextDecoder("utf-8");
+    const textEncoder = new TextEncoder("utf-8");
+
+    let tmpRetString;
+    let tmpRetBytes;
+    let tmpRetException;
+    return {
+        /**
+         * @param {WebAssembly.Imports} importObject
+         */
+        addImports: (importObject, importsContext) => {
+            const bjs = {};
+            importObject["bjs"] = bjs;
+            const imports = options.getImports(importsContext);
+            bjs["swift_js_return_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                tmpRetString = textDecoder.decode(bytes);
+            }
+            bjs["swift_js_init_memory"] = function(sourceId, bytesPtr) {
+                const source = swift.memory.getObject(sourceId);
+                const bytes = new Uint8Array(memory.buffer, bytesPtr);
+                bytes.set(source);
+            }
+            bjs["swift_js_make_js_string"] = function(ptr, len) {
+                const bytes = new Uint8Array(memory.buffer, ptr, len);
+                return swift.memory.retain(textDecoder.decode(bytes));
+            }
+            bjs["swift_js_init_memory_with_result"] = function(ptr, len) {
+                const target = new Uint8Array(memory.buffer, ptr, len);
+                target.set(tmpRetBytes);
+                tmpRetBytes = undefined;
+            }
+            bjs["swift_js_throw"] = function(id) {
+                tmpRetException = swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_retain"] = function(id) {
+                return swift.memory.retainByRef(id);
+            }
+            bjs["swift_js_release"] = function(id) {
+                swift.memory.release(id);
+            }
+
+            const TestModule = importObject["TestModule"] = importObject["TestModule"] || {};
+            TestModule["bjs_createArrayBuffer"] = function bjs_createArrayBuffer() {
+                try {
+                    let ret = imports.createArrayBuffer();
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_createWeirdObject"] = function bjs_createWeirdObject() {
+                try {
+                    let ret = imports.createWeirdObject();
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_ArrayBufferLike_byteLength_get"] = function bjs_ArrayBufferLike_byteLength_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).byteLength;
+                    return ret;
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_ArrayBufferLike_slice"] = function bjs_ArrayBufferLike_slice(self, begin, end) {
+                try {
+                    let ret = swift.memory.getObject(self).slice(begin, end);
+                    return swift.memory.retain(ret);
+                } catch (error) {
+                    setException(error);
+                    return 0
+                }
+            }
+            TestModule["bjs_WeirdNaming_normalProperty_get"] = function bjs_WeirdNaming_normalProperty_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).normalProperty;
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_normalProperty_set"] = function bjs_WeirdNaming_normalProperty_set(self, newValue) {
+                try {
+                    const newValueObject = swift.memory.getObject(newValue);
+                    swift.memory.release(newValue);
+                    swift.memory.getObject(self).normalProperty = newValueObject;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_for_get"] = function bjs_WeirdNaming_for_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).for;
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_for_set"] = function bjs_WeirdNaming_for_set(self, newValue) {
+                try {
+                    const newValueObject = swift.memory.getObject(newValue);
+                    swift.memory.release(newValue);
+                    swift.memory.getObject(self).for = newValueObject;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_Any_get"] = function bjs_WeirdNaming_Any_get(self) {
+                try {
+                    let ret = swift.memory.getObject(self).Any;
+                    tmpRetBytes = textEncoder.encode(ret);
+                    return tmpRetBytes.length;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_Any_set"] = function bjs_WeirdNaming_Any_set(self, newValue) {
+                try {
+                    const newValueObject = swift.memory.getObject(newValue);
+                    swift.memory.release(newValue);
+                    swift.memory.getObject(self).Any = newValueObject;
+                } catch (error) {
+                    setException(error);
+                }
+            }
+            TestModule["bjs_WeirdNaming_as"] = function bjs_WeirdNaming_as(self) {
+                try {
+                    swift.memory.getObject(self).as();
+                } catch (error) {
+                    setException(error);
+                }
+            }
+        },
+        setInstance: (i) => {
+            instance = i;
+            memory = instance.exports.memory;
+            setException = (error) => {
+                instance.exports._swift_js_exception.value = swift.memory.retain(error)
+            }
+        },
+        /** @param {WebAssembly.Instance} instance */
+        createExports: (instance) => {
+            const js = swift.memory.heap;
+
+            return {
+
+            };
+        },
+    }
+}