feat(stackable-versioned): Generate downgrade From impls

Author: Techassi

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

@@ -240,13 +240,13 @@ impl CommonItemAttributes {
 
             // The convert_with argument only makes sense to use when the
             // type changed
-            if let Some(convert_func) = change.convert_with.as_ref() {
+            if let Some(upgrade_func) = change.upgrade_with.as_ref() {
                 if change.from_type.is_none() {
                     errors.push(
                         Error::custom(
                             "the `convert_with` argument must be used in combination with `from_type`",
                         )
-                        .with_span(&convert_func.span()),
+                        .with_span(&upgrade_func.span()),
                     );
                 }
             }
@@ -315,7 +315,8 @@ impl CommonItemAttributes {
                     .unwrap_or(ty.clone());
 
                 actions.insert(*change.since, ItemStatus::Change {
-                    convert_with: change.convert_with.as_deref().cloned(),
+                    downgrade_with: change.downgrade_with.as_deref().cloned(),
+                    upgrade_with: change.upgrade_with.as_deref().cloned(),
                     from_ident: from_ident.clone(),
                     from_type: from_ty.clone(),
                     to_ident: ident,
@@ -359,7 +360,8 @@ impl CommonItemAttributes {
                     .unwrap_or(ty.clone());
 
                 actions.insert(*change.since, ItemStatus::Change {
-                    convert_with: change.convert_with.as_deref().cloned(),
+                    downgrade_with: change.downgrade_with.as_deref().cloned(),
+                    upgrade_with: change.upgrade_with.as_deref().cloned(),
                     from_ident: from_ident.clone(),
                     from_type: from_ty.clone(),
                     to_ident: ident,
@@ -435,7 +437,8 @@ pub struct ChangedAttributes {
     pub since: SpannedValue<Version>,
     pub from_name: Option<SpannedValue<String>>,
     pub from_type: Option<SpannedValue<Type>>,
-    pub convert_with: Option<SpannedValue<Path>>,
+    pub upgrade_with: Option<SpannedValue<Path>>,
+    pub downgrade_with: Option<SpannedValue<Path>>,
 }
 
 /// For the deprecated() action

crates/stackable-versioned-macros/src/codegen/container/enum.rs

@@ -1,6 +1,6 @@
 use std::ops::Not;
 
-use darling::{FromAttributes, Result, util::IdentString};
+use darling::{FromAttributes, Result};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Generics, ItemEnum};
@@ -126,11 +126,11 @@ impl Enum {
     }
 
     /// Generates code for the `From<Version> for NextVersion` implementation.
-    pub(crate) fn generate_from_impl(
+    pub fn generate_upgrade_from_impl(
         &self,
         version: &VersionDefinition,
         next_version: Option<&VersionDefinition>,
-        is_nested: bool,
+        add_attributes: bool,
     ) -> Option<TokenStream> {
         if version.skip_from || self.common.options.skip_from {
             return None;
@@ -145,12 +145,17 @@ impl Enum {
                 // later versions.
                 let (impl_generics, type_generics, where_clause) = self.generics.split_for_impl();
                 let enum_ident = &self.common.idents.original;
-                let from_ident = &self.common.idents.from;
+                let from_enum_ident = &self.common.idents.from;
 
-                let next_version_ident = &next_version.ident;
-                let version_ident = &version.ident;
+                let for_module_ident = &next_version.ident;
+                let from_module_ident = &version.ident;
 
-                let variants = self.generate_from_variants(version, next_version, enum_ident);
+                let variants: TokenStream = self
+                    .variants
+                    .iter()
+                    .map(|v| v.generate_for_upgrade_from_impl(version, next_version, enum_ident))
+                    .flatten()
+                    .collect();
 
                 // Include allow(deprecated) only when this or the next version is
                 // deprecated. Also include it, when a variant in this or the next
@@ -163,17 +168,18 @@ impl Enum {
 
                 // Only add the #[automatically_derived] attribute only if this impl is used
                 // outside of a module (in standalone mode).
-                let automatically_derived =
-                    is_nested.not().then(|| quote! {#[automatically_derived]});
+                let automatically_derived = add_attributes
+                    .not()
+                    .then(|| quote! {#[automatically_derived]});
 
                 Some(quote! {
                     #automatically_derived
                     #allow_attribute
-                    impl #impl_generics ::std::convert::From<#version_ident::#enum_ident #type_generics> for #next_version_ident::#enum_ident #type_generics
+                    impl #impl_generics ::std::convert::From<#from_module_ident::#enum_ident #type_generics> for #for_module_ident::#enum_ident #type_generics
                         #where_clause
                     {
-                        fn from(#from_ident: #version_ident::#enum_ident #type_generics) -> Self {
-                            match #from_ident {
+                        fn from(#from_enum_ident: #from_module_ident::#enum_ident #type_generics) -> Self {
+                            match #from_enum_ident {
                                 #variants
                             }
                         }
@@ -184,20 +190,53 @@ impl Enum {
         }
     }
 
-    /// Generates code for enum variants used in `From` implementations.
-    fn generate_from_variants(
+    pub fn generate_downgrade_from_impl(
         &self,
         version: &VersionDefinition,
-        next_version: &VersionDefinition,
-        enum_ident: &IdentString,
-    ) -> TokenStream {
-        let mut tokens = TokenStream::new();
-
-        for variant in &self.variants {
-            tokens.extend(variant.generate_for_from_impl(version, next_version, enum_ident));
+        next_version: Option<&VersionDefinition>,
+        add_attributes: bool,
+    ) -> Option<TokenStream> {
+        if version.skip_from || self.common.options.skip_from {
+            return None;
         }
 
-        tokens
+        match next_version {
+            Some(next_version) => {
+                let (impl_generics, type_generics, where_clause) = self.generics.split_for_impl();
+                let enum_ident = &self.common.idents.original;
+                let from_enum_ident = &self.common.idents.from;
+
+                let for_module_ident = &version.ident;
+                let from_module_ident = &next_version.ident;
+
+                let variants: TokenStream = self
+                    .variants
+                    .iter()
+                    .map(|v| v.generate_for_downgrade_from_impl(version, next_version, enum_ident))
+                    .flatten()
+                    .collect();
+
+                // Only add the #[automatically_derived] attribute only if this impl is used
+                // outside of a module (in standalone mode).
+                let automatically_derived = add_attributes
+                    .not()
+                    .then(|| quote! {#[automatically_derived]});
+
+                Some(quote! {
+                    #automatically_derived
+                    impl #impl_generics ::std::convert::From<#from_module_ident::#enum_ident #type_generics> for #for_module_ident::#enum_ident #type_generics
+                        #where_clause
+                    {
+                        fn from(#from_enum_ident: #from_module_ident::#enum_ident #type_generics) -> Self {
+                            match #from_enum_ident {
+                                #variants
+                            }
+                        }
+                    }
+                })
+            }
+            None => None,
+        }
     }
 
     /// Returns whether any variant is deprecated in the provided `version`.

crates/stackable-versioned-macros/src/codegen/container/mod.rs

@@ -21,7 +21,7 @@ mod r#enum;
 mod r#struct;
 
 /// Contains common container data shared between structs and enums.
-pub(crate) struct CommonContainerData {
+pub struct CommonContainerData {
     /// Original attributes placed on the container, like `#[derive()]` or `#[cfg()]`.
     pub(crate) original_attributes: Vec<Attribute>,
 
@@ -37,7 +37,7 @@ pub(crate) struct CommonContainerData {
 /// Abstracting away with kind of container is generated makes it possible to create a list of
 /// containers when the macro is used on modules. This enum provides functions to generate code
 /// which then internally call the appropriate function based on the variant.
-pub(crate) enum Container {
+pub enum Container {
     Struct(Struct),
     Enum(Enum),
 }
@@ -51,16 +51,37 @@ impl Container {
         }
     }
 
-    /// Generates the container `From<Version> for NextVersion` implementation.
-    pub(crate) fn generate_from_impl(
+    /// Generates the `From<Version> for NextVersion` implementation for the container.
+    pub fn generate_upgrade_from_impl(
         &self,
         version: &VersionDefinition,
         next_version: Option<&VersionDefinition>,
         add_attributes: bool,
     ) -> Option<TokenStream> {
         match self {
-            Container::Struct(s) => s.generate_from_impl(version, next_version, add_attributes),
-            Container::Enum(e) => e.generate_from_impl(version, next_version, add_attributes),
+            Container::Struct(s) => {
+                s.generate_upgrade_from_impl(version, next_version, add_attributes)
+            }
+            Container::Enum(e) => {
+                e.generate_upgrade_from_impl(version, next_version, add_attributes)
+            }
+        }
+    }
+
+    /// Generates the `From<NextVersion> for Version` implementation for the container.
+    pub fn generate_downgrade_from_impl(
+        &self,
+        version: &VersionDefinition,
+        next_version: Option<&VersionDefinition>,
+        add_attributes: bool,
+    ) -> Option<TokenStream> {
+        match self {
+            Container::Struct(s) => {
+                s.generate_downgrade_from_impl(version, next_version, add_attributes)
+            }
+            Container::Enum(e) => {
+                e.generate_downgrade_from_impl(version, next_version, add_attributes)
+            }
         }
     }
 
@@ -180,9 +201,17 @@ impl StandaloneContainer {
 
             // NOTE (@Techassi): Using '.copied()' here does not copy or clone the data, but instead
             // removes one level of indirection of the double reference '&&'.
-            let from_impl =
+            let next_version = versions.peek().copied();
+
+            // Generate the From impl for upgrading the CRD.
+            let upgrade_from_impl =
+                self.container
+                    .generate_upgrade_from_impl(version, next_version, false);
+
+            // Generate the From impl for downgrading the CRD.
+            let downgrade_from_impl =
                 self.container
-                    .generate_from_impl(version, versions.peek().copied(), false);
+                    .generate_downgrade_from_impl(version, next_version, false);
 
             // Add the #[deprecated] attribute when the version is marked as deprecated.
             let deprecated_attribute = version
@@ -210,7 +239,8 @@ impl StandaloneContainer {
                     #container_definition
                 }
 
-                #from_impl
+                #upgrade_from_impl
+                #downgrade_from_impl
             });
         }
 
@@ -231,13 +261,13 @@ impl StandaloneContainer {
 pub(crate) struct ContainerIdents {
     /// The ident used in the context of Kubernetes specific code. This ident
     /// removes the 'Spec' suffix present in the definition container.
-    pub(crate) kubernetes: IdentString,
+    pub kubernetes: IdentString,
 
     /// The original ident, or name, of the versioned container.
-    pub(crate) original: IdentString,
+    pub original: IdentString,
 
     /// The ident used in the [`From`] impl.
-    pub(crate) from: IdentString,
+    pub from: IdentString,
 }
 
 impl ContainerIdents {
@@ -261,32 +291,32 @@ impl ContainerIdents {
 }
 
 #[derive(Debug)]
-pub(crate) struct ContainerOptions {
-    pub(crate) kubernetes_options: Option<KubernetesOptions>,
-    pub(crate) skip_from: bool,
+pub struct ContainerOptions {
+    pub kubernetes_options: Option<KubernetesOptions>,
+    pub skip_from: bool,
 }
 
 #[derive(Debug)]
-pub(crate) struct KubernetesOptions {
-    pub(crate) group: String,
-    pub(crate) kind: Option<String>,
-    pub(crate) singular: Option<String>,
-    pub(crate) plural: Option<String>,
-    pub(crate) namespaced: bool,
+pub struct KubernetesOptions {
+    pub group: String,
+    pub kind: Option<String>,
+    pub singular: Option<String>,
+    pub plural: Option<String>,
+    pub namespaced: bool,
     // root
-    pub(crate) crates: KubernetesCrateOptions,
-    pub(crate) status: Option<Path>,
+    pub crates: KubernetesCrateOptions,
+    pub status: Option<Path>,
     // derive
     // schema
     // scale
     // printcolumn
-    pub(crate) shortnames: Vec<String>,
+    pub shortnames: Vec<String>,
     // category
     // selectable
     // doc
     // annotation
     // label
-    pub(crate) skip_merged_crd: bool,
+    pub skip_merged_crd: bool,
 }
 
 impl From<KubernetesArguments> for KubernetesOptions {
@@ -308,12 +338,12 @@ impl From<KubernetesArguments> for KubernetesOptions {
 }
 
 #[derive(Debug)]
-pub(crate) struct KubernetesCrateOptions {
-    pub(crate) kube_core: Override<Path>,
-    pub(crate) k8s_openapi: Override<Path>,
-    pub(crate) schemars: Override<Path>,
-    pub(crate) serde: Override<Path>,
-    pub(crate) serde_json: Override<Path>,
+pub struct KubernetesCrateOptions {
+    pub kube_core: Override<Path>,
+    pub k8s_openapi: Override<Path>,
+    pub schemars: Override<Path>,
+    pub serde: Override<Path>,
+    pub serde_json: Override<Path>,
 }
 
 impl Default for KubernetesCrateOptions {
@@ -396,7 +426,7 @@ impl ToTokens for KubernetesCrateOptions {
 
 /// Wraps a value to indicate whether it is original or has been overridden.
 #[derive(Debug)]
-pub(crate) enum Override<T> {
+pub enum Override<T> {
     Default(T),
     Overridden(T),
 }