feat: support for tuple structs

closes issue #46

Author: AnthonyMichaelTDM

src/to_typescript/structs.rs

@@ -4,7 +4,11 @@ use convert_case::{Case, Casing};
 
 impl super::ToTypescript for syn::ItemStruct {
     fn convert_to_ts(self, state: &mut BuildState, config: &crate::BuildSettings) {
-        let export = if config.uses_type_interface { "" } else { "export " };
+        let export = if config.uses_type_interface {
+            ""
+        } else {
+            "export "
+        };
         let casing = utils::get_attribute_arg("serde", "rename_all", &self.attrs);
         let casing = utils::parse_serde_case(casing);
         state.types.push('\n');
@@ -14,27 +18,53 @@ impl super::ToTypescript for syn::ItemStruct {
 
         let intersections = get_intersections(&self.fields);
 
-        match intersections {
-            Some(intersections) => {
+        match (
+            intersections,
+            matches!(self.fields, syn::Fields::Unnamed(_)),
+        ) {
+            (Some(intersections), false) => {
                 state.types.push_str(&format!(
-                    "{export}type {struct_name}{generics} = {intersections} & {{\n",
+                    "{export}type {struct_name}{generics} = {intersections} & ",
                     export = export,
                     struct_name = self.ident,
                     generics = utils::extract_struct_generics(self.generics.clone()),
                     intersections = intersections
                 ));
             }
-            None => {
+            (None, false) => {
                 state.types.push_str(&format!(
-                    "{export}interface {interface_name}{generics} {{\n",
+                    "{export}interface {interface_name}{generics} ",
                     interface_name = self.ident,
                     generics = utils::extract_struct_generics(self.generics.clone())
                 ));
             }
+            (None, true) => {
+                state.types.push_str(&format!(
+                    "{export}type {struct_name}{generics} = ",
+                    export = export,
+                    struct_name = self.ident,
+                    generics = utils::extract_struct_generics(self.generics.clone()),
+                ));
+            }
+            (Some(_), true) => {
+                if crate::DEBUG.try_get().is_some_and(|d| *d) {
+                    println!(
+                        "#[tsync] failed for struct {}. cannot flatten fields of tuple struct",
+                        self.ident
+                    );
+                }
+                return;
+            }
+        }
+
+        if let syn::Fields::Unnamed(unnamed) = self.fields {
+            process_tuple_fields(unnamed, state);
+        } else {
+            state.types.push_str("{\n");
+            process_fields(self.fields, state, 2, casing);
+            state.types.push('}');
         }
 
-        process_fields(self.fields, state, 2, casing);
-        state.types.push('}');
         state.types.push('\n');
     }
 }
@@ -48,6 +78,11 @@ pub fn process_fields(
     let space = utils::build_indentation(indentation_amount);
     let case = case.into();
     for field in fields {
+        debug_assert!(
+            field.ident.is_some(),
+            "struct fields should have names, found unnamed field"
+        );
+
         // Check if the field has the serde flatten attribute, if so, skip it
         let has_flatten_attr = utils::get_attribute_arg("serde", "flatten", &field.attrs).is_some();
         if has_flatten_attr {
@@ -77,6 +112,41 @@ pub fn process_fields(
     }
 }
 
+/// Process tuple fields
+///
+/// NOTE: Currently, this function does not handle comments or attributes on tuple fields.
+///
+/// # Example
+///
+/// ```ignore
+/// struct Todo(String, u32);
+/// ```
+///
+/// should become
+///
+/// ```ignore
+/// type Todo = [string, number];
+/// ```
+pub(crate) fn process_tuple_fields(fields: syn::FieldsUnnamed, state: &mut BuildState) {
+    let out = fields
+        .unnamed
+        .into_iter()
+        .map(|field| {
+            let field_type = convert_type(&field.ty);
+            format!("{field_type}", field_type = field_type.ts_type)
+        })
+        .collect::<Vec<String>>();
+
+    if out.is_empty() {
+        return;
+    } else if out.len() == 1 {
+        state.types.push_str(&format!("{}", out[0]));
+        return;
+    } else {
+        state.types.push_str(&format!("[ {} ]", out.join(", ")));
+    }
+}
+
 fn get_intersections(fields: &syn::Fields) -> Option<String> {
     let mut types = Vec::new();
 

test/issue-43/rust.rs

@@ -0,0 +1,17 @@
+// #[tsync]
+// struct HasTuple1 {
+//     foo: i32,
+//     bar: Option<(String, i32)>,
+// }
+
+// #[tsync]
+// struct HasTuple2 {
+//     foo: i32,
+//     bar: (String, i32),
+// }
+
+#[tsync]
+struct IsTuple(i32, String);
+
+#[tsync]
+struct IsTupleComplex(i32, String, (String, (i32, i32)));

test/issue-43/tsync.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+cd $SCRIPT_DIR
+
+cargo run -- -i rust.rs -o typescript.d.ts
+cargo run -- -i rust.rs -o typescript.ts

test/issue-43/typescript.d.ts

@@ -0,0 +1,5 @@
+/* This file is generated and managed by tsync */
+
+type IsTuple = [ number, string ]
+
+type IsTupleComplex = [ number, string, unknown ]

test/issue-43/typescript.ts

@@ -0,0 +1,5 @@
+/* This file is generated and managed by tsync */
+
+export type IsTuple = [ number, string ]
+
+export type IsTupleComplex = [ number, string, unknown ]