Add basic From impl generation

Author: Techassi

crates/stackable-versioned/src/attrs/container.rs

@@ -103,4 +103,5 @@ pub(crate) struct VersionAttributes {
 #[derive(Clone, Debug, Default, FromMeta)]
 pub(crate) struct ContainerOptions {
     pub(crate) allow_unsorted: Flag,
+    pub(crate) skip_from: Flag,
 }

crates/stackable-versioned/src/attrs/field.rs

@@ -1,6 +1,6 @@
 use darling::{util::SpannedValue, Error, FromField, FromMeta};
 use k8s_version::Version;
-use syn::{Field, Ident};
+use syn::{Field, Ident, Path};
 
 use crate::{attrs::container::ContainerAttributes, consts::DEPRECATED_PREFIX};
 
@@ -40,6 +40,7 @@ pub(crate) struct FieldAttributes {
 #[derive(Clone, Debug, FromMeta)]
 pub(crate) struct AddedAttributes {
     pub(crate) since: SpannedValue<Version>,
+    pub(crate) default: Option<SpannedValue<Path>>,
 }
 
 #[derive(Clone, Debug, FromMeta)]

crates/stackable-versioned/src/gen/field.rs

@@ -24,8 +24,8 @@ pub(crate) struct VersionedField {
     inner: Field,
 }
 
-impl ToTokensExt for VersionedField {
-    fn to_tokens_for_version(&self, container_version: &ContainerVersion) -> Option<TokenStream> {
+impl ToTokensExt<&ContainerVersion> for VersionedField {
+    fn to_tokens(&self, container_version: &ContainerVersion) -> Option<TokenStream> {
         match &self.chain {
             Some(chain) => {
                 // Check if the provided container version is present in the map

crates/stackable-versioned/src/gen/mod.rs

@@ -7,7 +7,7 @@ use syn::{spanned::Spanned, Data, DeriveInput, Error, Result};
 
 use crate::{
     attrs::container::ContainerAttributes,
-    gen::{venum::VersionedEnum, version::ContainerVersion, vstruct::VersionedStruct},
+    gen::{venum::VersionedEnum, vstruct::VersionedStruct},
 };
 
 pub(crate) mod field;
@@ -33,9 +33,9 @@ pub(crate) fn expand(input: DeriveInput) -> Result<TokenStream> {
 
     // Validate container shape and generate code
     let expanded = match input.data {
-        Data::Struct(data) => {
-            VersionedStruct::new(input.ident, data, attributes)?.to_token_stream()
-        }
+        Data::Struct(data) => VersionedStruct::new(input.ident, data, attributes)?
+            .to_tokens(true)
+            .expect("internal error: must produce tokens for versioned struct"),
         Data::Enum(data) => VersionedEnum::new(input.ident, data, attributes)?.to_token_stream(),
         Data::Union(_) => {
             return Err(Error::new(
@@ -48,8 +48,11 @@ pub(crate) fn expand(input: DeriveInput) -> Result<TokenStream> {
     Ok(expanded)
 }
 
-pub(crate) trait ToTokensExt {
-    fn to_tokens_for_version(&self, version: &ContainerVersion) -> Option<TokenStream>;
+pub(crate) trait ToTokensExt<T>
+where
+    T: Copy,
+{
+    fn to_tokens(&self, state: T) -> Option<TokenStream>;
 }
 
 pub(crate) trait Neighbors<K, V>

crates/stackable-versioned/src/gen/version.rs

@@ -1,6 +1,6 @@
 use k8s_version::Version;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub(crate) struct ContainerVersion {
     pub(crate) deprecated: bool,
     pub(crate) inner: Version,

crates/stackable-versioned/src/gen/vstruct.rs

@@ -1,6 +1,6 @@
 use darling::FromField;
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote, ToTokens};
+use quote::{format_ident, quote};
 use syn::{DataStruct, Ident, Result};
 
 use crate::{
@@ -26,41 +26,82 @@ pub(crate) struct VersionedStruct {
     pub(crate) fields: Vec<VersionedField>,
 }
 
-impl ToTokens for VersionedStruct {
-    fn to_tokens(&self, _tokens: &mut TokenStream) {
-        let mut versions = self.versions.iter().peekable();
+impl ToTokensExt<bool> for VersionedStruct {
+    fn to_tokens(&self, generate_modules: bool) -> Option<TokenStream> {
+        // TODO (@Techassi): This unwrap should be fine, should we expect here?
+        let mut versions = self.versions.clone();
+        versions.pop().unwrap();
+        let mut versions = versions.iter().peekable();
 
+        let mut tokens = TokenStream::new();
+
+        // TODO (@Techassi): Move this into own functions
         while let Some(version) = versions.next() {
-            let mut fields = TokenStream::new();
+            let mut field_tokens = TokenStream::new();
 
             for field in &self.fields {
-                fields.extend(field.to_tokens_for_version(version));
+                field_tokens.extend(field.to_tokens(version));
             }
 
-            // TODO (@Techassi): Make the generation of the module optional to
-            // enable the attribute macro to be applied to a module which
-            // generates versioned versions of all contained containers.
-
-            let deprecated_attr = version.deprecated.then_some(quote! {#[deprecated]});
             let module_name = format_ident!("{version}", version = version.inner.to_string());
+            let deprecated_attr = version.deprecated.then_some(quote! {#[deprecated]});
             let struct_name = &self.ident;
 
-            // Only generate a module when there is at least one more version.
-            // This skips generating a module for the latest version, because
-            // the base struct always represents the latest version.
-            if versions.peek().is_some() {
-                _tokens.extend(quote! {
+            let struct_tokens = quote! {
+                pub struct #struct_name {
+                    #field_tokens
+                }
+            };
+
+            // Only generate modules when asked to do so by the caller. This
+            // enables us the support attribute macros to generate code for
+            // multiple versioned containers in a single file (no module name
+            // collition).
+            if generate_modules {
+                // Only generate a module when there is at least one more
+                // version. This skips generating a module for the latest
+                // version, because the base struct always represents the
+                // latest version.
+                tokens.extend(quote! {
                     #[automatically_derived]
                     #deprecated_attr
                     pub mod #module_name {
-
-                        pub struct #struct_name {
-                            #fields
-                        }
+                        #struct_tokens
                     }
                 });
+
+                if let Some(next) = versions.peek() {
+                    // Generate From<THIS> for NEXT impls
+                    let next_module = format_ident!("{}", next.inner.to_string());
+
+                    let from_impl_tokens = quote! {
+                        #[automatically_derived]
+                        impl From<#module_name::#struct_name> for #next_module::#struct_name {
+                            fn from(from: #module_name::#struct_name) -> Self {
+                                todo!();
+                            }
+                        }
+                    };
+
+                    tokens.extend(from_impl_tokens);
+                } else {
+                    let from_impl_tokens = quote! {
+                        #[automatically_derived]
+                        impl From<#module_name::#struct_name> for #struct_name {
+                            fn from(from: #module_name::#struct_name) -> Self {
+                                todo!();
+                            }
+                        }
+                    };
+
+                    tokens.extend(from_impl_tokens);
+                }
+            } else {
+                tokens.extend(struct_tokens)
             }
         }
+
+        Some(tokens)
     }
 }