feat: Basic support for type changes

The current implementation is very brittle and less
than ideal. It currently only produces correct code
in the struct definitions, but not in the From impls.
For that reason, test files currently skip the From
impl generation.

I have a bunch of thoughts on how to improve the
situation, but I would like to tackle these changes
in follow-up commits.

Author: Techassi

crates/stackable-versioned-macros/src/attrs/common/item.rs

@@ -97,6 +97,11 @@ pub(crate) enum ItemType {
     Variant,
 }
 
+// TODO (@Techassi): Shower thought: Track actions as a Vec of an ActionAttribute
+// enum and implement Ord on it. This would allow us to order the items by type
+// of action (added < changed < deprecated) as well as sort changed action to
+// each other by specified version (which already implements Ord)
+
 /// These attributes are meant to be used in super structs, which add
 /// [`Field`](syn::Field) or [`Variant`](syn::Variant) specific attributes via
 /// darling's flatten feature. This struct only provides shared attributes.

crates/stackable-versioned-macros/src/codegen/common/item.rs

@@ -1,7 +1,7 @@
 use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};
 
 use quote::format_ident;
-use syn::{spanned::Spanned, Attribute, Ident, Path};
+use syn::{spanned::Spanned, Attribute, Ident, Path, Type};
 
 use crate::{
     attrs::common::{ContainerAttributes, ItemAttributes, ValidateVersions},
@@ -21,7 +21,7 @@ use crate::{
 pub(crate) trait Item<I, A>: Sized
 where
     A: for<'i> TryFrom<&'i I> + Attributes,
-    I: Named + Spanned,
+    I: InnerItem,
 {
     /// Creates a new versioned item (struct field or enum variant) by consuming
     /// the parsed [Field](syn::Field) or [Variant](syn::Variant) and validating
@@ -43,6 +43,10 @@ where
     fn get_ident(&self, version: &ContainerVersion) -> Option<&Ident>;
 }
 
+pub(crate) trait InnerItem: Named + Spanned {
+    fn ty(&self) -> Type;
+}
+
 /// This trait enables access to the ident of named items, like fields and
 /// variants.
 ///
@@ -87,7 +91,7 @@ pub(crate) trait Attributes {
 pub(crate) struct VersionedItem<I, A>
 where
     A: for<'i> TryFrom<&'i I> + Attributes,
-    I: Named + Spanned,
+    I: InnerItem,
 {
     pub(crate) original_attributes: Vec<Attribute>,
     pub(crate) chain: Option<VersionChain>,
@@ -99,7 +103,7 @@ impl<I, A> Item<I, A> for VersionedItem<I, A>
 where
     syn::Error: for<'i> From<<A as TryFrom<&'i I>>::Error>,
     A: for<'i> TryFrom<&'i I> + Attributes + ValidateVersions<I>,
-    I: Named + Spanned,
+    I: InnerItem,
 {
     fn new(item: I, container_attrs: &ContainerAttributes) -> syn::Result<Self> {
         // We use the TryFrom trait here, because the type parameter `A` can use
@@ -135,6 +139,8 @@ where
             // requires access to the item ident to infer the item ident for
             // the latest change.
             let mut ident = item.cleaned_ident();
+            let mut ty = item.ty();
+
             let mut actions = BTreeMap::new();
 
             actions.insert(
@@ -147,20 +153,33 @@ where
             );
 
             for change in common_attributes.changes.iter().rev() {
-                let from = if let Some(from) = change.from_name.as_deref() {
+                dbg!(&ty, &change.since);
+                let from_ident = if let Some(from) = change.from_name.as_deref() {
                     format_ident!("{from}")
                 } else {
                     ident.clone()
                 };
 
+                // TODO (@Techassi): This is an awful lot of cloning, can we get
+                // rid of it?
+                let from_ty = change
+                    .from_type
+                    .as_ref()
+                    .map(|sv| sv.deref().clone())
+                    .unwrap_or(ty.clone());
+
                 actions.insert(
                     *change.since,
                     ItemStatus::Change {
-                        from_ident: from.clone(),
+                        from_ident: from_ident.clone(),
                         to_ident: ident,
+                        from_type: from_ty.clone(),
+                        to_type: ty,
                     },
                 );
-                ident = from;
+
+                ident = from_ident;
+                ty = from_ty;
             }
 
             // After the last iteration above (if any) we use the ident for the
@@ -171,6 +190,7 @@ where
                     ItemStatus::Addition {
                         default_fn: added.default_fn.deref().clone(),
                         ident,
+                        ty,
                     },
                 );
             }
@@ -182,24 +202,39 @@ where
                 inner: item,
             })
         } else if !common_attributes.changes.is_empty() {
-            let mut actions = BTreeMap::new();
             let mut ident = item.ident().clone();
+            let mut ty = item.ty();
+
+            let mut actions = BTreeMap::new();
 
             for change in common_attributes.changes.iter().rev() {
-                let from = if let Some(from) = change.from_name.as_deref() {
+                dbg!(&ty, &change.since);
+                let from_ident = if let Some(from) = change.from_name.as_deref() {
                     format_ident!("{from}")
                 } else {
                     ident.clone()
                 };
 
+                // TODO (@Techassi): This is an awful lot of cloning, can we get
+                // rid of it?
+                let from_ty = change
+                    .from_type
+                    .as_ref()
+                    .map(|sv| sv.deref().clone())
+                    .unwrap_or(ty.clone());
+
                 actions.insert(
                     *change.since,
                     ItemStatus::Change {
-                        from_ident: from.clone(),
+                        from_ident: from_ident.clone(),
                         to_ident: ident,
+                        from_type: from_ty.clone(),
+                        to_type: ty,
                     },
                 );
-                ident = from;
+
+                ident = from_ident;
+                ty = from_ty;
             }
 
             // After the last iteration above (if any) we use the ident for the
@@ -210,6 +245,7 @@ where
                     ItemStatus::Addition {
                         default_fn: added.default_fn.deref().clone(),
                         ident,
+                        ty,
                     },
                 );
             }
@@ -229,6 +265,7 @@ where
                     ItemStatus::Addition {
                         default_fn: added.default_fn.deref().clone(),
                         ident: item.ident().clone(),
+                        ty: item.ty(),
                     },
                 );
 
@@ -314,10 +351,15 @@ pub(crate) enum ItemStatus {
     Addition {
         ident: Ident,
         default_fn: Path,
+        // NOTE (@Techassi): We need to carry idents and type information in
+        // nearly every status. Ideally, we would store this in separate maps.
+        ty: Type,
     },
     Change {
         from_ident: Ident,
         to_ident: Ident,
+        from_type: Type,
+        to_type: Type,
     },
     Deprecation {
         previous_ident: Ident,

crates/stackable-versioned-macros/src/codegen/venum/variant.rs

@@ -1,9 +1,9 @@
 use std::ops::{Deref, DerefMut};
 
 use darling::FromVariant;
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
-use syn::{Ident, Variant};
+use syn::{token::Not, Ident, Type, TypeNever, Variant};
 
 use crate::{
     attrs::{
@@ -13,8 +13,8 @@ use crate::{
     codegen::{
         chain::BTreeMapExt,
         common::{
-            remove_deprecated_variant_prefix, Attributes, ContainerVersion, Item, ItemStatus,
-            Named, VersionedItem,
+            remove_deprecated_variant_prefix, Attributes, ContainerVersion, InnerItem, Item,
+            ItemStatus, Named, VersionedItem,
         },
     },
 };
@@ -64,6 +64,17 @@ impl Attributes for VariantAttributes {
     }
 }
 
+impl InnerItem for Variant {
+    fn ty(&self) -> syn::Type {
+        // FIXME (@Techassi): As we currently don't support enum variants with
+        // data, we just return the Never type as the code generation code for
+        // enum variants won't use this type information.
+        Type::Never(TypeNever {
+            bang_token: Not([Span::call_site()]),
+        })
+    }
+}
+
 impl Named for Variant {
     fn cleaned_ident(&self) -> Ident {
         remove_deprecated_variant_prefix(self.ident())

crates/stackable-versioned-macros/src/codegen/vstruct/field.rs

@@ -11,8 +11,8 @@ use crate::{
         field::FieldAttributes,
     },
     codegen::common::{
-        remove_deprecated_field_prefix, Attributes, ContainerVersion, Item, ItemStatus, Named,
-        VersionedItem,
+        remove_deprecated_field_prefix, Attributes, ContainerVersion, InnerItem, Item, ItemStatus,
+        Named, VersionedItem,
     },
 };
 
@@ -63,6 +63,12 @@ impl Attributes for FieldAttributes {
     }
 }
 
+impl InnerItem for Field {
+    fn ty(&self) -> syn::Type {
+        self.ty.clone()
+    }
+}
+
 impl Named for Field {
     fn cleaned_ident(&self) -> Ident {
         let ident = self.ident();
@@ -115,13 +121,15 @@ impl VersionedField {
                         container_version.inner
                     )
                 }) {
-                    ItemStatus::Addition { ident, .. } => Some(quote! {
+                    ItemStatus::Addition { ident, ty, .. } => Some(quote! {
                         #(#original_attributes)*
-                        pub #ident: #field_type,
+                        pub #ident: #ty,
                     }),
-                    ItemStatus::Change { to_ident, .. } => Some(quote! {
+                    ItemStatus::Change {
+                        to_ident, to_type, ..
+                    } => Some(quote! {
                         #(#original_attributes)*
-                        pub #to_ident: #field_type,
+                        pub #to_ident: #to_type,
                     }),
                     ItemStatus::Deprecation {
                         ident: field_ident,
@@ -170,7 +178,12 @@ impl VersionedField {
                         .get(&next_version.inner)
                         .expect("internal error: chain must contain container version"),
                 ) {
-                    (_, ItemStatus::Addition { ident, default_fn }) => quote! {
+                    (
+                        _,
+                        ItemStatus::Addition {
+                            ident, default_fn, ..
+                        },
+                    ) => quote! {
                         #ident: #default_fn(),
                     },
                     (old, next) => {

crates/stackable-versioned-macros/tests/good/basic.rs

@@ -9,7 +9,8 @@ use stackable_versioned_macros::versioned;
     version(name = "v1beta1"),
     version(name = "v1"),
     version(name = "v2"),
-    version(name = "v3")
+    version(name = "v3"),
+    options(skip(from))
 )]
 pub(crate) struct Foo {
     #[versioned(