Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Support Option<OpaqueSwiftType> #272

Merged
merged 2 commits into from
Apr 28, 2024
Merged

Support Option<OpaqueSwiftType> #272

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
235c460
Support Option<OpaqueSwiftType>
Bright-Shard Apr 28, 2024
db71f4e
PR feedback & fix tests
Bright-Shard Apr 28, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 7 additions & 1 deletion SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunner/Option.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,6 +63,12 @@ func swift_arg_option_str(arg: Optional<RustStr>) -> Bool {
} else {
return false
}

}

public class OptTestOpaqueSwiftType {
let val: Int

init(val: Int) {
self.val = val
}
}
74 changes: 41 additions & 33 deletions SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/OptionTests.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,34 +15,34 @@ class OptionTests: XCTestCase {
func testSwiftCallRustOptionPrimitive() throws {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Autoformatting did something to the spacing in this whole file... I'll leave a comment where I actually made changes

XCTAssertEqual(rust_reflect_option_u8(70), 70)
XCTAssertEqual(rust_reflect_option_u8(nil), nil)

XCTAssertEqual(rust_reflect_option_i8(70), 70)
XCTAssertEqual(rust_reflect_option_i8(nil), nil)

XCTAssertEqual(rust_reflect_option_u16(70), 70)
XCTAssertEqual(rust_reflect_option_u16(nil), nil)

XCTAssertEqual(rust_reflect_option_i16(70), 70)
XCTAssertEqual(rust_reflect_option_i16(nil), nil)

XCTAssertEqual(rust_reflect_option_u32(70), 70)
XCTAssertEqual(rust_reflect_option_u32(nil), nil)

XCTAssertEqual(rust_reflect_option_i32(70), 70)
XCTAssertEqual(rust_reflect_option_i32(nil), nil)

XCTAssertEqual(rust_reflect_option_u64(70), 70)
XCTAssertEqual(rust_reflect_option_u64(nil), nil)

XCTAssertEqual(rust_reflect_option_i64(70), 70)
XCTAssertEqual(rust_reflect_option_i64(nil), nil)

XCTAssertEqual(rust_reflect_option_f32(70.0), 70.0)
XCTAssertEqual(rust_reflect_option_f32(nil), nil)

XCTAssertEqual(rust_reflect_option_f64(70.0), 70.0)
XCTAssertEqual(rust_reflect_option_f64(nil), nil)

XCTAssertEqual(rust_reflect_option_bool(true), true)
XCTAssertEqual(rust_reflect_option_bool(false), false)
XCTAssertEqual(rust_reflect_option_bool(nil), nil)
Expand All @@ -52,30 +52,30 @@ class OptionTests: XCTestCase {
func testRustCallSwiftOptionPrimitive() throws {
test_rust_calls_swift_option_primitive()
}

/// Verify that Swift can call a Rust function that accepts and returns an Option<T>
/// where T is a String.
func testSwiftCallRustReturnOptionString() throws {
let string = rust_reflect_option_string("hello world")
XCTAssertEqual(string!.toString(), "hello world")

let none: String? = nil
XCTAssertNil(rust_reflect_option_string(none))
}

/// We use an `Option<&'static str>` that we create on the Rust side so that
/// we don't run into any lifetime issues.
func testSwiftCallRustReturnOptionStr() throws {
let str = rust_create_option_static_str()
XCTAssertEqual(str!.toString(), "hello")

let reflected = rust_reflect_option_str(str)
XCTAssertEqual(reflected!.toString(), "hello")

let none: RustStr? = nil
XCTAssertNil(rust_reflect_option_str(none))
}

func testSwiftCallRustWithOptionVecOfPrimitiveType() throws {
let vec = RustVec<UInt16>()
vec.push(value: 123)
Expand All @@ -89,15 +89,24 @@ class OptionTests: XCTestCase {

XCTAssertNil(rust_reflect_option_vector_rust_type(nil))
}

func testSwiftCallRustWithOptionOpaqueRustType() throws {
let val = OptTestOpaqueRustType(123)
let reflect = rust_reflect_option_opaque_rust_type(val)
XCTAssertEqual(reflect!.field(), 123)

XCTAssertNil(rust_reflect_option_opaque_rust_type(nil))
}

/// Verify that we can bridge options of opaque Swift types.
func testSwiftCallRustWithOptionOpaqueSwiftType() throws {
let val = OptTestOpaqueSwiftType(val: 727)
let reflect = rust_reflect_option_opaque_swift_type(val)
XCTAssertEqual(reflect!.val, 727)

XCTAssertNil(rust_reflect_option_opaque_swift_type(nil))
}

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actual changes are here

/// Verify that we can pass and receive an `Option<&RustType>`.
///
/// We deinitialize the first reference and create a second to confirm that
Expand All @@ -110,39 +119,39 @@ class OptionTests: XCTestCase {
XCTAssertEqual(reflect!.field(), 123)
XCTAssertNil(rust_reflect_option_ref_opaque_rust_type(nil))
reflect = nil

reflect = rust_reflect_option_ref_opaque_rust_type(opt_ref)
XCTAssertEqual(reflect!.field(), 123)
}

func testSwiftCallRustWithOptionOpaqueRustCopyType() throws {
let val = new_opaque_rust_copy_type(123)
let _: OptTestOpaqueRustCopyType? = rust_reflect_option_opaque_rust_copy_type(val)

// TODO: Support methods on generic types
// XCTAssertEqual(reflect!.field(), 123)
XCTAssertNil(rust_reflect_option_opaque_rust_copy_type(nil))
}

func testSwiftCallRustWithOptionGenericOpaqueRustType() throws {
let val = new_generic_opaque_rust_type(123)
let _: OptTestGenericOpaqueRustType<UInt8>? = rust_reflect_option_generic_opaque_rust_type(val)

// TODO: Support methods on generic types
// XCTAssertEqual(reflect!.field(), 123)
XCTAssertNil(rust_reflect_option_opaque_rust_type(nil))
}

func testSwiftCallRustWithOptionGenericOpaqueRustCopyType() throws {
let val = new_generic_opaque_rust_copy_type(123)
let _: OptTestGenericOpaqueRustCopyType? = rust_reflect_option_generic_opaque_rust_copy_type(val)

// TODO: Support methods on generic types
// XCTAssertEqual(reflect!.field(), 123)
XCTAssertNil(rust_reflect_option_generic_opaque_rust_copy_type(nil))
}


func testStructWithOptionFieldsSome() throws {
let val = StructWithOptionFields(
u8: 123, i8: 123, u16: 123, i16: 123,
Expand All @@ -165,7 +174,7 @@ class OptionTests: XCTestCase {
XCTAssertEqual(reflected.f64, 123.4)
XCTAssertEqual(reflected.boolean, true)
}

func testStructWithOptionFieldsNone() {
let val = StructWithOptionFields(
u8: nil, i8: nil, u16: nil, i16: nil,
Expand All @@ -187,29 +196,28 @@ class OptionTests: XCTestCase {
XCTAssertEqual(reflected.f64, nil)
XCTAssertEqual(reflected.boolean, nil)
}

func testEnumWhereVariantsHaveNoData() {
let val = OptionEnumWithNoData.Variant2
let reflectedSome = rust_reflect_option_enum_with_no_data(val)
let reflectedNone = rust_reflect_option_enum_with_no_data(nil)

switch reflectedSome! {
case .Variant2:
break;
default:
XCTFail()
}

XCTAssertNil(reflectedNone)
}

func testOptionStruct() {
let val = OptionStruct(field: 123)
let reflectedSome = rust_reflect_option_struct_with_no_data(val)
let reflectedNone = rust_reflect_option_struct_with_no_data(nil)

XCTAssertEqual(reflectedSome!.field, 123)
XCTAssertNil(reflectedNone)
}
}

2 changes: 1 addition & 1 deletion crates/swift-bridge-ir/src/bridged_type.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1499,7 +1499,7 @@ impl BridgedType {
//
// Say we have an extern Rust function `create_string(str: &str) -> String`.
// It would be called using `__swift_bridge__$create_string(str)`
// But that would return a pointer to a swift_bridge::RustString.. So we need to convert that
// But that would return a pointer to a swift_bridge::RustString. So we need to convert that
// to something Swift can make use of.
// The final result on the Swift side would be:
//
Expand Down
78 changes: 62 additions & 16 deletions crates/swift-bridge-ir/src/bridged_type/bridged_opaque_type.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -311,11 +311,24 @@ impl BridgeableType for OpaqueForeignType {
}
}
} else {
quote! {
if let Some(val) = #expression {
Box::into_raw(Box::new(val))
} else {
std::ptr::null_mut()
match self.host_lang {
HostLang::Rust => {
quote! {
if let Some(val) = #expression {
Box::into_raw(Box::new(val))
} else {
std::ptr::null_mut()
}
}
}
HostLang::Swift => {
quote! {
if let Some(val) = #expression {
val.0.cast()
} else {
std::ptr::null_mut()
}
}
}
}
}
Expand Down Expand Up @@ -414,7 +427,14 @@ impl BridgeableType for OpaqueForeignType {
expression = expression,
)
} else {
format!("{{ if let val = {expression} {{ val.isOwned = false; return val.ptr }} else {{ return nil }} }}()", expression = expression,)
match self.host_lang {
HostLang::Rust => {
format!("{{ if let val = {expression} {{ val.isOwned = false; return val.ptr }} else {{ return nil }} }}()", expression = expression,)
}
HostLang::Swift => {
format!("{{ if let val = {expression} {{ return Unmanaged.passRetained(val).retain().toOpaque() }} else {{ return nil }} }}()")
}
}
}
}

Expand Down Expand Up @@ -479,11 +499,28 @@ impl BridgeableType for OpaqueForeignType {
}
}
} else {
quote! {
if #expression.is_null() {
None
} else {
Some(unsafe { * Box::from_raw(#expression) } )
match self.host_lang {
HostLang::Rust => {
quote! {
if #expression.is_null() {
None
} else {
Some(unsafe { *Box::from_raw(#expression) } )
}
}
}
HostLang::Swift => {
let ty = &self.ty;
quote! {
{
let val = #expression;
if val.is_null() {
None
} else {
Some(#ty(val.cast()))
}
}
}
}
}
}
Expand Down Expand Up @@ -545,11 +582,20 @@ impl BridgeableType for OpaqueForeignType {
)
} else {
let type_name = self.swift_name();
format!(
"{{ let val = {expression}; if val != nil {{ return {type_name}(ptr: val!) }} else {{ return nil }} }}()",
expression = expression,
type_name = type_name
)
match self.host_lang {
HostLang::Rust => {
format!(
"{{ let val = {expression}; if val != nil {{ return {type_name}(ptr: val!) }} else {{ return nil }} }}()",
expression = expression,
type_name = type_name
)
}
HostLang::Swift => {
format!(
"{{ if let val = {expression} {{ return Unmanaged<{type_name}>.fromOpaque(val).takeRetainedValue() }} else {{ return nil }} }}()"
)
}
}
}
}

Expand Down
1 change: 0 additions & 1 deletion crates/swift-bridge-ir/src/codegen/codegen_tests.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,7 +39,6 @@ mod derive_struct_attribute_codegen_tests;
mod extern_rust_function_opaque_rust_type_argument_codegen_tests;
mod extern_rust_function_opaque_rust_type_return_codegen_tests;
mod extern_rust_method_swift_class_placement_codegen_tests;
mod extern_swift_function_opaque_swift_type_return_codegen_tests;
mod function_attribute_codegen_tests;
mod generic_opaque_rust_type_codegen_tests;
mod opaque_rust_type_codegen_tests;
Expand Down
Loading
Loading