Unable to bridge async function that returns Vec

[crwen]

I tried to call an asynchronous function returning Vec<u8> from Rust in Swift, but I got the following errors when compile with swiftc:

error: cannot convert value of type 'RustVec<UInt8>' to expected argument type 'UnsafeMutableRawPointer'
 2 |     func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: RustVec<UInt8>) {
 3 |         let wrapper = Unmanaged<CbWrapper$async_func_return_vec>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
 4 |         wrapper.cb(.success(RustVec(ptr: rustFnRetVal)))
   |                                          `- error: cannot convert value of type 'RustVec<UInt8>' to expected argument type 'UnsafeMutableRawPointer'
 5 |     }
 6 | 

error: cannot convert value of type '(UnsafeMutableRawPointer?, RustVec<UInt8>) -> ()' to expected argument type '(@convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void)?'
13 |         let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
14 | 
15 |         __swift_bridge__$async_func_return_vec(wrapperPtr, onComplete)
   |                                                            `- error: cannot convert value of type '(UnsafeMutableRawPointer?, RustVec<UInt8>) -> ()' to expected argument type '(@convention(c) (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) -> Void)?'
16 |     })
17 | }

I think the problem is that the function signature of the onComplete callback does not match the function signature of the generated c header file.

Here is the minimal reproducible example

// lib.rs

#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        async fn async_func_return_vec() -> Vec<u8>;
    }
}

async fn async_func_return_vec() -> Vec<u8> {
    vec![1, 2, 3]
}

Here is the generated swift code:

public func async_func_return_vec() async -> RustVec<UInt8> {
    func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: RustVec<UInt8>) {
        let wrapper = Unmanaged<CbWrapper$async_func_return_vec>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
        wrapper.cb(.success(RustVec(ptr: rustFnRetVal)))
    }

    return await withCheckedContinuation({ (continuation: CheckedContinuation<RustVec<UInt8>, Never>) in
        let callback = { rustFnRetVal in
            continuation.resume(with: rustFnRetVal)
        }

        let wrapper = CbWrapper$async_func_return_vec(cb: callback)
        let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()

        __swift_bridge__$async_func_return_vec(wrapperPtr, onComplete)
    })
}

Here is the generated c header code:

void __swift_bridge__$async_func_return_vec(void* callback_wrapper, void __swift_bridge__$async_func_return_vec$async(void* callback_wrapper, void* ret));

[chinedufn]

Thank you for the report.

---

If anyone wants to work on this, here is where the codegen tests are for async functions:

swift-bridge/crates/swift-bridge-ir/src/codegen/codegen_tests/async_function.rs

