BridgeJS: Array import

Author: krodak

Plugins/BridgeJS/Sources/BridgeJSCore/ImportTS.swift

@@ -83,6 +83,7 @@ public struct ImportTS {
         var abiReturnType: WasmCoreType?
         // Track destructured variable names for multiple lowered parameters
         var destructuredVarNames: [String] = []
+        var stackLoweringStmts: [CodeBlockItemSyntax] = []
 
         init(moduleName: String, abiName: String, context: BridgeContext = .importTS) {
             self.moduleName = moduleName
@@ -93,11 +94,6 @@ public struct ImportTS {
         func lowerParameter(param: Parameter) throws {
             let loweringInfo = try param.type.loweringParameterInfo(context: context)
 
-            // Generate destructured variable names for all lowered parameters
-            let destructuredNames = loweringInfo.loweredParameters.map {
-                "\(param.name)\($0.name.capitalizedFirstLetter)"
-            }
-
             let initializerExpr: ExprSyntax
             switch param.type {
             case .closure(let signature):
@@ -108,6 +104,33 @@ public struct ImportTS {
                 initializerExpr = ExprSyntax("\(raw: param.name).bridgeJSLowerParameter()")
             }
 
+            if loweringInfo.loweredParameters.isEmpty {
+                let stmt = CodeBlockItemSyntax(
+                    item: .decl(
+                        DeclSyntax(
+                            VariableDeclSyntax(
+                                bindingSpecifier: .keyword(.let),
+                                bindings: PatternBindingListSyntax {
+                                    PatternBindingSyntax(
+                                        pattern: PatternSyntax(
+                                            IdentifierPatternSyntax(identifier: .wildcardToken())
+                                        ),
+                                        initializer: InitializerClauseSyntax(value: initializerExpr)
+                                    )
+                                }
+                            )
+                        )
+                    )
+                )
+                stackLoweringStmts.insert(stmt, at: 0)
+                return
+            }
+
+            // Generate destructured variable names for all lowered parameters
+            let destructuredNames = loweringInfo.loweredParameters.map {
+                "\(param.name)\($0.name.capitalizedFirstLetter)"
+            }
+
             // Always add destructuring statement to body (unified for single and multiple)
             let pattern: PatternSyntax
             if destructuredNames.count == 1 {
@@ -166,7 +189,9 @@ public struct ImportTS {
         }
 
         func call(returnType: BridgeType) throws {
-            // Build function call expression
+            let liftingInfo = try returnType.liftingReturnInfo(context: context)
+            body.append(contentsOf: stackLoweringStmts)
+
             let callExpr = FunctionCallExprSyntax(
                 calledExpression: ExprSyntax("\(raw: abiName)"),
                 leftParen: .leftParenToken(),
@@ -183,6 +208,8 @@ public struct ImportTS {
             } else if returnType.usesSideChannelForOptionalReturn() {
                 // Side channel returns don't need "let ret ="
                 body.append(CodeBlockItemSyntax(item: .stmt(StmtSyntax(ExpressionStmtSyntax(expression: callExpr)))))
+            } else if liftingInfo.valueToLift == nil {
+                body.append(CodeBlockItemSyntax(item: .stmt(StmtSyntax(ExpressionStmtSyntax(expression: callExpr)))))
             } else {
                 body.append("let ret = \(raw: callExpr)")
             }
@@ -922,13 +949,8 @@ extension BridgeType {
                 return LoweringParameterInfo(loweredParameters: [("value", .i32)])
             }
         case .rawValueEnum(_, let rawType):
-            switch context {
-            case .importTS:
-                return LoweringParameterInfo(loweredParameters: [("value", rawType.wasmCoreType ?? .i32)])
-            case .exportSwift:
-                // For protocol export we return .i32 for String raw value type instead of nil
-                return LoweringParameterInfo(loweredParameters: [("value", rawType.wasmCoreType ?? .i32)])
-            }
+            let wasmType = rawType.wasmCoreType ?? .i32
+            return LoweringParameterInfo(loweredParameters: [("value", wasmType)])
         case .associatedValueEnum:
             switch context {
             case .importTS:
@@ -952,12 +974,7 @@ extension BridgeType {
             params.append(contentsOf: wrappedInfo.loweredParameters)
             return LoweringParameterInfo(loweredParameters: params)
         case .array:
-            switch context {
-            case .importTS:
-                throw BridgeJSCoreError("Array types are not yet supported in TypeScript imports")
-            case .exportSwift:
-                return LoweringParameterInfo(loweredParameters: [])
-            }
+            return LoweringParameterInfo(loweredParameters: [])
         }
     }
 
@@ -1011,13 +1028,8 @@ extension BridgeType {
                 return LiftingReturnInfo(valueToLift: .i32)
             }
         case .rawValueEnum(_, let rawType):
-            switch context {
-            case .importTS:
-                return LiftingReturnInfo(valueToLift: rawType.wasmCoreType ?? .i32)
-            case .exportSwift:
-                // For protocol export we return .i32 for String raw value type instead of nil
-                return LiftingReturnInfo(valueToLift: rawType.wasmCoreType ?? .i32)
-            }
+            let wasmType = rawType.wasmCoreType ?? .i32
+            return LiftingReturnInfo(valueToLift: wasmType)
         case .associatedValueEnum:
             switch context {
             case .importTS:
@@ -1039,12 +1051,7 @@ extension BridgeType {
             let wrappedInfo = try wrappedType.liftingReturnInfo(context: context)
             return LiftingReturnInfo(valueToLift: wrappedInfo.valueToLift)
         case .array:
-            switch context {
-            case .importTS:
-                throw BridgeJSCoreError("Array types are not yet supported in TypeScript imports")
-            case .exportSwift:
-                return LiftingReturnInfo(valueToLift: nil)
-            }
+            return LiftingReturnInfo(valueToLift: nil)
         }
     }
 }

Plugins/BridgeJS/Sources/BridgeJSLink/BridgeJSLink.swift

@@ -2147,12 +2147,10 @@ extension BridgeJSLink {
 
         func liftParameter(param: Parameter) throws {
             let liftingFragment = try IntrinsicJSFragment.liftParameter(type: param.type, context: context)
-            assert(
-                liftingFragment.parameters.count >= 1,
-                "Lifting fragment should have at least one parameter to lift"
-            )
             let valuesToLift: [String]
-            if liftingFragment.parameters.count == 1 {
+            if liftingFragment.parameters.count == 0 {
+                valuesToLift = []
+            } else if liftingFragment.parameters.count == 1 {
                 parameterNames.append(param.name)
                 valuesToLift = [scope.variable(param.name)]
             } else {

Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift

@@ -1565,14 +1565,7 @@ struct IntrinsicJSFragment: Sendable {
                     "Namespace enums are not supported to be passed as parameters to imported JS functions: \(string)"
             )
         case .array(let elementType):
-            switch context {
-            case .importTS:
-                throw BridgeJSLinkError(
-                    message: "Arrays are not yet supported to be passed as parameters to imported JS functions"
-                )
-            case .exportSwift:
-                return try arrayLift(elementType: elementType)
-            }
+            return try arrayLift(elementType: elementType)
         }
     }
 
@@ -1640,14 +1633,7 @@ struct IntrinsicJSFragment: Sendable {
                 message: "Namespace enums are not supported to be returned from imported JS functions: \(string)"
             )
         case .array(let elementType):
-            switch context {
-            case .importTS:
-                throw BridgeJSLinkError(
-                    message: "Arrays are not yet supported to be returned from imported JS functions"
-                )
-            case .exportSwift:
-                return try arrayLower(elementType: elementType)
-            }
+            return try arrayLower(elementType: elementType)
         }
     }
 
@@ -2756,11 +2742,10 @@ struct IntrinsicJSFragment: Sendable {
                     // Lift return value if needed
                     if method.returnType != .void {
                         let liftFragment = try! IntrinsicJSFragment.liftReturn(type: method.returnType)
-                        if !liftFragment.parameters.isEmpty {
-                            let lifted = liftFragment.printCode(["ret"], methodScope, printer, methodCleanup)
-                            if let liftedValue = lifted.first {
-                                printer.write("return \(liftedValue);")
-                            }
+                        let liftArgs = liftFragment.parameters.isEmpty ? [] : ["ret"]
+                        let lifted = liftFragment.printCode(liftArgs, methodScope, printer, methodCleanup)
+                        if let liftedValue = lifted.first {
+                            printer.write("return \(liftedValue);")
                         }
                     }
                 }
@@ -3090,7 +3075,6 @@ struct IntrinsicJSFragment: Sendable {
                             printer.write("\(JSGlueVariableScope.reservedTmpParamInts).push(\(isSomeVar) ? 1 : 0);")
                             cleanup.write("if (\(enumCleanupVar)) { \(enumCleanupVar)(); }")
                         default:
-                            // For other types (nested structs, etc.), original logic applies
                             let wrappedFragment = structFieldLowerFragment(
                                 field: ExportedProperty(
                                     name: field.name,
@@ -3100,9 +3084,36 @@ struct IntrinsicJSFragment: Sendable {
                                 ),
                                 allStructs: allStructs
                             )
+                            let guardedPrinter = CodeFragmentPrinter()
+                            let guardedCleanup = CodeFragmentPrinter()
+                            _ = wrappedFragment.printCode([value], scope, guardedPrinter, guardedCleanup)
+                            var loweredLines = guardedPrinter.lines
+                            var hoistedCleanupVar: String?
+                            if let first = loweredLines.first {
+                                let trimmed = first.trimmingCharacters(in: .whitespaces)
+                                if trimmed.hasPrefix("const "),
+                                    let namePart = trimmed.split(separator: " ").dropFirst().first,
+                                    trimmed.contains("= []")
+                                {
+                                    hoistedCleanupVar = String(namePart)
+                                    loweredLines[0] = "\(hoistedCleanupVar!) = [];"
+                                }
+                            }
+                            if let hoistedName = hoistedCleanupVar {
+                                printer.write("let \(hoistedName);")
+                            }
                             printer.write("if (\(isSomeVar)) {")
                             printer.indent {
-                                _ = wrappedFragment.printCode([value], scope, printer, cleanup)
+                                for line in loweredLines {
+                                    printer.write(line)
+                                }
+                                if !guardedCleanup.lines.isEmpty {
+                                    cleanup.write("if (\(isSomeVar)) {")
+                                    cleanup.indent {
+                                        cleanup.write(contentsOf: guardedCleanup)
+                                    }
+                                    cleanup.write("}")
+                                }
                             }
                             printer.write("}")
                             printer.write("\(JSGlueVariableScope.reservedTmpParamInts).push(\(isSomeVar) ? 1 : 0);")

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

@@ -663,6 +663,15 @@ export class TypeProcessor {
      * @private
      */
     visitType(type, node) {
+        if (this.checker.isArrayType(type)) {
+            const typeArgs = this.checker.getTypeArguments(type);
+            if (typeArgs && typeArgs.length > 0) {
+                const elementType = this.visitType(typeArgs[0], node);
+                return `[${elementType}]`;
+            }
+            return "[JSObject]";
+        }
+
         // Treat A<B> and A<C> as the same type
         if (isTypeReference(type)) {
             type = type.target;
@@ -728,7 +737,7 @@ export class TypeProcessor {
                 return this.renderTypeIdentifier(typeName);
             }
 
-            if (this.checker.isArrayType(type) || this.checker.isTupleType(type) || type.getCallSignatures().length > 0) {
+            if (this.checker.isTupleType(type) || type.getCallSignatures().length > 0) {
                 return "JSObject";
             }
             // "a" | "b" -> string

Plugins/BridgeJS/Sources/TS2Swift/JavaScript/test/__snapshots__/ts2swift.test.js.snap

@@ -9,11 +9,17 @@ exports[`ts2swift > snapshots Swift output for ArrayParameter.d.ts > ArrayParame
 
 @_spi(Experimental) @_spi(BridgeJS) import JavaScriptKit
 
-@JSFunction func checkArray(_ a: JSObject) throws(JSException) -> Void
+@JSFunction func processNumbers(_ values: [Double]) throws(JSException) -> Void
 
-@JSFunction func checkArrayWithLength(_ a: JSObject, _ b: Double) throws(JSException) -> Void
+@JSFunction func getNumbers() throws(JSException) -> [Double]
 
-@JSFunction func checkArray(_ a: JSObject) throws(JSException) -> Void
+@JSFunction func transformNumbers(_ values: [Double]) throws(JSException) -> [Double]
+
+@JSFunction func processStrings(_ values: [String]) throws(JSException) -> [String]
+
+@JSFunction func processBooleans(_ values: [Bool]) throws(JSException) -> [Bool]
+
+@JSFunction func processArraySyntax(_ values: [Double]) throws(JSException) -> [Double]
 "
 `;
 

Plugins/BridgeJS/Sources/TS2Swift/JavaScript/test/fixtures/ArrayParameter.d.ts

@@ -1,3 +1,17 @@
-export function checkArray(a: number[]): void;
-export function checkArrayWithLength(a: number[], b: number): void;
-export function checkArray(a: Array<number>): void;
+// Array as parameter
+export function processNumbers(values: number[]): void;
+
+// Array as return value
+export function getNumbers(): number[];
+
+// Array as both parameter and return value
+export function transformNumbers(values: number[]): number[];
+
+// String arrays
+export function processStrings(values: string[]): string[];
+
+// Boolean arrays
+export function processBooleans(values: boolean[]): boolean[];
+
+// Using Array<T> syntax
+export function processArraySyntax(values: Array<number>): Array<number>;

Plugins/BridgeJS/Tests/BridgeJSToolTests/Inputs/MacroSwift/ArrayTypes.swift

@@ -61,3 +61,9 @@
 
 @JSFunction func checkArray(_ a: JSObject) throws(JSException) -> Void
 @JSFunction func checkArrayWithLength(_ a: JSObject, _ b: Double) throws(JSException) -> Void
+
+@JSFunction func importProcessNumbers(_ values: [Double]) throws(JSException) -> Void
+@JSFunction func importGetNumbers() throws(JSException) -> [Double]
+@JSFunction func importTransformNumbers(_ values: [Double]) throws(JSException) -> [Double]
+@JSFunction func importProcessStrings(_ values: [String]) throws(JSException) -> [String]
+@JSFunction func importProcessBooleans(_ values: [Bool]) throws(JSException) -> [Bool]