- Added JSValue array support end-to-end: JS glue now lowers/lifts optional JSValue arrays, using tmp stacks and JSValue helpers, and Swift intrinsics gained Optional<[JSValue]> bridging (Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift, Sources/JavaScriptKit/BridgeJSIntrinsics.swift).

kateinoigakukun · kateinoigakukun · commit 3dba5dfe81e9 · 2026-02-05T10:27:11.000+09:00
- Expanded runtime coverage with JSValue array round-trips (including optionals) on both import and export paths plus JS prelude wiring and d.ts definitions (`Tests/BridgeJSRuntimeTests/ExportAPITests.swift`, `Tests/BridgeJSRuntimeTests/ImportAPITests.swift`, `Tests/BridgeJSRuntimeTests/bridge-js.d.ts`, `Tests/prelude.mjs`), and regenerated BridgeJS outputs (`Tests/BridgeJSRuntimeTests/Generated/*`, `Tests/BridgeJSGlobalTests/Generated/*`, plugin outputs).
- Runtime tests now include JSValue array cases and all suites pass with the prescribed SDK.

Tests: `make unittest SWIFT_SDK_ID=DEVELOPMENT-SNAPSHOT-2025-11-03-a-wasm32-unknown-wasip1`.
diff --git a/Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift b/Plugins/BridgeJS/Sources/BridgeJSLink/JSGlueGen.swift
@@ -1029,6 +1029,20 @@ struct IntrinsicJSFragment: Sendable {
                         printer.write("\(JSGlueVariableScope.reservedTmpRetF64s).push(\(payload2Var));")
                     }
                     printer.write("\(JSGlueVariableScope.reservedTmpRetInts).push(\(isSomeVar) ? 1 : 0);")
+                case .array(let elementType):
+                    printer.write("if (\(isSomeVar)) {")
+                    printer.indent {
+                        let arrayLowerFragment = try! arrayLower(elementType: elementType)
+                        let arrayCleanup = CodeFragmentPrinter()
+                        let _ = arrayLowerFragment.printCode([value], scope, printer, arrayCleanup)
+                        if !arrayCleanup.lines.isEmpty {
+                            for line in arrayCleanup.lines {
+                                printer.write(line)
+                            }
+                        }
+                    }
+                    printer.write("}")
+                    printer.write("\(JSGlueVariableScope.reservedTmpParamInts).push(\(isSomeVar) ? 1 : 0);")
                 case .rawValueEnum(_, let rawType):
                     switch rawType {
                     case .string:
diff --git a/Sources/JavaScriptKit/BridgeJSIntrinsics.swift b/Sources/JavaScriptKit/BridgeJSIntrinsics.swift
@@ -1394,6 +1394,50 @@ extension Optional where Wrapped == JSValue {
     }
 }
 
+extension Optional where Wrapped == [JSValue] {
+    // MARK: ExportSwift
+
+    @_spi(BridgeJS) @_transparent public consuming func bridgeJSLowerParameter() -> Int32 {
+        switch consume self {
+        case .none:
+            return 0
+        case .some(let array):
+            array.bridgeJSLowerReturn()
+            return 1
+        }
+    }
+
+    @_spi(BridgeJS) public static func bridgeJSLiftParameter(_ isSome: Int32) -> [JSValue]? {
+        if isSome == 0 {
+            return nil
+        }
+        return [JSValue].bridgeJSLiftParameter()
+    }
+
+    @_spi(BridgeJS) public static func bridgeJSLiftParameter() -> [JSValue]? {
+        let isSome = _swift_js_pop_i32()
+        return bridgeJSLiftParameter(isSome)
+    }
+
+    @_spi(BridgeJS) public static func bridgeJSLiftReturn() -> [JSValue]? {
+        let isSome = _swift_js_pop_i32()
+        if isSome == 0 {
+            return nil
+        }
+        return [JSValue].bridgeJSLiftReturn()
+    }
+
+    @_spi(BridgeJS) public consuming func bridgeJSLowerReturn() -> Void {
+        switch consume self {
+        case .none:
+            _swift_js_push_i32(0)
+        case .some(let array):
+            array.bridgeJSLowerReturn()
+            _swift_js_push_i32(1)
+        }
+    }
+}
+
 extension Optional where Wrapped: _BridgedSwiftProtocolWrapper {
     // MARK: ExportSwift
 
diff --git a/Tests/BridgeJSRuntimeTests/ExportAPITests.swift b/Tests/BridgeJSRuntimeTests/ExportAPITests.swift
@@ -60,6 +60,14 @@ func runJsWorks() -> Void
     return v
 }
 
