Hi, I'm the one who asked about using Rust in Swift on Reddit.

I've made a Gist that follows your steps, but slightly modified to set up a Swift project with Swift Package Manager (https://gist.github.com/Jomy10/a4873dd43942ed1bf54d387dbc888795).

I've tried to add dependencies to Package.swift, but I don't know how to include them in the compiling process. Swiftc documentation seems to be rather scarce.

Here's an example of the Package.swift file:

// swift-tools-version:5.5
import PackageDescription

let package = Package(
    name: "swift",
    dependencies: [
        .package(url: "/path/to/HelloSwift", .branch("master"))
    ],
    targets: [
        .target(
            name: "swift",
            dependencies: [
                .product(name: "HelloSwift", package: "HelloSwift")
            ]),
        .testTarget(
            name: "swiftTests",
            dependencies: ["swift"]),
    ]
)

Folder structure is also in the gist.

I think it would be great if we could also use Swift Package Manager in the Swift project using the Rust library. Or maybe import the Rust library as a package in Package.Swift.

I have added support for generating Swift Packages.

The generate_package function inside of package.rs creates a package containing the xcframework needed.

The GeneratePackageConfig has 4 fields:

• bridge_dir: the directory containing the generated bridge files
• paths: the path to the compiled rust library and its platform. I have made the ApplePlatform enum follow the naming conventions of Apple. Let me know if you would rather have Rust naming conventions for this.
• out_dir: the output directory for th swift package
• package_name: the name for the Swift Package

I have added a test that generates a Swift Pacakage and tests that it executes and the output is correct.

I was wondering if we could replace this command:

swiftc -L target/x86_64-apple-darwin/debug/ -lswift_and_rust -import-objc-header bridging-header.h \
  main.swift lib.swift ./generated/swift-and-rust/swift-and-rust.swift

with swift build

I have tried the following in Package.swift

// swift-tools-version:5.5

import PackageDescription

let package = Package(
    name: "LinuxSwiftPackage",
    dependencies: [],
    targets: [
        .executableTarget(
            name: "LinuxSwiftPackage",
            dependencies: [],
            linkerSettings: [
                .unsafeFlags(["-L lib_mac", "-lmy_rust_lib", "-import-objc-header bridging-header.h"])
            ]
        )
    ]
)

It didn't seem to work, though.

All settings can be found in the Apple documentation, there is CSettings, SwiftSettings, LinkerSettings, ...

These are all things we can specify in the Package.swift.

here you can also find some information under "Settings".

It looks like you can also specify a json file using swift build --destination file.json. This also looks like a promising option.

I tried swift build --destination file.json

// file.json
{
    "version": 1,
    "sdk": "/swift/usr/bin/swift",
    "toolchain-bin-dir": "/swift/usr/bin",
    "target": "x86_64-apple-macosx",
    "dynamic-library-extension": "lib",
    "extra-cc-flags": [
    ],
    "extra-swiftc-flags": [
        "-L lib_mac",
        "-lmy_rust_lib",
        "-import-objc-header",
        "bridging-header.h"
    ],
    "extra-cpp-flags": []
}

but I'm getting

error: no such module 'Foundation'
import Foundation

This would allow us to link our library more easily in executable Swift packages, which I think would be useful for Linux as an alternative for generating a Swift Package.

I can't seem to find any more information on this and I'm not really knowledgeable in linking header files.

I'll leave some of my thoughts here after writing that book chapter on how we should implement the build process for Swift packages into swift-bridge.

We'll probably want an extra option in build.rs to generate a Swift package, maybe something like:

swift_bridge_build::parse_bridges(bridges)
        .write_all_concatenated(out_dir, env!("CARGO_PKG_NAME"))
        .generate_package();

For generating the xcframework, we could either use the xcodebuild command, or we could write the .plist file manually, which I think could be a good option.

I think all of the other steps should be pretty straight forward, following the chapter of the book.

I have the following struct type defined currently APIResponseObject<T, MT>, where both T and MT are supposed to be deserialized by Rust.

For some reason, if I try to extern them, I get a weird error, probably because generics (e.g. MyStruct<T>) aren't implemented for the bridge yet?

Following code is my bridge:

#[swift_bridge::bridge]
mod ffi {
    // inferred from https://chinedufn.github.io/swift-bridge/bridge-module/opaque-types/index.html
    extern "Rust" {
        type APIResponseList<T, MT>;
        type PteroClientServer;
        type APIResponsePaginationMetaData;
        type APIResponseObject<T, MT>;
    }

    extern "Rust" {
        type PteroClient;

        #[swift_bridge(init)]
        fn new(base_url: String, api_key: String) -> PteroClient;

        // inferred from https://github.com/chinedufn/swift-bridge/blob/ecc6704985ea260ae502d7ccdd776602e5f263ea/examples/async-functions/src/lib.rs
        async fn get_servers(&self) -> Option<APIResponseList<APIResponseObject<PteroClientServer, APIResponsePaginationMetaData>, APIResponsePaginationMetaData>>;
    }
}

