fix(swift): keep unit enums as raw value, JSON only for tagged enums

The prior fix serialized every enum-typed struct field getter with serde_json,
which broke unit enums: it emitted a JSON-quoted string that Swift's
Type(rawValue:) initializer cannot parse. Branch on enum kind instead — unit
enums (all variants fieldless) keep returning their bare serde raw value via the
bridge wrapper's to_string(), while tagged enums (a variant carries data)
serialize the source value with serde_json::to_string for JSONDecoder. Threads
unit_enum_names through the type-wrapper and getter emitters and covers both
kinds with struct-field getter tests.

Author: Goldziher

CHANGELOG.md

@@ -19,11 +19,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   register/unregister/clear lifecycle calls. The call sites now narrow via `(int) (long)`, matching
   the canonical pattern already used for `last_error_code`.
 
-- **swift**: serialize enum-typed struct field getters to JSON instead of emitting a bare variant
-  name. The discriminant-only bridge wrapper's `.to_string()` dropped the variant payload and
-  returned an unquoted name (e.g. `Text`), which Swift's `JSONDecoder` rejected with "The given data
-  was not valid JSON." Getters now emit `serde_json::to_string` of the source enum value, matching
-  the bidirectional `*_from_json` representation the Swift `Codable` types expect.
+- **swift**: encode enum-typed struct field getters to match how the Swift side decodes each enum
+  kind. Tagged enums (some variant carries data, e.g. `AssistantContent`) are serialized with
+  `serde_json::to_string` of the source value and decoded via `JSONDecoder` — the discriminant-only
+  bridge wrapper's `.to_string()` previously dropped the payload and returned an unquoted name (e.g.
+  `Text`), which `JSONDecoder` rejected with "The given data was not valid JSON." Unit enums (all
+  variants fieldless, e.g. `FinishReason`) keep returning their bare serde raw value via the wrapper's
+  `.to_string()`, which Swift reconstructs with `Type(rawValue:)`; serializing those to JSON would
+  emit a quoted string the rawValue init cannot parse.
 
 - **elixir**: keep async NIF symbols suffixed internally while exposing async free functions under
   their original public names in the high-level Elixir facade. Generated modules now expose

src/backends/swift/gen_rust_crate/mod.rs