+@JS func roundTripJSValueArray(v: [JSValue]) -> [JSValue] {
+    return v
+}
+
+@JS func roundTripOptionalJSValueArray(v: [JSValue]?) -> [JSValue]? {
+    return v
+}
+
 @JSClass struct Foo {
     @JSGetter var value: String
     @JSFunction init(_ value: String) throws(JSException)
diff --git a/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.Macros.swift b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.Macros.swift
@@ -20,6 +20,10 @@
 
 @JSFunction func jsRoundTripJSValue(_ v: JSValue) throws(JSException) -> JSValue
 
+@JSFunction func jsRoundTripJSValueArray(_ v: [JSValue]) throws(JSException) -> [JSValue]
+
+@JSFunction func jsRoundTripOptionalJSValueArray(_ v: Optional<[JSValue]>) throws(JSException) -> Optional<[JSValue]>
+
 @JSFunction func jsThrowOrVoid(_ shouldThrow: Bool) throws(JSException) -> Void
 
 @JSFunction func jsThrowOrNumber(_ shouldThrow: Bool) throws(JSException) -> Double
diff --git a/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.swift b/Tests/BridgeJSRuntimeTests/Generated/BridgeJS.swift
@@ -3832,6 +3832,37 @@ public func _bjs_roundTripOptionalJSValue(_ vIsSome: Int32, _ vKind: Int32, _ vP
     #endif
 }
 
+@_expose(wasm, "bjs_roundTripJSValueArray")
+@_cdecl("bjs_roundTripJSValueArray")
+public func _bjs_roundTripJSValueArray() -> Void {
+    #if arch(wasm32)
+    let ret = roundTripJSValueArray(v: [JSValue].bridgeJSLiftParameter())
+    ret.bridgeJSLowerReturn()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_roundTripOptionalJSValueArray")
+@_cdecl("bjs_roundTripOptionalJSValueArray")
+public func _bjs_roundTripOptionalJSValueArray(_ v: Int32) -> Void {
+    #if arch(wasm32)
+    let ret = roundTripOptionalJSValueArray(v: {
+        if v == 0 {
+            return Optional<[JSValue]>.none
+        } else {
+            return [JSValue].bridgeJSLiftParameter()
+        }
+        }())
+    let __bjs_isSome_ret = ret != nil
+    if let __bjs_unwrapped_ret = ret {
+    __bjs_unwrapped_ret.bridgeJSLowerReturn()}
+    _swift_js_push_i32(__bjs_isSome_ret ? 1 : 0)
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_makeImportedFoo")
 @_cdecl("bjs_makeImportedFoo")
 public func _bjs_makeImportedFoo(_ valueBytes: Int32, _ valueLength: Int32) -> Int32 {
@@ -8583,6 +8614,42 @@ func _$jsRoundTripJSValue(_ v: JSValue) throws(JSException) -> JSValue {
     return JSValue.bridgeJSLiftReturn()
 }
 
+#if arch(wasm32)
+@_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripJSValueArray")
+fileprivate func bjs_jsRoundTripJSValueArray() -> Void
+#else
+fileprivate func bjs_jsRoundTripJSValueArray() -> Void {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+
+func _$jsRoundTripJSValueArray(_ v: [JSValue]) throws(JSException) -> [JSValue] {
+    let _ = v.bridgeJSLowerParameter()
+    bjs_jsRoundTripJSValueArray()
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return [JSValue].bridgeJSLiftReturn()
+}
+
+#if arch(wasm32)
+@_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsRoundTripOptionalJSValueArray")
+fileprivate func bjs_jsRoundTripOptionalJSValueArray(_ v: Int32) -> Void
+#else
+fileprivate func bjs_jsRoundTripOptionalJSValueArray(_ v: Int32) -> Void {
+    fatalError("Only available on WebAssembly")
+}
+#endif
+
+func _$jsRoundTripOptionalJSValueArray(_ v: Optional<[JSValue]>) throws(JSException) -> Optional<[JSValue]> {
+    let vIsSome = v.bridgeJSLowerParameter()
+    bjs_jsRoundTripOptionalJSValueArray(vIsSome)
+    if let error = _swift_js_take_exception() {
+        throw error
+    }
+    return Optional<[JSValue]>.bridgeJSLiftReturn()
+}
+
 #if arch(wasm32)
 @_extern(wasm, module: "BridgeJSRuntimeTests", name: "bjs_jsThrowOrVoid")
 fileprivate func bjs_jsThrowOrVoid(_ shouldThrow: Int32) -> Void
diff --git a/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.json b/Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.json
@@ -5637,6 +5637,82 @@
           }
         }
       },
+      {
+        "abiName" : "bjs_roundTripJSValueArray",
+        "effects" : {
+          "isAsync" : false,
+          "isStatic" : false,
+          "isThrows" : false
+        },
+        "name" : "roundTripJSValueArray",
+        "parameters" : [
+          {
+            "label" : "v",
+            "name" : "v",
+            "type" : {
+              "array" : {
+                "_0" : {
+                  "jsValue" : {
+
+                  }
+                }
+              }
+            }
+          }
+        ],
+        "returnType" : {
+          "array" : {
+            "_0" : {
+              "jsValue" : {
+
+              }
+            }
+          }
+        }
+      },
+      {
+        "abiName" : "bjs_roundTripOptionalJSValueArray",
+        "effects" : {
+          "isAsync" : false,
+          "isStatic" : false,
+          "isThrows" : false
+        },
+        "name" : "roundTripOptionalJSValueArray",
+        "parameters" : [
+          {
+            "label" : "v",
+            "name" : "v",
+            "type" : {
+              "nullable" : {
+                "_0" : {
+                  "array" : {
+                    "_0" : {
+                      "jsValue" : {
+
+                      }
+                    }
+                  }
+                },
+                "_1" : "null"
+              }
+            }
+          }
+        ],
+        "returnType" : {
+          "nullable" : {
+            "_0" : {
+              "array" : {
+                "_0" : {
+                  "jsValue" : {
+
+                  }
+                }
+              }
+            },
+            "_1" : "null"
+          }
+        }
+      },
       {
         "abiName" : "bjs_makeImportedFoo",
         "effects" : {
@@ -12944,6 +13020,68 @@
               }
             }
           },
+          {
+            "name" : "jsRoundTripJSValueArray",
+            "parameters" : [
+              {
+                "name" : "v",
+                "type" : {
+                  "array" : {
+                    "_0" : {
+                      "jsValue" : {
+
+                      }
+                    }
+                  }
+                }
+              }
+            ],
+            "returnType" : {
+              "array" : {
+                "_0" : {
+                  "jsValue" : {
+
+                  }
+                }
+              }
+            }
+          },
+          {
+            "name" : "jsRoundTripOptionalJSValueArray",
+            "parameters" : [
+              {
+                "name" : "v",
+                "type" : {
+                  "nullable" : {
+                    "_0" : {
+                      "array" : {
+                        "_0" : {
+                          "jsValue" : {
+
+                          }
+                        }
+                      }
+                    },
+                    "_1" : "null"
+                  }
+                }
+              }
+            ],
+            "returnType" : {
+              "nullable" : {
+                "_0" : {
+                  "array" : {
+                    "_0" : {
+                      "jsValue" : {
+
+                      }
+                    }
+                  }
+                },
+                "_1" : "null"
+              }
+            }
+          },
           {
             "name" : "jsThrowOrVoid",
             "parameters" : [
diff --git a/Tests/BridgeJSRuntimeTests/ImportAPITests.swift b/Tests/BridgeJSRuntimeTests/ImportAPITests.swift
@@ -73,6 +73,32 @@ class ImportAPITests: XCTestCase {
         }
     }
 
+    func testRoundTripJSValueArray() throws {
+        let object = JSObject.global
+        let symbol = JSSymbol("array")
+        let bigInt = JSBigInt(_slowBridge: Int64(42))
+        let values: [JSValue] = [
+            .boolean(false),
+            .number(123.5),
+            .string(JSString("hello")),
+            .object(object),
+            .null,
+            .undefined,
+            .symbol(symbol),
+            .bigInt(bigInt),
+        ]
+        let roundTripped = try jsRoundTripJSValueArray(values)
+        XCTAssertEqual(roundTripped, values)
+        XCTAssertEqual(try jsRoundTripJSValueArray([]), [])
+    }
+
+    func testRoundTripOptionalJSValueArray() throws {
+        XCTAssertNil(try jsRoundTripOptionalJSValueArray(nil))
+        let values: [JSValue] = [.number(1), .undefined, .null]
+        let result = try jsRoundTripOptionalJSValueArray(values)
+        XCTAssertEqual(result, values)
+    }
+
     func testRoundTripFeatureFlag() throws {
         for v in [FeatureFlag.foo, .bar] {
             try XCTAssertEqual(jsRoundTripFeatureFlag(v), v)
diff --git a/Tests/BridgeJSRuntimeTests/bridge-js.d.ts b/Tests/BridgeJSRuntimeTests/bridge-js.d.ts
@@ -6,6 +6,8 @@ export function jsRoundTripOptionalNumberNull(v: number | null): number | null
 export function jsRoundTripOptionalNumberUndefined(v: number | undefined): number | undefined
 export type JSValue = any
 export function jsRoundTripJSValue(v: JSValue): JSValue
+export function jsRoundTripJSValueArray(v: JSValue[]): JSValue[]
+export function jsRoundTripOptionalJSValueArray(v: JSValue[] | null): JSValue[] | null
 export function jsThrowOrVoid(shouldThrow: boolean): void
 export function jsThrowOrNumber(shouldThrow: boolean): number
 export function jsThrowOrBool(shouldThrow: boolean): boolean
diff --git a/Tests/prelude.mjs b/Tests/prelude.mjs
@@ -71,6 +71,12 @@ export async function setupOptions(options, context) {
                 "jsRoundTripJSValue": (v) => {
                     return v;
                 },
+                "jsRoundTripJSValueArray": (values) => {
+                    return values;
+                },
+                "jsRoundTripOptionalJSValueArray": (values) => {
+                    return values ?? null;
+                },
                 "jsRoundTripIntArray": (items) => {
                     return items;
                 },
@@ -273,6 +279,10 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     assert.deepEqual(arrayStructRoundTrip.optStrings, ["a", "b"]);
     assert.equal(exports.arrayMembersSum(arrayStruct, [10, 20]), 30);
     assert.equal(exports.arrayMembersFirst(arrayStruct, ["x", "y"]), "x");
+    const jsValueArray = [true, 42, "ok", { nested: 1 }, null, undefined];
+    assert.deepEqual(exports.roundTripJSValueArray(jsValueArray), jsValueArray);
+    assert.deepEqual(exports.roundTripOptionalJSValueArray(jsValueArray), jsValueArray);
+    assert.equal(exports.roundTripOptionalJSValueArray(null), null);
 
     for (const p of [1, 4, 1024, 65536, 2147483647]) {
         assert.equal(exports.roundTripUnsafeRawPointer(p), p);
