Fix IntoParts implementation

execution-plan-macros/Cargo.toml

@@ -11,7 +11,7 @@ authors = ["Adam Chalmers"]
 [dependencies]
 proc-macro2 = "1.0.70"
 quote = "1.0.33"
-syn = "2.0.41"
+syn = { version = "2.0.41", features = ["extra-traits"] }
 
 [lib]
 proc-macro = true

execution-plan-macros/src/lib.rs

@@ -52,10 +52,10 @@ fn impl_value_on_enum(
                         #name::#variant_name{#(#field_idents),*}
                     },
                     quote_spanned! {expr.span()=>
-                        vec![
-                        Primitive::from(stringify!(#variant_name).to_owned()),
-                        #(Primitive::from(#field_idents),)*
-                        ]
+                        let mut parts = Vec::new();
+                        parts.push(kittycad_execution_plan_traits::Primitive::from(stringify!(#variant_name).to_owned()));
+                        #(parts.extend(#field_idents.into_parts());)*
+                        parts
                     },
                 )
             }
@@ -76,10 +76,10 @@ fn impl_value_on_enum(
                         #name::#variant_name(#(#placeholder_field_idents),*)
                     },
                     quote_spanned! {expr.span() =>
-                        vec![
-                        Primitive::from(stringify!(#variant_name).to_owned()),
-                        #(Primitive::from(#placeholder_field_idents),)*
-                        ]
+                        let mut parts = Vec::new();
+                        parts.push(kittycad_execution_plan_traits::Primitive::from(stringify!(#variant_name).to_owned()));
+                        #(parts.extend(#placeholder_field_idents.into_parts());)*
+                        parts
                     },
                 )
             }
@@ -113,7 +113,7 @@ fn impl_value_on_enum(
                     let (field_idents, field_types): (Vec<_>, Vec<_>) = expr
                         .named
                         .iter()
-                        .filter_map(|named| named.ident.as_ref().map(|id| (id, &named.ty)))
+                        .filter_map(|named| named.ident.as_ref().map(|id| (id, remove_generics(named.ty.clone()))))
                         .unzip();
                     let rhs = quote_spanned! {expr.span()=>
                         #(let #field_idents = #field_types::from_parts(values)?;)*
@@ -195,6 +195,17 @@ fn impl_value_on_enum(
     }
 }
 
+fn remove_generics(mut ty: syn::Type) -> syn::Type {
+    if let syn::Type::Path(ref mut p) = ty {
+        for segment in p.path.segments.iter_mut() {
+            if let syn::PathArguments::AngleBracketed(ref mut _a) = segment.arguments {
+                segment.arguments = syn::PathArguments::None;
+            }
+        }
+    }
+    ty
+}
+
 fn impl_value_on_struct(
     span: Span,
     name: proc_macro2::Ident,
@@ -299,6 +310,19 @@ mod tests {
         insta::assert_snapshot!(formatted);
     }
 
+    #[test]
+    fn test_enum_with_generics() {
+        let input = quote! {
+            enum Segment {
+                Line { point: Point3d<f64> }
+            }
+        };
+        let input: DeriveInput = syn::parse2(input).unwrap();
+        let out = impl_derive_value(input);
+        let formatted = get_text_fmt(&out).unwrap();
+        insta::assert_snapshot!(formatted);
+    }
+
     fn clean_text(s: &str) -> String {
         // Add newlines after end-braces at <= two levels of indentation.
         if cfg!(not(windows)) {

execution-plan-macros/src/snapshots/kittycad_execution_plan_macros__tests__enum.snap

@@ -7,21 +7,21 @@ impl kittycad_execution_plan_traits::Value for FooEnum {
         match self {
             FooEnum::A { x } => {
                 vec![
-                    Primitive::from(stringify!(A).to_owned()),
-                    Primitive::from(x),
+                    kittycad_execution_plan_traits::Primitive::from(stringify!(A).to_owned()),
+                    kittycad_execution_plan_traits::Primitive::from(x),
                 ]
             }
             FooEnum::B { y } => {
                 vec![
-                    Primitive::from(stringify!(B).to_owned()),
-                    Primitive::from(y),
+                    kittycad_execution_plan_traits::Primitive::from(stringify!(B).to_owned()),
+                    kittycad_execution_plan_traits::Primitive::from(y),
                 ]
             }
             FooEnum::C(field0, field1) => {
                 vec![
-                    Primitive::from(stringify!(C).to_owned()),
-                    Primitive::from(field0),
-                    Primitive::from(field1),
+                    kittycad_execution_plan_traits::Primitive::from(stringify!(C).to_owned()),
+                    kittycad_execution_plan_traits::Primitive::from(field0),
+                    kittycad_execution_plan_traits::Primitive::from(field1),
                 ]
             }
             FooEnum::D => Vec::new(),

execution-plan-macros/src/snapshots/kittycad_execution_plan_macros__tests__enum_with_generics.snap.new

@@ -0,0 +1,37 @@
+---
+source: execution-plan-macros/src/lib.rs
+assertion_line: 324
+expression: formatted
+---
+impl kittycad_execution_plan_traits::Value for Segment {
+    fn into_parts(self) -> Vec<kittycad_execution_plan_traits::Primitive> {
+        match self {
+            Segment::Line { point } => {
+                vec![
+                    kittycad_execution_plan_traits::Primitive::from(stringify!(Line).to_owned()),
+                    kittycad_execution_plan_traits::Primitive::from(point),
+                ]
+            }
+        }
+    }
+
+    fn from_parts<I>(values: &mut I) -> Result<Self, kittycad_execution_plan_traits::MemoryError>
+    where
+        I: Iterator<Item = Option<kittycad_execution_plan_traits::Primitive>>,
+    {
+        let variant_name = String::from_parts(values)?;
+        match variant_name.as_str() {
+            stringify!(Line) => {
+                let point = Point3d::from_parts(values)?;
+                Ok(Self::Line { point })
+            }
+            other => Err(
+                kittycad_execution_plan_traits::MemoryError::InvalidEnumVariant {
+                    expected_type: stringify!(Segment).to_owned(),
+                    actual: other.to_owned(),
+                },
+            ),
+        }
+    }
+}
+

execution-plan-macros/tests/main.rs

@@ -1,16 +1,4 @@
 use kittycad_execution_plan_macros::ExecutionPlanValue;
-use kittycad_execution_plan_traits::{Primitive, Value};
-
-#[derive(ExecutionPlanValue)]
-struct FooGenericWithDefault<T = f32>
-where
-    Primitive: From<T>,
-    T: Value,
-{
-    f: f64,
-    i: usize,
-    t: T,
-}
 
 #[derive(ExecutionPlanValue)]
 struct FooConcrete {
@@ -25,3 +13,19 @@ enum FooEnum {
     C(usize, String, f64, f32),
     D,
 }
+
+mod generics {
+    use kittycad_execution_plan_macros::ExecutionPlanValue;
+    use kittycad_execution_plan_traits::{Primitive, Value};
+
+    #[derive(ExecutionPlanValue)]
+    struct FooGenericWithDefault<T = f32>
+    where
+        Primitive: From<T>,
+        T: Value,
+    {
+        f: f64,
+        i: usize,
+        t: T,
+    }
+}