Generate includes for tuples (#208)

This commit adds support for generating a `#include<~>` corresponding to each field in tuples. 

Here's an example.

```rust
#[swift_bridge::bridge]
mod ffi {
    extern "Rust" {
        fn some_function(arg1: (i32, bool)) -> (i32, bool);
    }
}
```

Generates the following c header file:
```c
#include <stdint.h>
#include <stdbool.h>
//...
```

Author: NiwakaDev

SwiftRustIntegrationTestRunner/SwiftRustIntegrationTestRunnerTests/TupleTests.swift

@@ -27,6 +27,13 @@ final class TupleTest: XCTestCase {
             XCTAssertEqual(tuple.1.toString(), "foo")
             XCTAssertEqual(tuple.2, 128)
         }
+        XCTContext.runActivity(named: "Verify that we can pass and return a (F64, UInt, Bool).") {
+            _ in
+            let tuple = rust_reflect_tuple_f64_and_usize_and_bool((0.1, 123, true))
+            XCTAssertEqual(tuple.0, 0.1)
+            XCTAssertEqual(tuple.1, 123)
+            XCTAssertEqual(tuple.2, true)
+        }
     }
 
     /// Verify that Rust can call Swift functions that accept and return Tuples.

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

@@ -118,7 +118,7 @@ pub(crate) trait BridgeableType: Debug {
 
     /// Generate a C include statement to put in the C header.
     /// For example, for a `u8` we would generate a `#include <stdint.h>` line.
-    fn to_c_include(&self) -> Option<&'static str>;
+    fn to_c_include(&self, types: &TypeDeclarations) -> Option<Vec<&'static str>>;
 
     /// Get the FFI compatible Rust type.
     ///
@@ -531,7 +531,7 @@ impl BridgeableType for BridgedType {
         self.to_c(types)
     }
 
-    fn to_c_include(&self) -> Option<&'static str> {
+    fn to_c_include(&self, _types: &TypeDeclarations) -> Option<Vec<&'static str>> {
         todo!()
     }
 
@@ -1645,9 +1645,9 @@ impl BridgedType {
         }
     }
 