@@ -759,6 +759,7 @@ fn emit_lib_rs(
             &source_crate,
             &type_paths,
             &enum_names,
+            &unit_enum_names,
             &no_serde_names,
             exclude_fields,
             configured_features,

src/backends/swift/gen_rust_crate/wrappers/constructors.rs

@@ -20,11 +20,13 @@ use std::collections::{HashMap, HashSet};
 
 use super::getters::emit_getters;
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn emit_type_wrapper(
     ty: &TypeDef,
     source_crate: &str,
     type_paths: &HashMap<String, String>,
     enum_names: &HashSet<&str>,
+    unit_enum_names: &HashSet<&str>,
     no_serde_names: &HashSet<&str>,
     exclude_fields: &HashSet<String>,
     configured_features: &HashSet<&str>,
@@ -153,6 +155,7 @@ pub(crate) fn emit_type_wrapper(
             ty,
             type_paths,
             enum_names,
+            unit_enum_names,
             no_serde_names,
             exclude_fields,
             configured_features,
@@ -302,6 +305,7 @@ mod tests {
             &std::collections::HashMap::new(),
             &std::collections::HashSet::new(),
             &std::collections::HashSet::new(),
+            &std::collections::HashSet::new(),
             &exclude_fields,
             &configured_features,
         );

src/backends/swift/gen_rust_crate/wrappers/getters.rs

@@ -93,10 +93,12 @@ struct GetterCtx {
 }
 
 /// Emit getter methods for all fields of a type wrapper.
+#[allow(clippy::too_many_arguments)]
 pub(super) fn emit_getters(
     ty: &TypeDef,
     type_paths: &HashMap<String, String>,
     enum_names: &HashSet<&str>,
+    unit_enum_names: &HashSet<&str>,
     no_serde_names: &HashSet<&str>,
     exclude_fields: &HashSet<String>,
     configured_features: &std::collections::HashSet<&str>,
@@ -162,16 +164,19 @@ pub(super) fn emit_getters(
                 },
             ));
         } else if is_enum_named(&field.ty, enum_names) {
-            // Enum-typed Named field: return the serde-JSON encoding of the source enum
-            // value as a String. The opaque enum type is NOT declared in the extern block
-            // (see extern_block.rs), so we must not return the wrapper type here; and the
-            // discriminant-only wrapper would lose the variant payload, so serialize the
-            // original value instead. The Swift side JSON-decodes this back into its Codable
-            // enum (matching the bidirectional `*_from_json` representation).
-            emit_enum_string_getter(field, &ctx, enum_names, out);
+            // Enum-typed Named field: return the enum as a String. The opaque enum type is
+            // NOT declared in the extern block (see extern_block.rs), so we must not return
+            // the wrapper type here. Unit enums (all variants fieldless) serialize to their
+            // bare serde raw value via the wrapper's `to_string()`, which Swift reconstructs
+            // with `Type(rawValue:)`. Tagged enums (variants carry data) cannot use the
+            // discriminant-only wrapper — it drops the payload — so the source value is
+            // serialized with `serde_json::to_string`, which Swift decodes via `JSONDecoder`
+            // (matching the bidirectional `*_from_json` representation).
+            emit_enum_string_getter(field, &ctx, enum_names, unit_enum_names, out);
         } else if is_vec_of_enum(&field.ty, enum_names) {
-            // Vec<Named(enum)>: map each element to String via to_string().
-            emit_vec_enum_string_getter(field, &ctx, enum_names, out);
+            // Vec<Named(enum)>: map each element to a String (raw value for unit enums,
+            // serde-JSON for tagged enums — see emit_enum_string_getter).
+            emit_vec_enum_string_getter(field, &ctx, enum_names, unit_enum_names, out);
         } else if let TypeRef::Named(wrapper) = &field.ty {
             emit_named_getter(field, wrapper, &ctx, enum_names, out);
         } else if let TypeRef::Vec(inner) = &field.ty {
@@ -257,29 +262,42 @@ pub(super) fn emit_getters(
 
 /// Emit a `String`-returning getter for an enum-typed `Named` field.
 ///
-/// Instead of returning the opaque enum wrapper (which would trigger swift-bridge's
-/// `Vec<EnumType> Vectorizable` generation), this serializes the source enum value to
-/// JSON via `serde_json::to_string`. The discriminant-only bridge wrapper drops the
-/// variant payload and its `.to_string()` emits a bare variant name (invalid JSON), so
-/// the original value must be serialized for the Swift `JSONDecoder` to reconstruct it.
+/// Returns the opaque enum as a `String` (avoids swift-bridge's `Vec<EnumType>
+/// Vectorizable` generation). The encoding depends on the enum kind:
+/// - Unit enums (all variants fieldless): the bridge wrapper's `to_string()` yields the
+///   bare serde raw value (e.g. `stop`), which Swift reconstructs via `Type(rawValue:)`.
+/// - Tagged enums (some variant carries data): the discriminant-only wrapper drops the
+///   payload, so the source value is serialized with `serde_json::to_string` and Swift
+///   decodes it via `JSONDecoder` (matching the bidirectional `*_from_json` representation).
 fn emit_enum_string_getter(
     field: &crate::core::ir::FieldDef,
     ctx: &GetterCtx,
     enum_names: &HashSet<&str>,
+    unit_enum_names: &HashSet<&str>,
     out: &mut String,
 ) {
     let TypeRef::Named(wrapper) = &field.ty else {
         return;
     };
     let is_enum = enum_names.contains(wrapper.as_str());
     debug_assert!(is_enum, "emit_enum_string_getter called with non-enum Named type");
+    let is_unit = unit_enum_names.contains(wrapper.as_str());
 
     let name = &ctx.name;
     let getter_name = &ctx.getter_name;
 
     if field.optional {
-        // Option<EnumType> → Option<String>. Boxed and Arc fields both deref to the enum via `&*w`.
-        let map_expr = if field.is_boxed || matches!(field.core_wrapper, CoreWrapper::Arc) {
+        // Option<EnumType> → Option<String>.
+        let map_expr = if is_unit {
+            if field.is_boxed {
+                format!("self.0.{name}.clone().map(|w| {wrapper}::from(*w).to_string())")
+            } else if matches!(field.core_wrapper, CoreWrapper::Arc) {
+                format!("self.0.{name}.clone().map(|w| {wrapper}::from((*w).clone()).to_string())")
+            } else {
+                format!("self.0.{name}.clone().map(|w| {wrapper}::from(w).to_string())")
+            }
+        } else if field.is_boxed || matches!(field.core_wrapper, CoreWrapper::Arc) {
+            // Tagged enum: serialize the source value. Boxed and Arc both deref via `&*w`.
             format!(
                 "self.0.{name}.clone().map(|w| serde_json::to_string(&*w).unwrap_or_else(|_| \"null\".to_string()))"
             )
@@ -294,8 +312,17 @@ fn emit_enum_string_getter(
             },
         ));
     } else {
-        // EnumType → String. Boxed and Arc fields both deref to the enum via `&*self.0.{name}`.
-        let expr = if field.is_boxed || matches!(field.core_wrapper, CoreWrapper::Arc) {
+        // EnumType → String.
+        let expr = if is_unit {
+            if field.is_boxed {
+                format!("{wrapper}::from(*self.0.{name}.clone()).to_string()")
+            } else if matches!(field.core_wrapper, CoreWrapper::Arc) {
+                format!("{wrapper}::from((*self.0.{name}).clone()).to_string()")
+            } else {
+                format!("{wrapper}::from(self.0.{name}.clone()).to_string()")
+            }
+        } else if field.is_boxed || matches!(field.core_wrapper, CoreWrapper::Arc) {
+            // Tagged enum: serialize the source value. Boxed and Arc both deref via `&*self.0.{name}`.
             format!("serde_json::to_string(&*self.0.{name}).unwrap_or_else(|_| \"null\".to_string())")
         } else {
             format!("serde_json::to_string(&self.0.{name}).unwrap_or_else(|_| \"null\".to_string())")
@@ -312,11 +339,14 @@ fn emit_enum_string_getter(
 
 /// Emit a `Vec<String>`-returning getter for a `Vec<Named(enum)>` field.
 ///
-/// Maps each enum element to its serde-JSON encoding via `serde_json::to_string`.
+/// Maps each enum element to a `String`: the bridge wrapper's `to_string()` raw value for
+/// unit enums, or `serde_json::to_string` of the source value for tagged enums (see
+/// `emit_enum_string_getter` for the encoding rationale).
 fn emit_vec_enum_string_getter(
     field: &crate::core::ir::FieldDef,
     ctx: &GetterCtx,
     enum_names: &HashSet<&str>,
+    unit_enum_names: &HashSet<&str>,
     out: &mut String,
 ) {
     let TypeRef::Vec(inner) = &field.ty else {
@@ -327,14 +357,22 @@ fn emit_vec_enum_string_getter(
     };
     let is_enum = enum_names.contains(wrapper.as_str());
     debug_assert!(is_enum, "emit_vec_enum_string_getter called with non-enum Vec<Named>");
+    let is_unit = unit_enum_names.contains(wrapper.as_str());
 
     let name = &ctx.name;
     let getter_name = &ctx.getter_name;
 
-    // Build the per-element mapping expression based on wrapping strategy.
-    let elem_expr = match field.vec_inner_core_wrapper {
-        CoreWrapper::Arc => "serde_json::to_string(&**elem).unwrap_or_else(|_| \"null\".to_string())".to_string(),
-        _ => "serde_json::to_string(elem).unwrap_or_else(|_| \"null\".to_string())".to_string(),
+    // Build the per-element mapping expression based on enum kind and wrapping strategy.
+    let elem_expr = if is_unit {
+        match field.vec_inner_core_wrapper {
+            CoreWrapper::Arc => format!("{wrapper}::from((**elem).clone()).to_string()"),
+            _ => format!("{wrapper}::from(elem.clone()).to_string()"),
+        }
+    } else {
+        match field.vec_inner_core_wrapper {
+            CoreWrapper::Arc => "serde_json::to_string(&**elem).unwrap_or_else(|_| \"null\".to_string())".to_string(),
+            _ => "serde_json::to_string(elem).unwrap_or_else(|_| \"null\".to_string())".to_string(),
+        }
     };
 
     if field.optional {

tests/backends_swift_gen_rust_crate_test.rs

@@ -750,10 +750,10 @@ fn lib_rs_enum_extern_block_and_wrapper() {
 
 #[test]
 fn lib_rs_struct_with_enum_field_returns_string() {
-    // A struct with an enum-typed field must have that getter return `String`,
+    // A struct with a UNIT enum-typed field must have that getter return `String`,
     // not the opaque enum wrapper type. The extern block must declare `fn foo(&self) -> String`
-    // (not `fn foo(&self) -> Status`), and the wrapper impl must serialize the enum to JSON via
-    // serde_json::to_string so the Swift side can decode the variant payload.
+    // (not `fn foo(&self) -> Status`), and the wrapper impl must emit the bare serde raw value
+    // via `Status::from(...).to_string()` (Swift reconstructs it with `Type(rawValue:)`).
     let api = ApiSurface {
         crate_name: "demo".into(),
         version: "0.1.0".into(),
@@ -781,10 +781,10 @@ fn lib_rs_struct_with_enum_field_returns_string() {
         "extern block must declare status() -> String, not the opaque enum type: {}",
         lib.content
     );
-    // Wrapper impl must serialize the enum to JSON instead of emitting a bare variant name.
+    // Unit-enum wrapper impl must convert to String via Status::from(...).to_string().
     assert!(
-        lib.content.contains("serde_json::to_string(&self.0.status)"),
-        "wrapper impl must serialize the enum field via serde_json::to_string: {}",
+        lib.content.contains("Status::from(") && lib.content.contains(".to_string()"),
+        "wrapper impl must call Status::from(...).to_string(): {}",
         lib.content
     );
     // Opaque enum type IS declared in its own extern block (required for parameter usage).
@@ -796,6 +796,81 @@ fn lib_rs_struct_with_enum_field_returns_string() {
     );
 }
 
+#[test]
+fn lib_rs_struct_with_tagged_enum_field_serializes_to_json() {
+    // A struct with a TAGGED enum field (at least one variant carries data) must serialize the
+    // getter to JSON via serde_json::to_string. The discriminant-only bridge wrapper drops the
+    // variant payload, so its to_string() would emit an invalid bare name; Swift decodes the
+    // JSON back via JSONDecoder (matching the bidirectional `*_from_json` representation).
+    let payload = EnumDef {
+        name: "Payload".to_string(),
+        rust_path: "demo::Payload".to_string(),
+        original_rust_path: String::new(),
+        variants: vec![EnumVariant {
+            name: "Text".to_string(),
+            fields: vec![make_field("value", TypeRef::String)],
+            doc: String::new(),
+            is_default: false,
+            serde_rename: None,
+            binding_excluded: false,
+            binding_exclusion_reason: None,
+            is_tuple: false,
+            originally_had_data_fields: true,
+            cfg: None,
+            version: Default::default(),
+        }],
+        methods: vec![],
+        doc: String::new(),
+        cfg: None,
+        serde_tag: Some("type".to_string()),
+        serde_untagged: false,
+        serde_rename_all: None,
+        is_copy: false,
+        has_serde: true,
+        binding_excluded: false,
+        binding_exclusion_reason: None,
+        excluded_variants: vec![],
+        version: Default::default(),
+        has_default: false,
+    };
+    let api = ApiSurface {
+        crate_name: "demo".into(),
+        version: "0.1.0".into(),
+        types: vec![{
+            let mut t = make_type(
+                "Item",
+                vec![make_field("payload", TypeRef::Named("Payload".to_string()))],
+            );
+            t.has_serde = true;
+            t
+        }],
+        functions: vec![],
+        enums: vec![payload],
+        errors: vec![],
+        excluded_type_paths: ::std::collections::HashMap::new(),
+        excluded_trait_names: ::std::collections::HashSet::new(),
+        services: vec![],
+        handler_contracts: vec![],
+        unsupported_public_items: Vec::new(),
+    };
+
+    let files = gen_rust_crate::emit(&api, &make_config()).unwrap();
+    let lib = files.iter().find(|f| f.path.ends_with("lib.rs")).unwrap();
+
+    // Getter must be declared as String in the extern block.
+    assert!(
+        lib.content.contains("fn payload(&self) -> String;"),
+        "extern block must declare payload() -> String: {}",
+        lib.content
+    );
+    // Tagged enum must serialize via serde_json::to_string, NOT the discriminant wrapper to_string().
+    assert!(
+        lib.content.contains("serde_json::to_string(&self.0.payload)"),
+        "tagged-enum getter must serialize via serde_json::to_string: {}",
+        lib.content
+    );
+}
+
 // ── trait bridge tests ────────────────────────────────────────────────────────
 
 fn make_method(