Support Option<String> fields in shared structs (#354)

Adds support for Option<String> fields in shared structs.

## Example

```rust
// rust
#[swift_bridge::bridge]
mod ffi {
    #[swift_bridge(swift_repr = "struct")]
    struct UserProfile {
        name: String,
        bio: Option<String>,  // Now supported!
    }

    extern "Rust" {
        fn create_profile(name: String, bio: Option<String>) -> UserProfile;
    }
}
```

```swift
// swift
// Create with Some value
let profileWithBio = UserProfile(
    name: "Alice".intoRustString(),
    bio: "Hello world!".intoRustString()
)

// Create with None value  
let profileWithoutBio = UserProfile(
    name: "Bob".intoRustString(),
    bio: nil
)

// Access optional field
if let bio = profileWithBio.bio {
    print("Bio: \(bio.toString())")
}
```

Author: Choochmeque

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/OptionTests.swift

@@ -157,7 +157,7 @@ class OptionTests: XCTestCase {
             u8: 123, i8: 123, u16: 123, i16: 123,
             u32: 123, i32: 123, u64: 123, i64: 123,
             usize: 123, isize: 123, f32: 123.4, f64: 123.4,
-            boolean: true
+            boolean: true, string: "hello".intoRustString()
         )
         let reflected = rust_reflect_struct_with_option_fields(val)
         XCTAssertEqual(reflected.u8, 123)
@@ -173,14 +173,15 @@ class OptionTests: XCTestCase {
         XCTAssertEqual(reflected.f32, 123.4)
         XCTAssertEqual(reflected.f64, 123.4)
         XCTAssertEqual(reflected.boolean, true)
+        XCTAssertEqual(reflected.string!.toString(), "hello")
     }
 
     func testStructWithOptionFieldsNone() {
         let val = StructWithOptionFields(
             u8: nil, i8: nil, u16: nil, i16: nil,
             u32: nil, i32: nil, u64: nil, i64: nil,
             usize: nil, isize: nil, f32: nil, f64: nil,
-            boolean: nil
+            boolean: nil, string: nil
         )
         let reflected = rust_reflect_struct_with_option_fields(val)
         XCTAssertEqual(reflected.i8, nil)
@@ -195,6 +196,7 @@ class OptionTests: XCTestCase {
         XCTAssertEqual(reflected.f32, nil)
         XCTAssertEqual(reflected.f64, nil)
         XCTAssertEqual(reflected.boolean, nil)
+        XCTAssertNil(reflected.string)
     }
 
     func testEnumWhereVariantsHaveNoData() {

crates/swift-bridge-ir/src/bridged_type/bridgeable_string.rs

@@ -27,7 +27,7 @@ impl BridgeableType for BridgedString {
     }
 
     fn as_option(&self) -> Option<&super::bridged_option::BridgedOption> {
-        todo!()
+        None
     }
 
     fn is_passed_via_pointer(&self) -> bool {
@@ -123,9 +123,7 @@ impl BridgeableType for BridgedString {
                     "UnsafeMutableRawPointer?".to_string()
                 }
             }
-            TypePosition::SharedStructField => {
-                todo!()
-            }
+            TypePosition::SharedStructField => "UnsafeMutableRawPointer?".to_string(),
             TypePosition::ResultFfiReturnType => {
                 todo!()
             }
@@ -200,7 +198,10 @@ impl BridgeableType for BridgedString {
                 }
             }
             TypePosition::SharedStructField => {
-                todo!("Option<String> fields in structs are not yet supported.")
+                format!(
+                    "{{ if let rustString = optionalStringIntoRustString({expression}) {{ rustString.isOwned = false; return rustString.ptr }} else {{ return nil }} }}()",
+                    expression = expression
+                )
             }
             TypePosition::ResultFfiReturnType => {
                 unimplemented!()
@@ -290,10 +291,7 @@ impl BridgeableType for BridgedString {
             rust: quote! {
                 std::ptr::null::<#swift_bridge_path::string::RustString>() as *mut #swift_bridge_path::string::RustString
             },
-            // TODO: Add integration tests:
-            //  Rust: crates/swift-integration-tests/src/option.rs
-            //  Swift: OptionTests.swift
-            swift: "TODO_SWIFT_OPTIONAL_STRING_SUPPORT".to_string(),
+            swift: "nil".to_string(),
         }
     }
 

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

@@ -1475,3 +1475,112 @@ typedef struct __swift_bridge__$SomeStruct { struct __private__OptionU8 field; }
         .test();
     }
 }
