Malformed Swift wrapper for fn(input: &[u8]) -> Vec<u8> signatures (0.1.59)

[JohnnyTarrr]

swift-bridge 0.1.59 produces malformed Swift code in the generated wrapper for extern "Swift" functions with the signature fn(input: &[u8]) -> Vec<u8>.

This is distinct from #228 (which covers the Vec<u8> return-type implementation; that fix landed). The Vec<u8> return marshaling itself works — the bug is in the &[u8] input-side marshaling, where the slice unpacking is emitted in expression position rather than statement position.

Reproducer

// src/bridge.rs
#[swift_bridge::bridge]
mod ffi {
    extern "Swift" {
        fn my_hash(input: &[u8]) -> Vec<u8>;
    }
}

Generated Swift (from cargo build)

@_cdecl("__swift_bridge__$my_hash")
func __swift_bridge__my_hash (_ input: __private__FfiSlice) -> UnsafeMutableRawPointer {
    { let val = my_hash(input: let slice = input; return UnsafeBufferPointer(start: slice.start.assumingMemoryBound(to: UInt8.self), count: Int(slice.len));); val.isOwned = false; return val.ptr }()
}

The inlined let slice = input; return UnsafeBufferPointer(...) cannot appear in expression position inside the my_hash(input: ...) argument — let and return are statements in Swift, not expressions. The Swift compiler rejects this with error: expected expression.

Likely fix

The slice unpacking needs to be hoisted to a statement above the call:

@_cdecl("__swift_bridge__$my_hash")
func __swift_bridge__my_hash (_ input: __private__FfiSlice) -> UnsafeMutableRawPointer {
    let slice = UnsafeBufferPointer(start: input.start.assumingMemoryBound(to: UInt8.self), count: Int(input.len))
    let val = my_hash(input: slice)
    val.isOwned = false
    return val.ptr
}

Looks like a missed case in swift-bridge-ir's expression-flattener for the &[u8] input-side marshaling specifically.

Workaround in use

Hex-encoded String -> String signatures (Rust passes hex string, Swift decodes + processes + returns hex). Functional but adds encode/decode CPU overhead. Not viable in hot paths so we'd appreciate a fix.

Environment

• swift-bridge 0.1.59
• swift 6.2.3 (Apple Swift)
• macOS 26.0 / aarch64-apple-darwin

Happy to provide a minimal repro project if useful. Thanks for the great library!

[JohnnyTarrr]

Adding empirical evidence to confirm F1 is distinct from #228 (and that #228's fix did land in 0.1.59):

Minimal reproducer crate

Cargo.toml:

[package]
name = "sb-vec-test"
version = "0.1.0"
edition = "2021"
[lib]
crate-type = ["lib", "staticlib"]
[dependencies]
swift-bridge = "0.1"
[build-dependencies]
swift-bridge-build = "0.1"

src/bridge.rs:

#[swift_bridge::bridge]
mod ffi {
    extern "Swift" {
        fn ret_bytes() -> Vec<u8>;                  // Test 1: Vec<u8> return only
        fn take_bytes(input: &[u8]);                // Test 2: &[u8] input only
        fn hash_bytes(input: &[u8]) -> Vec<u8>;     // Test 3: both
    }
}

build.rs (standard swift-bridge-build invocation).

Generated Swift (0.1.59)

Test 1: Vec<u8> return only ✅ WELL-FORMED

@_cdecl("__swift_bridge__$ret_bytes")
func __swift_bridge__ret_bytes () -> UnsafeMutableRawPointer {
    { let val = ret_bytes(); val.isOwned = false; return val.ptr }()
}

With a hand-written public func ret_bytes() -> RustVec<UInt8> impl, swiftc -typecheck passes cleanly. #228's fix is in 0.1.59 and works correctly.

Test 2: &[u8] input only ❌ MALFORMED

@_cdecl("__swift_bridge__$take_bytes")
func __swift_bridge__take_bytes (_ input: __private__FfiSlice) {
    take_bytes(input: let slice = input; return UnsafeBufferPointer(start: slice.start.assumingMemoryBound(to: UInt8.self), count: Int(slice.len));)
}

swiftc -typecheck fails:

error: missing argument for parameter 'input' in call
error: unexpected non-void return value in void function

Test 3: both &[u8] input AND Vec<u8> return ❌ MALFORMED (same input-side bug)

@_cdecl("__swift_bridge__$hash_bytes")
func __swift_bridge__hash_bytes (_ input: __private__FfiSlice) -> UnsafeMutableRawPointer {
    { let val = hash_bytes(input: let slice = input; return UnsafeBufferPointer(start: slice.start.assumingMemoryBound(to: UInt8.self), count: Int(slice.len));); val.isOwned = false; return val.ptr }()
}

Same error: missing argument for parameter 'input' in call. The closure wrapper around the return-side is fine; the input-side let slice = input; return UnsafeBufferPointer(...) placed in expression position is what Swift rejects.

Conclusion

F1 is specifically the &[u8] INPUT-side marshaling, independent of the Vec<u8> return-type implementation tracked in #228. The fix likely lives somewhere in swift-bridge-ir's wrapper-emission for __private__FfiSlice arguments — needs to hoist the slice unpacking to a let-statement BEFORE the call to the user's Swift function, rather than inlining it inside the argument expression.

Environment unchanged from original report: swift-bridge 0.1.59, swift 6.2.3, macOS 26.0.