The error I receive:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error("expected `,`")', /home/cozygalvinism/.cargo/registry/src/github.com-1ecc6299db9ec823/swift-bridge-ir-0.1.29/src/bridged_type.rs:335:82

Am I doing something wrong or is my assumption correct?

Hi! First - thank you for this project! I have successfully called Rust code from Swift!

Unfortunately, I am having some troubles, and I can't figure out how to fix them.

I want to call a Swift function from Rust, but the generated swift code has a compiler error in it.

This is the rust code (snippet)

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        // Works, except the function is still called rust_init on the Swift side?
        #[swift_bridge(swift_name = "rustInit")]
        fn init(url: String);
    }

    extern "Swift" {
        // Generates a Swift compiler error
        #[swift_bridge(swift_name = "getAuthToken")]
        fn get_authentication_token() -> String;
    }
}

This snippet is generated

@_cdecl("__swift_bridge__$get_authentication_token")
func __swift_bridge__get_authentication_token () -> RustString {
    { let rustString = getAuthToken().intoRustString(); rustString.isOwned = false; return rustString.ptr }()
}

And then I added this function (in the Swift package, as a new file)

public func getAuthToken() -> String {
    return "token"
}

But the generated snippet has these compiler errors:

• Method cannot be marked @_cdecl because its result type cannot be represented in Objective-C
• Cannot convert return expression of type 'UnsafeMutableRawPointer' to return type 'RustString'

An additional, minor, problem is that #[swift_bridge(swift_name = "rustInit")] doesn't seem to do anything.

What am I doing wrong? Thanks.

I've tried both the book example + running the tests and both fail ("error[E0658]: destructuring assignments are unstable" and "panic in main thread" respectively). Do I need nightly compiler?

I can follow up with stack traces/needed info, if someone could confirm it's buildable/usable. I really like the idea of this crate, so hoping to succeed

Thanks for this crate! I'm looking into using librespot with Swift, but can't seem to have async methods or async functions with parameters.

async method

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        type SpotifyApp;

        async fn connect(&mut self);
    }
}

pub struct SpotifyApp {}

impl SpotifyApp {
    pub async fn connect(&mut self) {
        print!("Connecting to Spotify...");
    }
}

error[E0425]: cannot find value `this` in this scope
 --> src/lib.rs:6:1
  |
6 | #[swift_bridge::bridge]
  | ^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
  |
  = note: this error originates in the attribute macro `swift_bridge::bridge`

async function with parameters

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        type SpotifyApp;

        async fn connect(track_id: &str);
    }
}

pub struct SpotifyApp {}

pub async fn connect(track_id: &str) {
    print!("Connecting to Spotify... {track_id}");
}

error[E0425]: cannot find value `track_id` in this scope
  --> src/lib.rs:11:26
   |
11 |         async fn connect(track_id: &str);
   |                          ^^^^^^^^ not found in this scope

Without one of these, I'm unable to pass data from the Swift app to Rust within async functions, do you think it is possible to have async methods or async functions with parameters? Thank you again :)

This commit adds support for passing a Result<T, E> as an argument from Rust -> Swift.

For example, the following is not possible:

use some_crate::SomeRustType;

#[swift_bridge::bridge]
mod ffi {
    extern "Swift" {
        fn swift_func_takes_callback(
            arg: Box<dyn FnOnce(Result<SomeRustType, String>)>,
        );
    }

    extern "Rust" {
        type SomeRustType;

        #[swift_bridge::init]
        fn new () -> SomeRustType;
    }
}

This could just me missing some basic things, but I wasn't able to find in the book how to compile swift code to link and use in Rust. The book seems to focus heavily on calling Rust FROM Swift but not the other way around.

I'm currently going down the route to use a Swift Package (code is here https://github.com/lorenzolewis/tauri-ffi/tree/main/examples/swift-bridge/src-swift) to hold my Swift code. I don't see anything in the docs on how you're supposed to annotate Swift code to be exposed to Rust so I'm annotating functions with _cdecl which I've used from another implementation to text.

On the Rust side I'm using Tauri and have the Rust code here https://github.com/lorenzolewis/tauri-ffi/tree/main/examples/swift-bridge/src-tauri.

I'm assuming there's some sort of build/compile step I'm missing with Swift to generate the needed header files that I may have just missed in the docs?

To reproduce:

1. clone swift-bridge
2. git checkout 1951b4a262719c68590b635358677d1416248b58
3. cargo test --all && ./test-integration.sh

   Compiling hir_def v0.0.0 (https://github.com/rust-analyzer/rust-analyzer#c6995a37)
error[E0308]: mismatched types
  --> /Users/holliday/.cargo/git/checkouts/rust-analyzer-5e0f1308176aaeda/c6995a3/crates/hir_def/src/intern.rs:62:25
   |
62 |             None => Err(shard),
   |                         ^^^^^ expected struct `parking_lot::RawRwLock`, found struct `dashmap::RawRwLock`
   |
   = note: expected struct `lock_api::RwLockWriteGuard<'_, parking_lot::RawRwLock, HashMap<Arc<T>, SharedValue<()>, BuildHasherDefault<FxHasher>>>`
              found struct `lock_api::RwLockWriteGuard<'_, dashmap::RawRwLock, hashbrown::map::HashMap<Arc<T>, SharedValue<()>, BuildHasherDefault<FxHasher>>>`

rustc 1.60.0 (7737e0b5c 2022-04-04)
cargo 1.60.0 (d1fd9fe2c 2022-03-01)
macOS 12.3.1 (21E258)
Xcode  13.3.1 (13E500a)

New Feature

//Rust side 

extern "Rust" {
    fn get_value()->i16;
}

//build.rs

use std::path::PathBuf;

fn main() {
    let out_dir = PathBuf::from("./generated");

    let bridges = vec!["src/lib.rs"];
    for path in &bridges {
        println!("cargo:rerun-if-changed={}", path);
    }
    
    let support_camel_case = true  // option to convert snake case to camel case

    swift_bridge_build::parse_bridges(bridges, support_camel_case)
        .write_all_concatenated(out_dir, env!("CARGO_PKG_NAME"));
}

//Swift side 

let value = getValue()

Why

the Swift API Design Guidelines recommend using camel case.

I would like to read some documentation on what you think the best place for auxillary Swift files for the generated Swift Package is.

Might it be

• In the directory of the "target Swift Package" itself (could be another folder / git)?
• In some directory in the "source crate" using swift-bridge?
• Some other place
• Undefined

Is there some automatic facility for copying Swift files already in place?

I've got a quite complicated type I'm sharing via the swift bridge interface. I'm using an opaque type, but I want to use the async function bridge and it looks like thats not supported:

   Compiling dt-swift v0.1.0 (/Users/seph/src/diamond-types/crates/dt-swift)
error: failed to run custom build command for `dt-swift v0.1.0 (/Users/seph/src/diamond-types/crates/dt-swift)`

Caused by:
  process didn't exit successfully: `/Users/seph/src/diamond-types/target/release/build/dt-swift-82fb4d8c023013ad/build-script-build` (exit status: 101)
  --- stdout
  cargo:rerun-if-changed=src/lib.rs

  --- stderr
  thread 'main' panicked at 'not implemented', /Users/seph/.cargo/registry/src/github.com-1ecc6299db9ec823/swift-bridge-ir-0.1.41/src/bridged_type/bridged_opaque_type.rs:71:21

The code for async functions in opaque types is unimplemented:

                TypePosition::SwiftCallsRustAsyncOnCompleteReturnTy => {
                    unimplemented!()
                }

• What is needed to add support here?
• Are there any workarounds? Can I have a bridged struct with an opaque reference or something?

A library I'm using calls tokio::runtime::Handle::current() in a non-async function and calling this results in a panic there is no reactor running, must be called from the context of a Tokio 1.x runtime. Presumably that context is only running when the function is async. Unsure if this is an issue with that library (i.e. you shouldn't call that) or there's an issue on this side of the fence.

I do need to call that function in my initialisation though, and making that an init function async results in a not implemented panic on matching TypePosition::SwiftCallsRustAsyncOnCompleteReturnTy within bridged_type/bridged_opaque_type.rs:71:21.

Any suggestions as to the best ways to work around these?

I appreciate the example showing how to link swift into rust, but I think the examples are all pretty simple swift. I'm trying to use this library to write bindings for an Apple framework, so the swift classes involved a bit more complex.

For instance if I have nested swift structs/classes like

class Foo {
  var x : Int

  init(x : Int) {
    self.x = x
  }

  struct Bar {
    var y: Int
  }

  func baz(bar: Bar) -> Int {
    return x + bar.y
  }
}

and I want to do something like

let foo = Foo(x: 1)
let bar = Foo.Bar(y: 2)
print("baz: \(foo.baz(bar: bar))")

but from rust, how would I write the bindings?

Also, some swift libraries have vars that I might want to access from rust. Is it possible to write bindings to do this?

Since cargo-lipo is considered deprecated by its developer, the tutorial for setting up swift-bridge in an xcode project should use a properly maintained alternative instead. cargo-xcode seems to be a promising alternative since it also does some of the required XCode project configuration and therefore eliminates the need for additional setup/build scripts (build.rs is still necessary but minimal).

I was able to set up and built a project using swift-bridge + cargo-xcode with the Apple Multiplatform target, so I could do a draft for the revised tutorial section if wanted.