Lines 5 to 1051 in 93da216

	/// Verify that we generate the correct code for extern "Rust" async functions that do not return
	/// a value.
	mod extern_rust_async_function_no_return {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn some_function();
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	fut.await;
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function() async {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(()))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<(), Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<(), Never>) -> ()
	public init(cb: @escaping (Result<(), Never>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that takes a u32 arg.
	mod extern_rust_async_function_u32_arg {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn some_function(arg: u32);
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void) -> (),
	arg: u32
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function(arg);
	let task = async move {
	fut.await;
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function(_ arg: UInt32) async {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(()))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<(), Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete, arg)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<(), Never>) -> ()
	public init(cb: @escaping (Result<(), Never>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	#include <stdint.h>
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper), uint32_t arg);
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_u8() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a u8.
	mod extern_rust_async_function_returns_u8 {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn some_function() -> u8;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, u8) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = fut.await;
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function() async -> UInt8 {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: UInt8) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(rustFnRetVal))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<UInt8, Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<UInt8, Never>) -> ()
	public init(cb: @escaping (Result<UInt8, Never>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	#include <stdint.h>
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, uint8_t ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_u8() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a u8.
	mod extern_rust_async_function_returns_string {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn some_function() -> String;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, *mut swift_bridge::string::RustString) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = swift_bridge::string::RustString(fut.await).box_into_raw();
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function() async -> RustString {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: UnsafeMutableRawPointer?) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(RustString(ptr: rustFnRetVal!)))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<RustString, Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<RustString, Never>) -> ()
	public init(cb: @escaping (Result<RustString, Never>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, void* ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_string() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a struct.
	mod extern_rust_async_function_returns_struct {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	struct SomeStruct {
	field: u8
	}
	extern "Rust" {
	async fn some_function() -> SomeStruct;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, __swift_bridge__SomeStruct) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = fut.await.into_ffi_repr();
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function() async -> SomeStruct {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __swift_bridge__$SomeStruct) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(rustFnRetVal.intoSwiftRepr()))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<SomeStruct, Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<SomeStruct, Never>) -> ()
	public init(cb: @escaping (Result<SomeStruct, Never>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __swift_bridge__$SomeStruct ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_struct() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async method.
	mod extern_rust_async_method {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	type SomeType;
	async fn some_method(&self);
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__SomeType_some_method(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void) -> (),
	this: *mut super::SomeType
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = (unsafe {&*this}).some_method();
	let task = async move {
	fut.await;
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	extension SomeTypeRef {
	public func some_method() async {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?) {
	let wrapper = Unmanaged<CbWrapper$SomeType$some_method>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	wrapper.cb(.success(()))
	}
	return await withCheckedContinuation({ (continuation: CheckedContinuation<(), Never>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$SomeType$some_method(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$SomeType$some_method(wrapperPtr, onComplete, ptr)
	})
	}
	class CbWrapper$SomeType$some_method {
	var cb: (Result<(), Never>) -> ()
	public init(cb: @escaping (Result<(), Never>) -> ()) {
	self.cb = cb
	}
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$SomeType$some_method(void* callback_wrapper, void __swift_bridge__$SomeType$some_method$async(void* callback_wrapper), void* self);
	"#,
	)
	}
	#[test]
	fn extern_rust_async_method() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<OpaqueRustType, OpaqueRustType>.
	mod extern_rust_async_function_returns_result_opaque {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	type OkType;
	type ErrorType;
	async fn some_function() -> Result<OkType, ErrorType>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, swift_bridge :: result :: ResultPtrAndPtr) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = match fut.await {
	Ok(ok) => {
	swift_bridge::result::ResultPtrAndPtr {
	is_ok: true,
	ok_or_err: Box::into_raw(Box::new({
	let val: super::OkType = ok;
	val
	})) as *mut super::OkType as *mut std::ffi::c_void
	}
	}
	Err(err) => {
	swift_bridge::result::ResultPtrAndPtr {
	is_ok: false,
	ok_or_err: Box::into_raw(Box::new({
	let val: super::ErrorType = err;
	val
	})) as *mut super::ErrorType as *mut std::ffi::c_void
	}
	}
	};
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	// TODO: Replace `Error` with the concrete error type `ErrorType`.
	// As of Feb 2023 using the concrete error type leads to a compile time error.
	// This seems like a bug in the Swift compiler.
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	public func some_function() async throws -> OkType {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __private__ResultPtrAndPtr) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	if rustFnRetVal.is_ok {
	wrapper.cb(.success(OkType(ptr: rustFnRetVal.ok_or_err!)))
	} else {
	wrapper.cb(.failure(ErrorType(ptr: rustFnRetVal.ok_or_err!)))
	}
	}
	return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<OkType, Error>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<OkType, Error>) -> ()
	public init(cb: @escaping (Result<OkType, Error>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __private__ResultPtrAndPtr ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_result_opaque() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<TransparentEnum, TransparentEnum>.
	mod extern_rust_async_function_returns_result_transparent_enum {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	enum OkEnum {
	OkVariant1,
	OkVariant2,
	}
	enum ErrEnum {
	ErrVariant1,
	ErrVariant2,
	}
	extern "Rust" {
	async fn some_function() -> Result<OkEnum, ErrEnum>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, ResultOkEnumAndErrEnum) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = match fut.await {
	Ok(ok) => ResultOkEnumAndErrEnum::Ok(ok.into_ffi_repr()),
	Err(err) => ResultOkEnumAndErrEnum::Err(err.into_ffi_repr()),
	};
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	// TODO: Replace `Error` with the concrete error type `ErrorType`.
	// As of Feb 2023 using the concrete error type leads to a compile time error.
	// This seems like a bug in the Swift compiler.
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	public func some_function() async throws -> OkEnum {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __swift_bridge__$ResultOkEnumAndErrEnum) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	switch rustFnRetVal.tag { case __swift_bridge__$ResultOkEnumAndErrEnum$ResultOk: wrapper.cb(.success(rustFnRetVal.payload.ok.intoSwiftRepr())) case __swift_bridge__$ResultOkEnumAndErrEnum$ResultErr: wrapper.cb(.failure(rustFnRetVal.payload.err.intoSwiftRepr())) default: fatalError() }
	}
	return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<OkEnum, Error>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<OkEnum, Error>) -> ()
	public init(cb: @escaping (Result<OkEnum, Error>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __swift_bridge__$ResultOkEnumAndErrEnum ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_result_transparent_enum() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<OpaqueRustType, TransparentEnum>.
	mod extern_rust_async_function_returns_result_opaque_rust_transparent_enum {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	enum ErrEnum {
	ErrVariant1,
	ErrVariant2,
	}
	extern "Rust" {
	type SomeType;
	async fn some_function() -> Result<SomeType, ErrEnum>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, ResultSomeTypeAndErrEnum) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = match fut.await {
	Ok(ok) => ResultSomeTypeAndErrEnum::Ok(Box::into_raw(Box::new({
	let val: super::SomeType = ok;
	val
	})) as *mut super::SomeType),
	Err(err) => ResultSomeTypeAndErrEnum::Err(err.into_ffi_repr()),
	};
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	// TODO: Replace `Error` with the concrete error type `ErrorType`.
	// As of Feb 2023 using the concrete error type leads to a compile time error.
	// This seems like a bug in the Swift compiler.
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	public func some_function() async throws -> SomeType {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __swift_bridge__$ResultSomeTypeAndErrEnum) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	switch rustFnRetVal.tag { case __swift_bridge__$ResultSomeTypeAndErrEnum$ResultOk: wrapper.cb(.success(SomeType(ptr: rustFnRetVal.payload.ok))) case __swift_bridge__$ResultSomeTypeAndErrEnum$ResultErr: wrapper.cb(.failure(rustFnRetVal.payload.err.intoSwiftRepr())) default: fatalError() }
	}
	return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<SomeType, Error>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<SomeType, Error>) -> ()
	public init(cb: @escaping (Result<SomeType, Error>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __swift_bridge__$ResultSomeTypeAndErrEnum ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_result_opaque_rust_transparent_enum() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<(), TransparentEnum>.
	mod extern_rust_async_function_returns_result_null_transparent_enum {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	enum ErrEnum {
	ErrVariant1,
	ErrVariant2,
	}
	extern "Rust" {
	async fn some_function() -> Result<(), ErrEnum>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, ResultVoidAndErrEnum) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = match fut.await {
	Ok(ok) => ResultVoidAndErrEnum::Ok,
	Err(err) => ResultVoidAndErrEnum::Err(err.into_ffi_repr()),
	};
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	// TODO: Replace `Error` with the concrete error type `ErrorType`.
	// As of Feb 2023 using the concrete error type leads to a compile time error.
	// This seems like a bug in the Swift compiler.
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	public func some_function() async throws -> () {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: __swift_bridge__$ResultVoidAndErrEnum) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	switch rustFnRetVal.tag { case __swift_bridge__$ResultVoidAndErrEnum$ResultOk: wrapper.cb(.success(())) case __swift_bridge__$ResultVoidAndErrEnum$ResultErr: wrapper.cb(.failure(rustFnRetVal.payload.err.intoSwiftRepr())) default: fatalError() }
	}
	return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<(), Error>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<(), Error>) -> ()
	public init(cb: @escaping (Result<(), Error>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, struct __swift_bridge__$ResultVoidAndErrEnum ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_result_null_transparent_enum() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}
	/// Verify that we generate the correct code for extern "Rust" async functions that returns a Result<(), OpaqueRustType>.
	mod extern_rust_async_function_returns_result_null_opaque {
	use super::*;
	fn bridge_module() -> TokenStream {
	quote! {
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	type ErrorType;
	async fn some_function() -> Result<(), ErrorType>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	pub extern "C" fn __swift_bridge__some_function(
	callback_wrapper: *mut std::ffi::c_void,
	callback: extern "C" fn(*mut std::ffi::c_void, *mut super::ErrorType) -> (),
	) {
	let callback_wrapper = swift_bridge::async_support::SwiftCallbackWrapper(callback_wrapper);
	let fut = super::some_function();
	let task = async move {
	let val = match fut.await {
	Ok(ok) => std::ptr::null_mut(),
	Err(err) => Box::into_raw(Box::new({
	let val: super::ErrorType = err;
	val
	})) as *mut super::ErrorType
	};
	let callback_wrapper = callback_wrapper;
	let callback_wrapper = callback_wrapper.0;
	(callback)(callback_wrapper, val)
	};
	swift_bridge::async_support::ASYNC_RUNTIME.spawn_task(Box::pin(task))
	}
	})
	}
	// TODO: Replace `Error` with the concrete error type `ErrorType`.
	// As of Feb 2023 using the concrete error type leads to a compile time error.
	// This seems like a bug in the Swift compiler.
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	public func some_function() async throws -> () {
	func onComplete(cbWrapperPtr: UnsafeMutableRawPointer?, rustFnRetVal: UnsafeMutableRawPointer?) {
	let wrapper = Unmanaged<CbWrapper$some_function>.fromOpaque(cbWrapperPtr!).takeRetainedValue()
	if rustFnRetVal == nil {
	wrapper.cb(.success(()))
	} else {
	wrapper.cb(.failure(ErrorType(ptr: rustFnRetVal!)))
	}
	}
	return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<(), Error>) in
	let callback = { rustFnRetVal in
	continuation.resume(with: rustFnRetVal)
	}
	let wrapper = CbWrapper$some_function(cb: callback)
	let wrapperPtr = Unmanaged.passRetained(wrapper).toOpaque()
	__swift_bridge__$some_function(wrapperPtr, onComplete)
	})
	}
	class CbWrapper$some_function {
	var cb: (Result<(), Error>) -> ()
	public init(cb: @escaping (Result<(), Error>) -> ()) {
	self.cb = cb
	}
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ContainsAfterTrim(
	r#"
	void __swift_bridge__$some_function(void* callback_wrapper, void __swift_bridge__$some_function$async(void* callback_wrapper, void* ret));
	"#,
	)
	}
	#[test]
	fn extern_rust_async_function_returns_result_null_opaque() {
	CodegenTest {
	bridge_module: bridge_module().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}

Can take some inspiration from this -> Vec<u8> test:

swift-bridge/crates/swift-bridge-ir/src/codegen/codegen_tests/vec.rs

Lines 548 to 604 in 93da216

	/// Test code generation for Rust function that returns a Vec<T> where T is a primitive Rust type.
	mod extern_swift_fn_return_vec_of_primitive_rust_type {
	use super::*;
	fn bridge_module_tokens() -> TokenStream {
	quote! {
	mod ffi {
	extern "Swift" {
	fn some_function() -> Vec<u8>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	#[allow(non_snake_case)]
	mod ffi {
	pub fn some_function() -> Vec<u8> {
	unsafe { *Box::from_raw(unsafe { __swift_bridge__some_function() }) }
	}
	#[allow(improper_ctypes)]
	extern "C" {
	#[link_name = "__swift_bridge__$some_function"]
	fn __swift_bridge__some_function() -> *mut Vec<u8>;
	}
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	@_cdecl("__swift_bridge__$some_function")
	func __swift_bridge__some_function () -> UnsafeMutableRawPointer {
	{ let val = some_function(); val.isOwned = false; return val.ptr }()
	}
	"#,
	)
	}
	fn expected_c_header() -> ExpectedCHeader {
	ExpectedCHeader::ExactAfterTrim("")
	}
	#[test]
	fn extern_swift_fn_return_vec_of_primitive_rust_type() {
	CodegenTest {
	bridge_module: bridge_module_tokens().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: expected_c_header(),
	}
	.test();
	}
	}

---

Here is where the async integration tests live:

swift-bridge/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/AsyncTests.swift

Lines 9 to 194 in 93da216

	class AsyncTests: XCTestCase {
	override func setUpWithError() throws {
	// Put setup code here. This method is called before the invocation of each test method in the class.
	}
	override func tearDownWithError() throws {
	// Put teardown code here. This method is called after the invocation of each test method in the class.
	}
	func testSwiftCallsRustAsyncFn() async throws {
	await rust_async_return_null()
	}
	/// Verify that we can pass and return a u8 to an async Rust function
	func testSwiftCallsRustAsyncFnReflectU8() async throws {
	let num = await rust_async_reflect_u8(123)
	XCTAssertEqual(num, 123)
	}
	/// Verify that we can pass and return a String to an async Rust function
	func testSwiftCallsRustAsyncFnReflectString() async throws {
	let string = await rust_async_reflect_string("hello world")
	XCTAssertEqual(string.toString(), "hello world")
	}
	/// Verify that we can call async Rust methods
	func testSwiftCallsRustAsyncMethodReflectU16() async throws {
	let test = TestRustAsyncSelf()
	let num = await test.reflect_u16(567)
	XCTAssertEqual(num, 567)
	}
	/// Verify that we can pass and return a Result<OpaqueRust, OpaqueRust> to an async Rust function
	func testSwiftCallsRustAsyncFnReflectResultOpaqueRust() async throws {
	// Should return an AsyncResultOpaqueRustType1 type.
	do {
	let _ = try await rust_async_func_reflect_result_opaque_rust(.Ok(AsyncResultOpaqueRustType1(10)))
	} catch {
	XCTFail()
	}
	// Should throw an AsyncResultOpaqueRustType2 type that conforms to Error protocol.
	do {
	let _ = try await rust_async_func_reflect_result_opaque_rust(.Err(AsyncResultOpaqueRustType2(100)))
	XCTFail()
	} catch let error as AsyncResultOpaqueRustType2 {
	XCTAssertEqual(error.val(), 100)
	} catch {
	XCTFail()
	}
	}
	/// Verify that we can return a Result<TransparentEnum, TransparentEnum> from async Rust function
	func testSwiftCallsRustAsyncFnReturnResultTransparentEnum() async throws {
	//Should return an AsyncResultOkEnum
	do {
	let value: AsyncResultOkEnum = try await rust_async_func_return_result_transparent_enum_and_transparent_enum(true)
	switch value {
	case .NoFields:
	XCTFail()
	case .UnnamedFields(let valueInt32, let valueString):
	XCTAssertEqual(valueInt32, 123)
	XCTAssertEqual(valueString.toString(), "hello")
	case .NamedFields(_):
	XCTFail()
	}
	} catch {
	XCTFail()
	}
	//Should throw an AsyncResultErrEnum
	do {
	let _ = try await rust_async_func_return_result_transparent_enum_and_transparent_enum(false)
	XCTFail()
	} catch let error as AsyncResultErrEnum {
	switch error {
	case .UnnamedFields(_, _):
	XCTFail()
	case .NamedFields(let valueUInt32):
	XCTAssertEqual(valueUInt32, 100)
	}
	} catch {
	XCTFail()
	}
	}
	/// Verify that we can return a Result<OpaqueRust, TransparentEnum> from async Rust function
	func testSwiftCallsRustAsyncFnReturnResultOpaqueRustTransparentEnum() async throws {
	//Should return an AsyncResultOpaqueRustType1
	do {
	let value: AsyncResultOpaqueRustType1 = try await rust_async_func_return_result_opaque_rust_and_transparent_enum(true)
	XCTAssertEqual(value.val(), 10)
	} catch {
	XCTFail()
	}
	//Should throw an AsyncResultErrEnum
	do {
	let _: AsyncResultOpaqueRustType1 = try await rust_async_func_return_result_opaque_rust_and_transparent_enum(false)
	} catch let error as AsyncResultErrEnum {
	switch error {
	case .UnnamedFields(_, _):
	XCTFail()
	case .NamedFields(let value):
	XCTAssertEqual(value, 1000)
	}
	} catch {
	XCTFail()
	}
	}
	/// Verify that we can return a Result<TransparentEnum, OpaqueRust> from async Rust function
	func testSwiftCallsRustAsyncFnReturnResultTransparentEnumOpaqueRust() async throws {
	//Should return an AsyncResultOkEnum
	do {
	let value: AsyncResultOkEnum = try await rust_async_func_return_result_transparent_enum_and_opaque_rust(true)
	switch value {
	case .NoFields:
	break
	case .UnnamedFields(_, _):
	XCTFail()
	case .NamedFields(let value):
	XCTFail()
	}
	} catch {
	XCTFail()
	}
	//Should throw an AsyncResultOpaqueRustType1
	do {
	let _ = try await rust_async_func_return_result_transparent_enum_and_opaque_rust(false)
	XCTFail()
	} catch let error as AsyncResultOpaqueRustType1 {
	XCTAssertEqual(error.val(), 1000)
	} catch {
	XCTFail()
	}
	}
	/// Verify that we can return a Result<(), TransparentEnum> from async Rust function
	func testSwiftCallsRustAsyncFnReturnResultNullTransparentEnum() async throws {
	//Should return an Unit type
	do {
	let _: () = try await rust_async_func_return_result_null_and_transparent_enum(true)
	} catch {
	XCTFail()
	}
	//Should throw an AsyncResultErrEnum
	do {
	let _ = try await rust_async_func_return_result_null_and_transparent_enum(false)
	XCTFail()
	} catch let error as AsyncResultErrEnum {
	switch error {
	case .UnnamedFields(let valueString, let valueInt32):
	XCTAssertEqual(valueString.toString(), "foo")
	XCTAssertEqual(valueInt32, 123)
	case .NamedFields(_):
	XCTFail()
	}
	} catch {
	XCTFail()
	}
	}
	func testSwiftCallsRustAsyncFnRetStruct() async throws {
	let _: AsyncRustFnReturnStruct = await rust_async_return_struct()
	}
	func testSwiftCallsRustAsyncFnReturnResultNullOpaqueRust() async throws {
	try await rust_async_func_return_result_null_opaque_rust(true)
	do {
	try await rust_async_func_return_result_null_opaque_rust(false)
	XCTFail()
	} catch let error as AsyncResultOpaqueRustType2 {
	XCTAssertEqual(error.val(), 111)
	}
	}
	}

Can take some inspiration from this -> Vec<u8> integration test:

swift-bridge/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/VecTests.swift

Lines 102 to 125 in 93da216

	/// Verify that we can construct a RustVec of every primitive type.
	/// We tested all of the methods on two different primitives above to be sure that our
	/// functions that generate the pieces of the RustVec support aren't accidentally hard coded to
	/// only work for one type.
	/// Here we call the rest of the types, confident that if we can construct them then the rest of their
	/// methods will work since they worked for the other types above.
	func testConstructPrimitiveRustVecs() throws {
	XCTAssertEqual(RustVec<UInt8>().pop(), nil);
	XCTAssertEqual(RustVec<UInt16>().len(), 0);
	XCTAssertEqual(RustVec<UInt32>().len(), 0);
	XCTAssertEqual(RustVec<UInt64>().len(), 0);
	XCTAssertEqual(RustVec<UInt>().len(), 0);
	XCTAssertEqual(RustVec<Int8>().len(), 0);
	XCTAssertEqual(RustVec<Int16>().len(), 0);
	XCTAssertEqual(RustVec<Int32>().len(), 0);
	XCTAssertEqual(RustVec<Int64>().len(), 0);
	XCTAssertEqual(RustVec<Int>().len(), 0);
	XCTAssertEqual(RustVec<Bool>().len(), 0);
	XCTAssertEqual(RustVec<Float>().len(), 0);
	XCTAssertEqual(RustVec<Double>().len(), 0);
	}

---

Here's the contributing guide:

swift-bridge/book/src/contributing/adding-support-for-a-signature/README.md

Lines 1 to 206 in 93da216

	# Adding support for a signature
	Bridge modules expose Rust and Swift functions by declaring their function signatures.
	For example, in the following bridge module we declare one Swift and one Rust function signature.
	```rust
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn add(a: u8, b: u16) -> u32;
	}
	extern "Swift" {
	type Counter;
	fn increment(&mut self);
	}
	}
	```
	Not all signatures are supported. For example, the following would not compile:
	```rust
	// This does not compile
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	async fn print_cow(cow: Cow<'static, str>);
	}
	}
	```
	`swift-bridge` does not currently support the `Cow<'static, str>`, so the `print_cow` function signature is unsupported.
	This chapter shows how to add support for an unsupported signature.
	## Implementing Support for a Signature
	To support a new signature, we first write automated tests for the signature and then implement just enough code to get
	those
	tests passing.
	Add the time of writing, the `Swift` programming language does not have support for 128 bit integers.
	Let's pretend that `Swift` gained support for them and we were tasked with supporting `u128` argument and return types
	in `swift-bridge` function signatures.
	```rust
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	fn reflect_u128(num: u128);
	}
	}
	fn reflect_u128(num: u128) -> num {
	num
	}
	```
	#### Integration Tests
	Our first step would be to add an integration test where we declared this signature in
	a bridge module and called the function from Rust.
	We would first find a good place in `crates/swift-integration-tests` to declare the signature.
	[`crates/swift-integration-tests/src/primitive.rs`](https://github.com/chinedufn/swift-bridge/blob/master/crates/swift-integration-tests/src/primitive.rs)
	would be a good choice.
	Before adding our `u128` support, the file looks like this:
	```rust
	#[swift_bridge::bridge]
	mod ffi {
	extern "Rust" {
	fn test_rust_calls_swift_primitives();
	fn rust_double_u8(arg: u8) -> u8;
	fn rust_double_i8(arg: i8) -> i8;
	fn rust_double_u16(arg: u16) -> u16;
	fn rust_double_i16(arg: i16) -> i16;
	fn rust_double_u32(arg: u32) -> u32;
	// ... snip ...
	```
	Next we would add our `reflect_u128` function to the bridge module.
	We would then modify the `SwiftRustIntegrationTestRunner` to call our function.
	In this case we would want to
	modify [`SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/PrimitiveTests.swift`](https://github.com/chinedufn/swift-bridge/blob/master/SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/PrimitiveTests.swift),
	which before our updates looks something like:
	```swift
	import XCTest
	@testable import SwiftRustIntegrationTestRunner
	/// Tests for generic types such as `type SomeType<u32>`
	class PrimitiveTests: XCTestCase {
	/// Run tests where Rust calls Swift functions that take primitive args.
	func testRustCallsSwiftPrimitives() throws {
	test_rust_calls_swift_primitives()
	}
	/// Run tests where Swift calls Rust functions that take primitive args.
	func testSwiftCallsRustPrimitives() throws {
	XCTAssertEqual(rust_double_u8(10), 20);
	XCTAssertEqual(rust_double_i8(10), 20);
	XCTAssertEqual(rust_double_u16(10), 20);
	XCTAssertEqual(rust_double_i16(10), 20);
	XCTAssertEqual(rust_double_u32(10), 20);
	XCTAssertEqual(rust_double_i32(10), 20);
	XCTAssertEqual(rust_double_u64(10), 20);
	XCTAssertEqual(rust_double_i64(10), 20);
	XCTAssertEqual(rust_double_f32(10.0), 20.0);
	XCTAssertEqual(rust_double_f64(10.0), 20.0);
	XCTAssertEqual(rust_negate_bool(true), false);
	XCTAssertEqual(rust_negate_bool(false), true);
	}
	}
	```
	#### Codegen Tests
	After adding one or more integration tests, we would then add one or more codegen tests.
	Codegen tests live in `crates/swift-bridge-ir/src/codegen/codegen_tests`.
	In codegen tests we write out the exact code that we expect `swift-bridge` to generate.
	For example, here is the codegen test for supporting `Option<u8>` in Rust function arguments.
	```rust
	// Copied from: crates/swift-bridge-ir/src/codegen/codegen_tests/option_codegen_tests.rs
	/// Test code generation for Rust function that accepts and returns an Option<T> where T is a
	/// primitive.
	mod extern_rust_fn_option_primitive {
	use super::*;
	fn bridge_module_tokens() -> TokenStream {
	quote! {
	mod ffi {
	extern "Rust" {
	fn some_function (arg: Option<u8>) -> Option<f32>;
	}
	}
	}
	}
	fn expected_rust_tokens() -> ExpectedRustTokens {
	ExpectedRustTokens::Contains(quote! {
	#[export_name = "__swift_bridge__$some_function"]
	pub extern "C" fn __swift_bridge__some_function(
	arg: swift_bridge::option::OptionU8
	) -> swift_bridge::option::OptionF32 {
	if let Some(val) = super::some_function(
	if arg.is_some {
	Some(arg.val)
	} else {
	None
	}
	) {
	swift_bridge::option::OptionF32 { val, is_some: true}
	} else {
	swift_bridge::option::OptionF32 { val: 123.4, is_some: false}
	}
	}
	})
	}
	fn expected_swift_code() -> ExpectedSwiftCode {
	ExpectedSwiftCode::ContainsAfterTrim(
	r#"
	func some_function(_ arg: Optional<UInt8>) -> Optional<Float> {
	{ let val = __swift_bridge__$some_function({ let val = arg; return __private__OptionU8(val: val ?? 123, is_some: val != nil); }()); if val.is_some { return val.val } else { return nil } }()
	}
	"#,
	)
	}
	const EXPECTED_C_HEADER: ExpectedCHeader = ExpectedCHeader::ExactAfterTrim(
	r#"
	struct __private__OptionF32 __swift_bridge__$some_function(struct __private__OptionU8 arg);
	"#,
	);
	#[test]
	fn extern_rust_fn_option_primitive() {
	CodegenTest {
	bridge_module: bridge_module_tokens().into(),
	expected_rust_tokens: expected_rust_tokens(),
	expected_swift_code: expected_swift_code(),
	expected_c_header: EXPECTED_C_HEADER,
	}
	.test();
	}
	}
	```
	#### Passing Tests
	After writing our integration and codegen tests we would add just enough code to make them pass.
	This would involve modifying `crates/swift-bridge-ir/src/bridged_type.rs` until all of our tests passed.