-    pub fn to_c_include(&self) -> Option<&'static str> {
+    pub fn to_c_include(&self, types: &TypeDeclarations) -> Option<Vec<&'static str>> {
         match self {
-            BridgedType::Bridgeable(b) => b.to_c_include(),
+            BridgedType::Bridgeable(b) => b.to_c_include(types),
             BridgedType::StdLib(stdlib_type) => match stdlib_type {
                 StdLibType::U8
                 | StdLibType::I8
@@ -1658,18 +1658,15 @@ impl BridgedType {
                 | StdLibType::U64
                 | StdLibType::I64
                 | StdLibType::Usize
-                | StdLibType::Isize => Some("stdint.h"),
-                StdLibType::Bool => Some("stdbool.h"),
+                | StdLibType::Isize => Some(vec!["stdint.h"]),
+                StdLibType::Bool => Some(vec!["stdbool.h"]),
                 StdLibType::Pointer(ptr) => match &ptr.pointee {
-                    Pointee::BuiltIn(ty) => ty.to_c_include(),
+                    Pointee::BuiltIn(ty) => ty.to_c_include(types),
                     Pointee::Void(_) => None,
                 },
-                StdLibType::RefSlice(slice) => slice.ty.to_c_include(),
-                StdLibType::Vec(_vec) => Some("stdint.h"),
-                StdLibType::Tuple(_tuple) => {
-                    // TODO: Iterate over the fields and see if any of them need imports..
-                    None
-                }
+                StdLibType::RefSlice(slice) => slice.ty.to_c_include(types),
+                StdLibType::Vec(_vec) => Some(vec!["stdint.h"]),
+                StdLibType::Tuple(tuple) => tuple.to_c_include(types),
                 _ => None,
             },
             BridgedType::Foreign(CustomBridgedType::Shared(SharedType::Struct(_shared_struct))) => {
@@ -1855,9 +1852,14 @@ impl BridgedType {
                 StdLibType::U8 => "U8".to_string(),
                 StdLibType::U16 => "U16".to_string(),
                 StdLibType::U32 => "U32".to_string(),
+                StdLibType::Usize => "UInt".to_string(),
                 StdLibType::I8 => "I8".to_string(),
                 StdLibType::I16 => "I16".to_string(),
                 StdLibType::I32 => "I32".to_string(),
+                StdLibType::Isize => "Int".to_string(),
+                StdLibType::Bool => "Bool".to_string(),
+                StdLibType::F32 => "F32".to_string(),
+                StdLibType::F64 => "F64".to_string(),
                 _ => todo!(),
             },
             BridgedType::Foreign(ty) => match ty {

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

@@ -81,7 +81,7 @@ impl BridgeableType for BuiltInPointer {
         todo!()
     }
 
-    fn to_c_include(&self) -> Option<&'static str> {
+    fn to_c_include(&self, _types: &TypeDeclarations) -> Option<Vec<&'static str>> {
         todo!()
     }
 

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

@@ -66,7 +66,7 @@ impl BridgeableType for BridgedString {
         "void*".to_string()
     }
 
-    fn to_c_include(&self) -> Option<&'static str> {
+    fn to_c_include(&self, _types: &TypeDeclarations) -> Option<Vec<&'static str>> {
         None
     }
 

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

@@ -145,7 +145,7 @@ impl BridgeableType for OpaqueForeignType {
         }
     }
 
-    fn to_c_include(&self) -> Option<&'static str> {
+    fn to_c_include(&self, _types: &TypeDeclarations) -> Option<Vec<&'static str>> {
         None
     }
 

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

@@ -136,8 +136,8 @@ impl BridgeableType for BuiltInTuple {
         format!("struct {}", ty_name)
     }
 
-    fn to_c_include(&self) -> Option<&'static str> {
-        todo!()
+    fn to_c_include(&self, types: &TypeDeclarations) -> Option<Vec<&'static str>> {
+        self.0.to_c_include(types)
     }
 
     fn to_ffi_compatible_rust_type(

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

@@ -207,6 +207,22 @@ impl UnnamedStructFields {
             })
             .collect()
     }
+    pub fn to_c_include(&self, types: &TypeDeclarations) -> Option<Vec<&'static str>> {
+        let mut includes = vec![];
+        for field in self.0.iter() {
+            let ty = BridgedType::new_with_type(&field.ty, types).unwrap();
+            if let Some(field_includes) = ty.to_c_include(types) {
+                for include in field_includes {
+                    includes.push(include);
+                }
+            }
+        }
+        if includes.len() > 0 {
+            Some(includes)
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Clone)]

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

