wip: Refactors

Author: Techassi

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

@@ -6,11 +6,14 @@ use quote::quote;
 use syn::{Generics, ItemEnum};
 
 use crate::{
-    attrs::container::NestedContainerAttributes,
+    attrs::container::ContainerAttributes,
     codegen::{
-        ItemStatus, StandaloneContainerAttributes, VersionDefinition,
+        ItemStatus, VersionDefinition,
         changes::Neighbors,
-        container::{CommonContainerData, Container, ContainerIdents, ContainerOptions, Direction},
+        container::{
+            CommonContainerData, Container, ContainerIdents, ContainerOptions, ContainerTokens,
+            Direction, ExtendContainerTokens, ModuleGenerationContext, VersionContext,
+        },
         item::VersionedVariant,
     },
 };
@@ -27,11 +30,13 @@ impl Container {
         }
 
         let options = ContainerOptions {
-            kubernetes_arguments: None,
-            skip_from: attributes.options.skip.is_some_and(|s| s.from.is_present()),
+            skip_from: attributes.skip.from.is_present(),
+            skip_object_from: attributes.skip.object_from.is_present(),
+            skip_merged_crd: attributes.skip.merged_crd.is_present(),
+            skip_try_convert: attributes.skip.try_convert.is_present(),
         };
 
