feat: support for tuple variants of enums

closes Failing for Internally/Adjacently tagged #58
partially addresses Enhanced enum support and types #55

Author: AnthonyMichaelTDM

Diff for: src/to_typescript/enums.rs

@@ -1,4 +1,3 @@
-use crate::typescript::convert_type;
 use crate::{utils, BuildState};
 use convert_case::{Case, Casing};
 use syn::__private::ToTokens;
@@ -9,26 +8,6 @@ use syn::__private::ToTokens;
 /// `rename_all` attributes for the name of the tag will also be adhered to.
 impl super::ToTypescript for syn::ItemEnum {
     fn convert_to_ts(self, state: &mut BuildState, config: &crate::BuildSettings) {
-        // check we don't have any tuple structs that could mess things up.
-        // if we do ignore this struct
-        for variant in self.variants.iter() {
-            // allow single-field tuple structs to pass through as newtype structs
-            let mut is_newtype = false;
-            for f in variant.fields.iter() {
-                if f.ident.is_none() {
-                    // If we already marked this variant as a newtype, we have a multi-field tuple struct
-                    if is_newtype {
-                        if crate::DEBUG.try_get().is_some_and(|d| *d) {
-                            println!("#[tsync] failed for enum {}", self.ident);
-                        }
-                        return;
-                    } else {
-                        is_newtype = true;
-                    }
-                }
-            }
-        }
-
         state.types.push('\n');
 
         let comments = utils::get_comments(self.clone().attrs);
@@ -42,7 +21,15 @@ impl super::ToTypescript for syn::ItemEnum {
 
         // always use output the internally_tagged representation if the tag is present
         if let Some(tag_name) = utils::get_attribute_arg("serde", "tag", &self.attrs) {
-            add_internally_tagged_enum(tag_name, self, state, casing, config.uses_type_interface)
+            let content_name = utils::get_attribute_arg("serde", "content", &self.attrs);
+            add_internally_tagged_enum(
+                tag_name,
+                content_name,
+                self,
+                state,
+                casing,
+                config.uses_type_interface,
+            )
         } else if is_single {
             if utils::has_attribute_arg("derive", "Serialize_repr", &self.attrs) {
                 add_numeric_enum(self, state, casing, config)
@@ -208,6 +195,7 @@ fn add_numeric_enum(
 /// ```
 fn add_internally_tagged_enum(
     tag_name: String,
+    content_name: Option<String>,
     exported_struct: syn::ItemEnum,
     state: &mut BuildState,
     casing: Option<Case>,
@@ -222,7 +210,7 @@ fn add_internally_tagged_enum(
 
     for variant in exported_struct.variants.iter() {
         // Assumes that non-newtype tuple variants have already been filtered out
-        if variant.fields.iter().any(|v| v.ident.is_none()) {
+        if variant.fields.iter().any(|v| v.ident.is_none()) && content_name.is_none() {
             // TODO: Generate newtype structure
             // This should contain the discriminant plus all fields of the inner structure as a flat structure
             // TODO: Check for case where discriminant name matches an inner structure field name
@@ -240,31 +228,62 @@ fn add_internally_tagged_enum(
     state.types.push_str(";\n");
 
     for variant in exported_struct.variants {
-        // Assumes that non-newtype tuple variants have already been filtered out
-        if !variant.fields.iter().any(|v| v.ident.is_none()) {
-            state.types.push('\n');
-            let comments = utils::get_comments(variant.attrs);
-            state.write_comments(&comments, 0);
-            state.types.push_str(&format!(
-                "type {interface_name}__{variant_name} = ",
-                interface_name = exported_struct.ident,
-                variant_name = variant.ident,
-            ));
+        match (&variant.fields, content_name.as_ref()) {
+            // adjacently tagged
+            (syn::Fields::Unnamed(fields), Some(content_name)) => {
+                state.types.push('\n');
+                let comments = utils::get_comments(variant.attrs);
+                state.write_comments(&comments, 0);
+                state.types.push_str(&format!(
+                    "type {interface_name}__{variant_name} = ",
+                    interface_name = exported_struct.ident,
+                    variant_name = variant.ident,
+                ));
+                // add discriminant
+                state.types.push_str(&format!(
+                    "{{\n{indent}\"{tag_name}\": \"{}\";\n{indent}\"{content_name}\": ",
+                    variant.ident,
+                    indent = utils::build_indentation(2),
+                ));
+                super::structs::process_tuple_fields(fields.clone(), state);
+                state.types.push_str(";\n};");
+            }
+            // missing content name
+            (syn::Fields::Unnamed(_), None) => {
+                if crate::DEBUG.try_get().is_some_and(|d: &bool| *d) {
+                    println!(
+                        "#[tsync] failed for {} variant of enum {}, missing content attribute, skipping",
+                        variant.ident,
+                        exported_struct.ident
+                    );
+                }
+                continue;
+            }
+            _ => {
+                state.types.push('\n');
+                let comments = utils::get_comments(variant.attrs);
+                state.write_comments(&comments, 0);
+                state.types.push_str(&format!(
+                    "type {interface_name}__{variant_name} = ",
+                    interface_name = exported_struct.ident,
+                    variant_name = variant.ident,
+                ));
 
-            let field_name = if let Some(casing) = casing {
-                variant.ident.to_string().to_case(casing)
-            } else {
-                variant.ident.to_string()
-            };
-            // add discriminant
-            state.types.push_str(&format!(
-                "{{\n{}{}: \"{}\";\n",
-                utils::build_indentation(2),
-                tag_name,
-                field_name,
-            ));
-            super::structs::process_fields(variant.fields, state, 2, casing);
-            state.types.push_str("};");
+                let field_name = if let Some(casing) = casing {
+                    variant.ident.to_string().to_case(casing)
+                } else {
+                    variant.ident.to_string()
+                };
+                // add discriminant
+                state.types.push_str(&format!(
+                    "{{\n{}{}: \"{}\";\n",
+                    utils::build_indentation(2),
+                    tag_name,
+                    field_name,
+                ));
+                super::structs::process_fields(variant.fields, state, 2, casing);
+                state.types.push_str("};");
+            }
         }
     }
     state.types.push('\n');
@@ -293,17 +312,13 @@ fn add_externally_tagged_enum(
         } else {
             variant.ident.to_string()
         };
-        // Assumes that non-newtype tuple variants have already been filtered out
-        let is_newtype = variant.fields.iter().any(|v| v.ident.is_none());
 
-        if is_newtype {
+        if let syn::Fields::Unnamed(fields) = &variant.fields {
             // add discriminant
-            state.types.push_str(&format!("  | {{ \"{}\":", field_name));
-            for field in variant.fields {
-                state
-                    .types
-                    .push_str(&format!(" {}", convert_type(&field.ty).ts_type,));
-            }
+            state
+                .types
+                .push_str(&format!("  | {{ \"{}\": ", field_name));
+            super::structs::process_tuple_fields(fields.clone(), state);
             state.types.push_str(" }");
         } else {
             // add discriminant

Diff for: src/to_typescript/structs.rs

@@ -127,22 +127,19 @@ pub fn process_fields(
 /// ```ignore
 /// type Todo = [string, number];
 /// ```
-pub(crate) fn process_tuple_fields(fields: syn::FieldsUnnamed, state: &mut BuildState) {
+pub 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)
+            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 {
+    if out.len() == 1 {
+        state.types.push_str(&out[0].to_string());
+    } else if !out.is_empty() {
         state.types.push_str(&format!("[ {} ]", out.join(", ")));
     }
 }

Diff for: test/enum/rust.rs

@@ -17,7 +17,32 @@ enum InternalTopping {
     ExtraCheese { kind: String },
     /// Custom toppings
     /// May expire soon
+    /// Note: this test case will not be included in the generated typescript,
+    /// because it is a tuple variant
     Custom(CustomTopping),
+    /// two custom toppings
+    /// Note: this test case will not be included in the generated typescript,
+    /// because it is a tuple variant
+    CustomTwo(CustomTopping, CustomTopping),
+}
+
+/// Adjacently tagged enums have a key-value pair
+/// that discrimate which variant it belongs to, and
+/// can support tuple variants
+#[tsync]
+#[serde(tag = "type", content = "value")]
+enum AdjacentTopping {
+    /// Tasty!
+    /// Not vegetarian
+    Pepperoni,
+    /// For cheese lovers
+    ExtraCheese { kind: String },
+    /// Custom toppings
+    /// May expire soon
+    Custom(CustomTopping),
+    /// two custom toppings
+    /// Note: this test case is specifically for specifying a tuple of types
+    CustomTwo(CustomTopping, CustomTopping),
 }
 
 /// Externally tagged enums ascribe the value to a key
@@ -33,6 +58,9 @@ enum ExternalTopping {
     /// May expire soon
     /// Note: this test case is specifically for specifying a single type in the tuple
     Custom(CustomTopping),
+    /// two custom toppings
+    /// Note: this test case is specifically for specifying a tuple of types
+    CustomTwo(CustomTopping, CustomTopping),
 }
 
 #[tsync]
@@ -69,5 +97,5 @@ enum AnimalTwo {
 #[tsync]
 #[serde(tag = "type")]
 enum Tagged {
-    Test // this should be { type: "Test" } in the TypeScript (not just the string "Test")
-}
+    Test, // this should be { type: "Test" } in the TypeScript (not just the string "Test")
+}

Diff for: test/enum/typescript.d.ts

@@ -21,6 +21,46 @@ type InternalTopping__ExtraCheese = {
   KIND: string;
 };
 
+/**
+ * Adjacently tagged enums have a key-value pair
+ * that discrimate which variant it belongs to, and
+ * can support tuple variants
+ */
+type AdjacentTopping =
+  | AdjacentTopping__Pepperoni
+  | AdjacentTopping__ExtraCheese
+  | AdjacentTopping__Custom
+  | AdjacentTopping__CustomTwo;
+
+/**
+ * Tasty!
+ * Not vegetarian
+ */
+type AdjacentTopping__Pepperoni = {
+  type: "Pepperoni";
+};
+/** For cheese lovers */
+type AdjacentTopping__ExtraCheese = {
+  type: "ExtraCheese";
+  kind: string;
+};
+/**
+ * Custom toppings
+ * May expire soon
+ */
+type AdjacentTopping__Custom = {
+  "type": "Custom";
+  "value": CustomTopping;
+};
+/**
+ * two custom toppings
+ * Note: this test case is specifically for specifying a tuple of types
+ */
+type AdjacentTopping__CustomTwo = {
+  "type": "CustomTwo";
+  "value": [ CustomTopping, CustomTopping ];
+};
+
 /**
  * Externally tagged enums ascribe the value to a key
  * that is the same as the variant name
@@ -44,7 +84,12 @@ type ExternalTopping =
    * May expire soon
    * Note: this test case is specifically for specifying a single type in the tuple
    */
-  | { "Custom": CustomTopping };
+  | { "Custom": CustomTopping }
+  /**
+   * two custom toppings
+   * Note: this test case is specifically for specifying a tuple of types
+   */
+  | { "CustomTwo": [ CustomTopping, CustomTopping ] };
 
 interface CustomTopping {
   name: string;

Diff for: test/enum/typescript.ts

@@ -21,6 +21,46 @@ type InternalTopping__ExtraCheese = {
   KIND: string;
 };
 
+/**
+ * Adjacently tagged enums have a key-value pair
+ * that discrimate which variant it belongs to, and
+ * can support tuple variants
+ */
+export type AdjacentTopping =
+  | AdjacentTopping__Pepperoni
+  | AdjacentTopping__ExtraCheese
+  | AdjacentTopping__Custom
+  | AdjacentTopping__CustomTwo;
+
+/**
+ * Tasty!
+ * Not vegetarian
+ */
+type AdjacentTopping__Pepperoni = {
+  type: "Pepperoni";
+};
+/** For cheese lovers */
+type AdjacentTopping__ExtraCheese = {
+  type: "ExtraCheese";
+  kind: string;
+};
+/**
+ * Custom toppings
+ * May expire soon
+ */
+type AdjacentTopping__Custom = {
+  "type": "Custom";
+  "value": CustomTopping;
+};
+/**
+ * two custom toppings
+ * Note: this test case is specifically for specifying a tuple of types
+ */
+type AdjacentTopping__CustomTwo = {
+  "type": "CustomTwo";
+  "value": [ CustomTopping, CustomTopping ];
+};
+
 /**
  * Externally tagged enums ascribe the value to a key
  * that is the same as the variant name
@@ -44,7 +84,12 @@ export type ExternalTopping =
    * May expire soon
    * Note: this test case is specifically for specifying a single type in the tuple
    */
-  | { "Custom": CustomTopping };
+  | { "Custom": CustomTopping }
+  /**
+   * two custom toppings
+   * Note: this test case is specifically for specifying a tuple of types
+   */
+  | { "CustomTwo": [ CustomTopping, CustomTopping ] };
 
 export interface CustomTopping {
   name: string;