+
+/// Test conversion to and from the FFI representation of a struct that contains Option<String> fields.
+mod shared_struct_with_option_string_field_ffi_repr {
+    use super::*;
+
+    fn bridge_module_tokens() -> TokenStream {
+        quote! {
+            mod ffi {
+                struct SomeStruct {
+                    field: Option<String>
+                }
+            }
+        }
+    }
+
+    fn expected_rust_tokens() -> ExpectedRustTokens {
+        ExpectedRustTokens::ContainsMany(vec![
+            quote! {
+                pub struct __swift_bridge__SomeStruct {
+                    field: *mut swift_bridge::string::RustString
+                }
+            },
+            quote! {
+                impl SomeStruct {
+                    #[doc(hidden)]
+                    #[inline(always)]
+                    pub fn into_ffi_repr(self) -> __swift_bridge__SomeStruct {
+                        {
+                            let val = self;
+                            __swift_bridge__SomeStruct {
+                                field: if let Some(val) = val.field {
+                                    swift_bridge::string::RustString(val).box_into_raw()
+                                } else {
+                                    std::ptr::null::<swift_bridge::string::RustString>() as *mut swift_bridge::string::RustString
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            quote! {
+                impl __swift_bridge__SomeStruct {
+                    #[doc(hidden)]
+                    #[inline(always)]
+                    pub fn into_rust_repr(self) -> SomeStruct {
+                         {
+                            let val = self;
+                            SomeStruct {
+                                field: {
+                                    let val = val.field;
+
+                                    if val.is_null() {
+                                        None
+                                    } else {
+                                        Some( unsafe { Box::from_raw(val).0 } )
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        ])
+    }
+
+    fn expected_swift_code() -> ExpectedSwiftCode {
+        ExpectedSwiftCode::ContainsAfterTrim(
+            r#"
+public struct SomeStruct {
+    public var field: Optional<RustString>
+
+    public init(field: Optional<RustString>) {
+        self.field = field
+    }
+
+    @inline(__always)
+    func intoFfiRepr() -> __swift_bridge__$SomeStruct {
+        { let val = self; return __swift_bridge__$SomeStruct(field: { if let rustString = optionalStringIntoRustString(val.field) { rustString.isOwned = false; return rustString.ptr } else { return nil } }()); }()
+    }
+}
+extension __swift_bridge__$SomeStruct {
+    @inline(__always)
+    func intoSwiftRepr() -> SomeStruct {
+        { let val = self; return SomeStruct(field: { let val = val.field; if val != nil { return RustString(ptr: val!) } else { return nil } }()); }()
+    }
+}
+"#,
+        )
+    }
+
+    fn expected_c_header() -> ExpectedCHeader {
+        ExpectedCHeader::ContainsAfterTrim(
+            r#"
+typedef struct __swift_bridge__$SomeStruct { void* field; } __swift_bridge__$SomeStruct;
+    "#,
+        )
+    }
+
+    #[test]
+    fn shared_struct_with_option_string_field_ffi_repr() {
+        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();
+    }
+}

crates/swift-integration-tests/src/option.rs

@@ -19,8 +19,8 @@ mod ffi {
         f32: Option<f32>,
         f64: Option<f64>,
         boolean: Option<bool>,
-        // TODO: Support test more types:
-        // string: Option<String>,
+        string: Option<String>,
+        // TODO: Support more types:
         // str: Option<&'static str>,
     }