-        let idents = ContainerIdents::from(item_enum.ident, None);
+        let idents = ContainerIdents::from(item_enum.ident);
 
         let common = CommonContainerData {
             original_attributes: item_enum.attrs,
@@ -62,18 +67,43 @@ pub struct Enum {
 
 // Common token generation
 impl Enum {
+    pub fn generate_tokens<'a>(
+        &'a self,
+        versions: &'a [VersionDefinition],
+        gen_ctx: ModuleGenerationContext<'a>,
+    ) -> ContainerTokens<'a> {
+        let mut versions = versions.iter().peekable();
+        let mut container_tokens = ContainerTokens::default();
+
+        while let Some(version) = versions.next() {
+            let next_version = versions.peek().copied();
+            let ver_ctx = VersionContext::new(version, next_version);
+
+            let enum_definition = self.generate_definition(ver_ctx);
+            let upgrade_from = self.generate_from_impl(Direction::Upgrade, ver_ctx, gen_ctx);
+            let downgrade_from = self.generate_from_impl(Direction::Downgrade, ver_ctx, gen_ctx);
+
+            container_tokens
+                .extend_inner(&version.inner, enum_definition)
+                .extend_between(&version.inner, upgrade_from)
+                .extend_between(&version.inner, downgrade_from);
+        }
+
+        container_tokens
+    }
+
     /// Generates code for the enum definition.
-    pub fn generate_definition(&self, version: &VersionDefinition) -> TokenStream {
+    pub fn generate_definition(&self, ver_ctx: VersionContext<'_>) -> TokenStream {
         let where_clause = self.generics.where_clause.as_ref();
         let type_generics = &self.generics;
 
         let original_attributes = &self.common.original_attributes;
         let ident = &self.common.idents.original;
-        let version_docs = &version.docs;
+        let version_docs = &ver_ctx.version.docs;
 
         let mut variants = TokenStream::new();
         for variant in &self.variants {
-            variants.extend(variant.generate_for_container(version));
+            variants.extend(variant.generate_for_container(ver_ctx.version));
         }
 
         quote! {
@@ -89,15 +119,16 @@ impl Enum {
     pub fn generate_from_impl(
         &self,
         direction: Direction,
-        version: &VersionDefinition,
-        next_version: Option<&VersionDefinition>,
-        add_attributes: bool,
+        ver_ctx: VersionContext<'_>,
+        gen_ctx: ModuleGenerationContext<'_>,
     ) -> Option<TokenStream> {
-        if version.skip_from || self.common.options.skip_from {
+        if ver_ctx.version.skip_from || self.common.options.skip_from {
             return None;
         }
 
-        next_version.map(|next_version| {
+        let version = ver_ctx.version;
+
+        ver_ctx.next_version.map(|next_version| {
             // TODO (@Techassi): Support generic types which have been removed in newer versions,
             // but need to exist for older versions How do we represent that? Because the
             // defined struct always represents the latest version. I guess we could generally
@@ -118,7 +149,7 @@ impl Enum {
 
             // Only add the #[automatically_derived] attribute only if this impl is used
             // outside of a module (in standalone mode).
-            let automatically_derived = add_attributes
+            let automatically_derived = gen_ctx.add_attributes
                 .not()
                 .then(|| quote! {#[automatically_derived]});
 

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

@@ -1,12 +1,18 @@
-use darling::{Result, util::IdentString};
-use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote};
-use syn::{Attribute, Ident, ItemEnum, ItemStruct, Visibility};
+use std::collections::HashMap;
+
+use darling::util::IdentString;
+use k8s_version::Version;
+use proc_macro2::{Span, TokenStream, TokenTree};
+use quote::format_ident;
+use syn::{Attribute, Ident, Visibility};
 
 use crate::{
-    attrs::container::{StandaloneContainerAttributes, k8s::KubernetesArguments},
+    attrs::{
+        container::StructCrdArguments,
+        module::{CrateArguments, KubernetesConfigOptions, ModuleSkipArguments},
+    },
     codegen::{
-        KubernetesTokens, VersionDefinition,
+        VersionDefinition,
         container::{r#enum::Enum, r#struct::Struct},
     },
     utils::ContainerIdentExt,
@@ -37,57 +43,117 @@ pub enum Container {
     Enum(Enum),
 }
 
-impl Container {
-    /// Generates the container definition for the specified `version`.
-    pub fn generate_definition(&self, version: &VersionDefinition) -> TokenStream {
-        match self {
-            Container::Struct(s) => s.generate_definition(version),
-            Container::Enum(e) => e.generate_definition(version),
-        }
+#[derive(Debug, Default)]
+pub struct ContainerTokens<'a> {
+    pub versioned: HashMap<&'a Version, VersionedContainerTokens>,
+    pub outer: TokenStream,
+}
+
+#[derive(Debug, Default)]
+/// A collection of generated tokens for a container per version.
+pub struct VersionedContainerTokens {
+    /// The inner tokens are placed inside the version module. These tokens mostly only include the
+    /// container definition with attributes, doc comments, etc.
+    pub inner: TokenStream,
+
+    /// These tokens are placed between version modules. These could technically be grouped together
+    /// with the outer tokens, but it makes sense to keep them separate to achieve a more structured
+    /// code generation. These tokens mostly only include `From` impls to convert between two versions
+    pub between: TokenStream,
+}
+
+pub trait ExtendContainerTokens<'a, T> {
+    fn extend_inner<I: IntoIterator<Item = T>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self;
+    fn extend_between<I: IntoIterator<Item = T>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self;
+    fn extend_outer<I: IntoIterator<Item = T>>(&mut self, streams: I) -> &mut Self;
+}
+
+impl<'a> ExtendContainerTokens<'a, TokenStream> for ContainerTokens<'a> {
+    fn extend_inner<I: IntoIterator<Item = TokenStream>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self {
+        self.versioned
+            .entry(version)
+            .or_default()
+            .inner
+            .extend(streams);
+        self
     }
 
-    pub fn generate_from_impl(
-        &self,
-        direction: Direction,
-        version: &VersionDefinition,
-        next_version: Option<&VersionDefinition>,
-        add_attributes: bool,
-    ) -> Option<TokenStream> {
-        match self {
-            Container::Struct(s) => {
-                // TODO (@Techassi): Decide here (based on K8s args) what we want to generate
-                s.generate_from_impl(direction, version, next_version, add_attributes)
-            }
-            Container::Enum(e) => {
-                e.generate_from_impl(direction, version, next_version, add_attributes)
-            }
-        }
+    fn extend_between<I: IntoIterator<Item = TokenStream>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self {
+        self.versioned
+            .entry(version)
+            .or_default()
+            .between
+            .extend(streams);
+        self
     }
 
-    /// Generates Kubernetes specific code for the container.
-    ///
-    /// This includes CRD merging, CRD conversion, and the conversion tracking status struct.
-    pub fn generate_kubernetes_code(
-        &self,
-        versions: &[VersionDefinition],
-        tokens: &KubernetesTokens,
-        vis: &Visibility,
-        is_nested: bool,
-    ) -> Option<TokenStream> {
-        match self {
-            Container::Struct(s) => s.generate_kubernetes_code(versions, tokens, vis, is_nested),
-            Container::Enum(_) => None,
-        }
+    fn extend_outer<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) -> &mut Self {
+        self.outer.extend(streams);
+        self
+    }
+}
+
+impl<'a> ExtendContainerTokens<'a, TokenTree> for ContainerTokens<'a> {
+    fn extend_inner<I: IntoIterator<Item = TokenTree>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self {
+        self.versioned
+            .entry(version)
+            .or_default()
+            .inner
+            .extend(streams);
+        self
+    }
+
+    fn extend_between<I: IntoIterator<Item = TokenTree>>(
+        &mut self,
+        version: &'a Version,
+        streams: I,
+    ) -> &mut Self {
+        self.versioned
+            .entry(version)
+            .or_default()
+            .between
+            .extend(streams);
+        self
     }
 
-    /// Generates KUbernetes specific code for individual versions.
-    pub fn generate_kubernetes_version_items(
-        &self,
-        version: &VersionDefinition,
-    ) -> Option<(TokenStream, IdentString, TokenStream, String)> {
+    fn extend_outer<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) -> &mut Self {
+        self.outer.extend(streams);
+        self
+    }
+}
+
+impl Container {
+    // TODO (@Techassi): Only have a single function here. It should return and store all generated
+    // tokens. It should also have access to a single GenerationContext, which provides all external
+    // parameters which influence code generation.
+    pub fn generate_tokens<'a>(
+        &'a self,
+        versions: &'a [VersionDefinition],
+        ctx: ModuleGenerationContext<'a>,
+    ) -> ContainerTokens<'a> {
         match self {
-            Container::Struct(s) => s.generate_kubernetes_version_items(version),
-            Container::Enum(_) => None,
+            Container::Struct(s) => s.generate_tokens(versions, ctx),
+            Container::Enum(e) => e.generate_tokens(versions, ctx),
         }
     }
 
@@ -162,12 +228,43 @@ impl KubernetesIdents {
 
 #[derive(Debug)]
 pub struct ContainerOptions {
-    pub kubernetes_arguments: Option<KubernetesArguments>,
     pub skip_from: bool,
+    pub skip_object_from: bool,
+    pub skip_merged_crd: bool,
+    pub skip_try_convert: bool,
 }
 
+/// Describes the direction of [`From`] implementations.
 #[derive(Copy, Clone, Debug)]
 pub enum Direction {
     Upgrade,
     Downgrade,
 }
+
+#[derive(Clone, Copy, Debug)]
+pub struct ModuleGenerationContext<'a> {
+    pub kubernetes_options: &'a KubernetesConfigOptions,
+    pub skip: &'a ModuleSkipArguments,
+    pub crates: &'a CrateArguments,
+    pub vis: &'a Visibility,
+
+    pub add_attributes: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct VersionContext<'a> {
+    pub version: &'a VersionDefinition,
+    pub next_version: Option<&'a VersionDefinition>,
+}
+
+impl<'a> VersionContext<'a> {
+    pub fn new(
+        version: &'a VersionDefinition,
+        next_version: Option<&'a VersionDefinition>,
+    ) -> Self {
+        Self {
+            version,
+            next_version,
+        }
+    }
+}