@@ -45,6 +45,9 @@ public func some_function(_ arg: (Int32, UInt8)) -> (Int32, UInt8) {
     fn expected_c_header() -> ExpectedCHeader {
         ExpectedCHeader::ContainsManyAfterTrim(vec![
             r#"
+#include <stdint.h>
+"#,
+            r#"
 typedef struct __swift_bridge__$tuple$I32U8 { int32_t _0; uint8_t _1; } __swift_bridge__$tuple$I32U8;
 "#,
             r#"
@@ -108,6 +111,9 @@ public func some_function<GenericIntoRustString: IntoRustString>(_ arg1: (Generi
     fn expected_c_header() -> ExpectedCHeader {
         ExpectedCHeader::ContainsManyAfterTrim(vec![
             r#"
+#include <stdint.h>
+"#,
+            r#"
 typedef struct __swift_bridge__$tuple$StringU32 { void* _0; uint32_t _1; } __swift_bridge__$tuple$StringU32;
 "#,
             r#"
@@ -176,6 +182,9 @@ public func some_function(_ arg1: (SomeType, UInt32)) -> (SomeType, UInt32) {
     fn expected_c_header() -> ExpectedCHeader {
         ExpectedCHeader::ContainsManyAfterTrim(vec![
             r#"
+#include <stdint.h>
+"#,
+            r#"
 typedef struct __swift_bridge__$tuple$SomeTypeU32 { void* _0; uint32_t _1; } __swift_bridge__$tuple$SomeTypeU32;
 "#,
             r#"
@@ -196,6 +205,76 @@ struct __swift_bridge__$tuple$SomeTypeU32 __swift_bridge__$some_function(struct
     }
 }
 
+/// Verify that we can use a (f32, isize, bool) as Rust function arg and return type.
+mod extern_rust_tuple_f32_isize_bool {
+    use super::*;
+
+    fn bridge_module_tokens() -> TokenStream {
+        quote! {
+            #[swift_bridge::bridge]
+            mod ffi {
+                extern "Rust" {
+                    fn some_function(arg1: (f32, isize, bool)) -> (f32, isize, bool);
+                }
+            }
+        }
+    }
+
+    fn expected_rust_tokens() -> ExpectedRustTokens {
+        ExpectedRustTokens::ContainsMany(vec![
+            quote! {
+                pub extern "C" fn __swift_bridge__some_function (arg1: __swift_bridge__tuple_F32IntBool) -> __swift_bridge__tuple_F32IntBool {
+                    { let val = super::some_function({let val = arg1; (val.0, val.1, val.2)});
+                    __swift_bridge__tuple_F32IntBool(val.0, val.1, val.2) }
+                }
+            },
+            quote! {
+                #[repr(C)]
+                #[doc(hidden)]
+                pub struct __swift_bridge__tuple_F32IntBool(f32, isize, bool);
+            },
+        ])
+    }
+
+    fn expected_swift_code() -> ExpectedSwiftCode {
+        ExpectedSwiftCode::ContainsManyAfterTrim(vec![
+            r#"
+public func some_function(_ arg1: (Float, Int, Bool)) -> (Float, Int, Bool) {
+    { let val = __swift_bridge__$some_function(__swift_bridge__$tuple$F32IntBool(_0: arg1.0, _1: arg1.1, _2: arg1.2)); return (val._0, val._1, val._2); }()
+}
+"#,
+        ])
+    }
+
+    fn expected_c_header() -> ExpectedCHeader {
+        ExpectedCHeader::ContainsManyAfterTrim(vec![
+            r#"
+#include <stdint.h>
+"#,
+            r#"
+#include <stdbool.h>
+"#,
+            r#"
+typedef struct __swift_bridge__$tuple$F32IntBool { float _0; intptr_t _1; bool _2; } __swift_bridge__$tuple$F32IntBool;
+"#,
+            r#"
+struct __swift_bridge__$tuple$F32IntBool __swift_bridge__$some_function(struct __swift_bridge__$tuple$F32IntBool arg1);
+"#,
+        ])
+    }
+
+    #[test]
+    fn extern_rust_tuple_f32_isize_bool() {
+        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();
+    }
+}
+
 /// Verify that we can use a (primitive type, primitive type) as Swift function arg and return type.
 mod extern_swift_tuple_primitives {
     use super::*;

crates/swift-bridge-ir/src/codegen/generate_c_header.rs

@@ -71,8 +71,10 @@ impl SwiftBridgeModule {
                                     for field in f.iter() {
                                         let ty = BridgedType::new_with_type(&field.ty, &self.types)
                                             .unwrap();
-                                        if let Some(include) = ty.to_c_include() {
-                                            bookkeeping.includes.insert(include);
+                                        if let Some(includes) = ty.to_c_include(&self.types) {
+                                            for include in includes {
+                                                bookkeeping.includes.insert(include);
+                                            }
                                         }
 
                                         let name = field.swift_name_string();
@@ -84,8 +86,10 @@ impl SwiftBridgeModule {
                                     for (idx, field) in types.iter().enumerate() {
                                         let ty = BridgedType::new_with_type(&field.ty, &self.types)
                                             .unwrap();
-                                        if let Some(include) = ty.to_c_include() {
-                                            bookkeeping.includes.insert(include);
+                                        if let Some(includes) = ty.to_c_include(&self.types) {
+                                            for include in includes {
+                                                bookkeeping.includes.insert(include);
+                                            }
                                         }
 
                                         let name = format!("_{}", idx);
@@ -177,8 +181,10 @@ typedef struct {option_ffi_name} {{ bool is_some; {ffi_name} val; }} {option_ffi
                                                 &self.types,
                                             )
                                             .unwrap();
-                                            if let Some(include) = ty.to_c_include() {
-                                                bookkeeping.includes.insert(include);
+                                            if let Some(includes) = ty.to_c_include(&self.types) {
+                                                for include in includes {
+                                                    bookkeeping.includes.insert(include);
+                                                }
                                             }
                                             let ty = ty.to_c(&self.types);
                                             let field_name = named_field.name.to_string();
@@ -197,8 +203,10 @@ typedef struct {option_ffi_name} {{ bool is_some; {ffi_name} val; }} {option_ffi
                                                 &self.types,
                                             )
                                             .unwrap();
-                                            if let Some(include) = ty.to_c_include() {
-                                                bookkeeping.includes.insert(include);
+                                            if let Some(includes) = ty.to_c_include(&self.types) {
+                                                for include in includes {
+                                                    bookkeeping.includes.insert(include);
+                                                }
                                             }
                                             let ty = ty.to_c(&self.types);
                                             params.push(format!("{} _{};", ty, unnamed_field.idx));

crates/swift-bridge-ir/src/parsed_extern_fn.rs

@@ -401,7 +401,7 @@ impl ParsedExternFn {
 
         if let ReturnType::Type(_, ty) = &self.func.sig.output {
             if let Some(ty) = BridgedType::new_with_type(&ty, types) {
-                if let Some(include) = ty.to_c_include() {
+                if let Some(include) = ty.to_c_include(types) {
                     includes.push(include);
                 }
             }
@@ -410,15 +410,15 @@ impl ParsedExternFn {
         for param in &self.func.sig.inputs {
             if let FnArg::Typed(pat_ty) = param {
                 if let Some(ty) = BridgedType::new_with_type(&pat_ty.ty, types) {
-                    if let Some(include) = ty.to_c_include() {
+                    if let Some(include) = ty.to_c_include(types) {
                         includes.push(include);
                     }
                 }
             }
         }
 
         if includes.len() > 0 {
-            Some(includes)
+            Some(includes.into_iter().flatten().collect())
         } else {
             None
         }

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

@@ -9,6 +9,9 @@ mod ffi {
         fn rust_reflect_tuple_opaque_rust_and_string_and_primitive(
             tuple: (TupleTestOpaqueRustType, String, u8),
         ) -> (TupleTestOpaqueRustType, String, u8);
+        fn rust_reflect_tuple_f64_and_usize_and_bool(
+            tuple: (f64, usize, bool),
+        ) -> (f64, usize, bool);
     }
     extern "Swift" {
         fn swift_reflect_tuple_primitives(arg: (i32, u32)) -> (i32, u32);
@@ -39,6 +42,10 @@ fn rust_reflect_tuple_opaque_rust_and_string_and_primitive(
     tuple
 }
 
+fn rust_reflect_tuple_f64_and_usize_and_bool(tuple: (f64, usize, bool)) -> (f64, usize, bool) {
+    tuple
+}
+
 fn test_rust_calls_swift_tuples() {
     let val = ffi::swift_reflect_tuple_primitives((-123, 123));
     assert_eq!(val.0, -123);