fix(alef-backend-swift): call .intoRust() on first-class DTO args at call sites

Author: Goldziher

crates/alef-backend-swift/src/gen_bindings.rs

@@ -854,10 +854,27 @@ fn emit_client_class(
         let params_str = params.join(", ");
 
         // Build argument list for forwarding to the bridge function.
+        // When a parameter type is a first-class Swift DTO (i.e. has `intoRust()`
+        // emitted), the bridge function expects the raw `RustBridge.T` type, not
+        // the Swift wrapper `T`.  Apply `.intoRust()` at the call site.
+        // `intoRust()` is `throws`, so track whether any conversion is needed so we
+        // can add `throws` to the method signature even when `error_type` is `None`.
+        let has_dto_param = method
+            .params
+            .iter()
+            .any(|p| matches!(&p.ty, TypeRef::Named(n) if first_class_types.contains(n)));
         let args: Vec<String> = method
             .params
             .iter()
-            .map(|p| swift_ident(&p.name.to_lower_camel_case()))
+            .map(|p| {
+                let swift_name = swift_ident(&p.name.to_lower_camel_case());
+                match &p.ty {
+                    TypeRef::Named(n) if first_class_types.contains(n) => {
+                        format!("try {swift_name}.intoRust()")
+                    }
+                    _ => swift_name,
+                }
+            })
             .collect();
         let args_str = if args.is_empty() {
             String::new()
@@ -866,7 +883,8 @@ fn emit_client_class(
         };
 
         let return_ty = mapper.map_type(&method.return_type);
-        let throws_clause = if method.error_type.is_some() { " throws" } else { "" };
+        let needs_throws = method.error_type.is_some() || has_dto_param;
+        let throws_clause = if needs_throws { " throws" } else { "" };
         let async_clause = if method.is_async { " async" } else { "" };
         let return_clause = if matches!(method.return_type, TypeRef::Unit) {
             String::new()
@@ -883,11 +901,11 @@ fn emit_client_class(
         if matches!(method.return_type, TypeRef::Unit) {
             out.push_str(&format!(
                 "        {throws_kw}RustBridge.{bridge_fn_camel}(self.inner{args_str})\n",
-                throws_kw = if method.error_type.is_some() { "try " } else { "" }
+                throws_kw = if needs_throws { "try " } else { "" }
             ));
         } else {
             let await_kw = if method.is_async { "await " } else { "" };
-            let try_kw = if method.error_type.is_some() { "try " } else { "" };
+            let try_kw = if needs_throws { "try " } else { "" };
             // swift-bridge bridges `Vec<u8>` as `RustVec<UInt8>` on the Swift side.
             // The host wrapper exposes `Data` (per `SwiftMapper::bytes()`) — convert
             // by iterating the RustVec into a Swift array, then wrapping in `Data`.

crates/alef-backend-swift/tests/gen_bindings_test.rs

@@ -1497,6 +1497,215 @@ client_constructor_body.Client = "Self { inner: ::demo::Client::new(api_key, bas
     );
 }
 
+// ── first-class DTO call-site conversion tests ───────────────────────────────
+
+/// When a method on an opaque client class takes a first-class Swift DTO as a
+/// parameter, the generated call site must apply `.intoRust()` to convert the
+/// Swift wrapper into the `RustBridge.T` raw type that the bridge function
+/// expects.  Without this conversion the Swift compiler rejects the call with
+/// "cannot convert value of type 'LiterLlm.T' to expected argument type
+/// 'RustBridge.T'".
+///
+/// The method signature must also carry `throws` because `intoRust()` is itself
+/// a throwing function.
+#[test]
+fn method_with_first_class_dto_param_calls_into_rust_at_call_site() {
+    use alef_core::ir::{MethodDef, ReceiverKind};
+
+    // CreateImageRequest: first-class DTO with has_serde + has_default + string fields.
+    let mut request_type = make_type(
+        "CreateImageRequest",
+        vec![
+            make_field("prompt", TypeRef::String, false),
+            make_field("model", TypeRef::Optional(Box::new(TypeRef::String)), true),
+        ],
+    );
+    request_type.has_serde = true;
+    request_type.has_default = true;
+
+    // ImageClient: opaque type with `generateImage(_ request: CreateImageRequest)`.
+    let client_type = TypeDef {
+        name: "ImageClient".to_string(),
+        rust_path: "demo::ImageClient".to_string(),
+        original_rust_path: String::new(),
+        fields: vec![],
+        methods: vec![MethodDef {
+            name: "generate_image".to_string(),
+            params: vec![make_param("request", TypeRef::Named("CreateImageRequest".into()))],
+            return_type: TypeRef::String,
+            is_async: true,
+            is_static: false,
+            error_type: Some("DemoError".to_string()),
+            doc: String::new(),
+            sanitized: false,
+            returns_ref: false,
+            returns_cow: false,
+            return_newtype_wrapper: None,
+            receiver: Some(ReceiverKind::Ref),
+            trait_source: None,
+            has_default_impl: false,
+            binding_excluded: false,
+            binding_exclusion_reason: None,
+        }],
+        is_opaque: true,
+        is_clone: false,
+        is_copy: false,
+        is_trait: false,
+        has_default: false,
+        has_stripped_cfg_fields: false,
+        is_return_type: false,
+        serde_rename_all: None,
+        has_serde: false,
+        super_traits: vec![],
+        doc: String::new(),
+        cfg: None,
+        binding_excluded: false,
+        binding_exclusion_reason: None,
+    };
+
+    let api = ApiSurface {
+        crate_name: "demo".into(),
+        version: "0.1.0".into(),
+        types: vec![client_type, request_type],
+        functions: vec![],
+        enums: vec![],
+        errors: vec![],
+        excluded_type_paths: ::std::collections::HashMap::new(),
+    };
+
+    let toml = r#"
+[workspace]
+languages = ["swift"]
+
+[[crates]]
+name = "demo"
+sources = ["src/lib.rs"]
+
+[crates.swift]
+client_constructor_body.ImageClient = "Self { inner: ::demo::ImageClient::new(api_key, base_url) }"
+"#;
+    let cfg: alef_core::config::new_config::NewAlefConfig = toml::from_str(toml).expect("test config must parse");
+    let config = cfg.resolve().expect("test config must resolve").remove(0);
+    let files = SwiftBackend.generate_bindings(&api, &config).unwrap();
+    let swift = files
+        .iter()
+        .find(|f| f.path.to_string_lossy().ends_with(".swift"))
+        .unwrap();
+
+    // The call site must apply `.intoRust()` to convert the Swift DTO wrapper
+    // into the RustBridge raw type.
+    assert!(
+        swift.content.contains("try request.intoRust()"),
+        "call site must apply try request.intoRust() for first-class DTO params; got:\n{}",
+        swift.content
+    );
+    // The method signature must carry `throws` (both from error_type and intoRust).
+    assert!(
+        swift.content.contains("public func generateImage(_ request: CreateImageRequest) async throws -> String"),
+        "method signature must include throws when param is a first-class DTO; got:\n{}",
+        swift.content
+    );
+    // Must NOT pass the raw Swift wrapper directly to the bridge.
+    assert!(
+        !swift.content.contains(", request)"),
+        "must not forward the Swift wrapper directly to the bridge without .intoRust(); got:\n{}",
+        swift.content
+    );
+}
+
+/// When only DTO params are present (no `error_type`), the method must still
+/// emit `throws` on its signature because `intoRust()` is throwing.
+#[test]
+fn method_with_dto_param_only_adds_throws_even_without_error_type() {
+    use alef_core::ir::{MethodDef, ReceiverKind};
+
+    let mut req_type = make_type(
+        "SpeechRequest",
+        vec![make_field("text", TypeRef::String, false)],
+    );
+    req_type.has_serde = true;
+    req_type.has_default = true;
+
+    let client_type = TypeDef {
+        name: "SpeechClient".to_string(),
+        rust_path: "demo::SpeechClient".to_string(),
+        original_rust_path: String::new(),
+        fields: vec![],
+        methods: vec![MethodDef {
+            name: "create_speech".to_string(),
+            params: vec![make_param("req", TypeRef::Named("SpeechRequest".into()))],
+            return_type: TypeRef::Bytes,
+            is_async: false,
+            is_static: false,
+            error_type: None, // no error_type — throws must still come from intoRust()
+            doc: String::new(),
+            sanitized: false,
+            returns_ref: false,
+            returns_cow: false,
+            return_newtype_wrapper: None,
+            receiver: Some(ReceiverKind::Ref),
+            trait_source: None,
+            has_default_impl: false,
+            binding_excluded: false,
+            binding_exclusion_reason: None,
+        }],
+        is_opaque: true,
+        is_clone: false,
+        is_copy: false,
+        is_trait: false,
+        has_default: false,
+        has_stripped_cfg_fields: false,
+        is_return_type: false,
+        serde_rename_all: None,
+        has_serde: false,
+        super_traits: vec![],
+        doc: String::new(),
+        cfg: None,
+        binding_excluded: false,
+        binding_exclusion_reason: None,
+    };
+
+    let api = ApiSurface {
+        crate_name: "demo".into(),
+        version: "0.1.0".into(),
+        types: vec![client_type, req_type],
+        functions: vec![],
+        enums: vec![],
+        errors: vec![],
+        excluded_type_paths: ::std::collections::HashMap::new(),
+    };
+
+    let toml = r#"
+[workspace]
+languages = ["swift"]
+
+[[crates]]
+name = "demo"
+sources = ["src/lib.rs"]
+
+[crates.swift]
+client_constructor_body.SpeechClient = "Self { inner: ::demo::SpeechClient::new(api_key, base_url) }"
+"#;
+    let cfg: alef_core::config::new_config::NewAlefConfig = toml::from_str(toml).expect("test config must parse");
+    let config = cfg.resolve().expect("test config must resolve").remove(0);
+    let files = SwiftBackend.generate_bindings(&api, &config).unwrap();
+    let swift = files
+        .iter()
+        .find(|f| f.path.to_string_lossy().ends_with(".swift"))
+        .unwrap();
+
+    assert!(
+        swift.content.contains("public func createSpeech(_ req: SpeechRequest) throws"),
+        "method with only DTO params must still emit throws; got:\n{}",
+        swift.content
+    );
+    assert!(
+        swift.content.contains("try req.intoRust()"),
+        "call site must apply try req.intoRust(); got:\n{}",
+        swift.content
+    );
+}
+
 /// First-class struct fields must emit their rustdoc as `///` lines immediately
 /// above the `public let` declaration, mirroring how type/enum docs are surfaced.
 #[test]