attempt 2

Author: lilizoey

godot-codegen/src/generator/central_files.rs

@@ -7,7 +7,7 @@
 
 use crate::context::Context;
 use crate::conv;
-use crate::generator::gdext_build_struct;
+use crate::generator::{enums, gdext_build_struct};
 use crate::models::domain::{Enumerator, ExtensionApi};
 use crate::util::ident;
 use proc_macro2::{Ident, Literal, TokenStream};
@@ -265,7 +265,7 @@ fn make_global_enums(api: &ExtensionApi) -> Vec<TokenStream> {
             continue;
         }
 
-        let def = enum_.to_definition();
+        let def = enums::make_enum_definition(enum_);
         global_enum_defs.push(def);
     }
 

godot-codegen/src/generator/enums.rs

@@ -9,212 +9,202 @@
 //!
 //! See also models/domain/enums.rs for other enum-related methods.
 
-use crate::{
-    models::domain::{self, Enum},
-    util::ident,
-};
-use proc_macro2::{Ident, TokenStream};
+use crate::models::domain::{Enum, Enumerator};
+use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 
-pub fn make_enums(enums: &[domain::Enum]) -> TokenStream {
-    let definitions = enums.iter().map(Enum::to_definition);
+pub fn make_enums(enums: &[Enum]) -> TokenStream {
+    let definitions = enums.iter().map(make_enum_definition);
 
     quote! {
         #( #definitions )*
     }
 }
 
-/// Codegen methods.
-impl domain::Enum {
-    /// Creates a definition of this enum.
-    ///
-    /// This will also implement all relevant traits and generate appropriate constants for each enumerator.
-    pub fn to_definition(&self) -> TokenStream {
-        // Things needed for the type definition
-        let derives = self.derives();
-        let enum_doc = self.enum_doc();
-        let name = &self.name;
-
-        // Values
-        let enumerators = self
-            .enumerators
-            .iter()
-            .map(|enumerator| enumerator.to_definition(name.clone().into_token_stream()));
-
-        // Trait implementations
-        let engine_trait_impl = self.to_engine_trait_impl();
-        let index_enum_impl = self.to_index_impl();
-        let bitwise_impls = self.bitwise_operators();
-
-        // Various types
-        let ord_type = self.ord_type();
-        let engine_trait = self.engine_trait();
+/// Creates a definition for the given enum.
+///
+/// This will also implement all relevant traits and generate appropriate constants for each enumerator.
+pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
+    // Things needed for the type definition
+    let derives = enum_.derives();
+    let derives = if !derives.is_empty() {
+        quote! { #[derive( #( #derives )* )]}
+    } else {
+        TokenStream::new()
+    };
+    let enum_doc = make_enum_doc(enum_);
+    let name = &enum_.name;
+
+    // Values
+    let enumerators = enum_
+        .enumerators
+        .iter()
+        .map(|enumerator| make_enumerator_definition(enumerator, name.to_token_stream()));
+
+    // Trait implementations
+    let engine_trait_impl = make_enum_engine_trait_impl(enum_);
+    let index_enum_impl = make_enum_index_impl(enum_);
+    let bitwise_impls = make_enum_bitwise_operators(enum_);
+
+    // Various types
+    let ord_type = enum_.ord_type();
+    let engine_trait = enum_.engine_trait();
 
-        quote! {
-            #[repr(transparent)]
-            #[derive(#( #derives ),*)]
-            #( #[doc = #enum_doc] )*
-            pub struct #name {
-                ord: #ord_type
-            }
+    quote! {
+        #[repr(transparent)]
+        #derives
+        #( #[doc = #enum_doc] )*
+        pub struct #name {
+            ord: #ord_type
+        }
 
-            impl #name {
-                #( #enumerators )*
-            }
+        impl #name {
+            #( #enumerators )*
+        }
 
-            #engine_trait_impl
-            #index_enum_impl
-            #bitwise_impls
+        #engine_trait_impl
+        #index_enum_impl
+        #bitwise_impls
 
-            impl crate::builtin::meta::GodotConvert for #name {
-                type Via = #ord_type;
-            }
+        impl crate::builtin::meta::GodotConvert for #name {
+            type Via = #ord_type;
+        }
 
-            impl crate::builtin::meta::ToGodot for #name {
-                fn to_godot(&self) -> Self::Via {
-                    <Self as #engine_trait>::ord(*self)
-                }
+        impl crate::builtin::meta::ToGodot for #name {
+            fn to_godot(&self) -> Self::Via {
+                <Self as #engine_trait>::ord(*self)
             }
+        }
 
-            impl crate::builtin::meta::FromGodot for #name {
-                fn try_from_godot(via: Self::Via) -> std::result::Result<Self, crate::builtin::meta::ConvertError> {
-                    <Self as #engine_trait>::try_from_ord(via)
-                        .ok_or_else(|| crate::builtin::meta::FromGodotError::InvalidEnum.into_error(via))
-                }
+        impl crate::builtin::meta::FromGodot for #name {
+            fn try_from_godot(via: Self::Via) -> std::result::Result<Self, crate::builtin::meta::ConvertError> {
+                <Self as #engine_trait>::try_from_ord(via)
+                    .ok_or_else(|| crate::builtin::meta::FromGodotError::InvalidEnum.into_error(via))
             }
         }
     }
+}
 
-    /// Creates an implementation of `IndexEnum` for this enum.
-    ///
-    /// Returns `None` if `self` isn't an indexable enum.
-    fn to_index_impl(&self) -> Option<TokenStream> {
-        let enum_max = self.count_index_enum()?;
-        let name = &self.name;
+/// Creates an implementation of `IndexEnum` for the given enum.
+///
+/// Returns `None` if `enum_` isn't an indexable enum.
+fn make_enum_index_impl(enum_: &Enum) -> Option<TokenStream> {
+    let enum_max = enum_.find_index_enum_max()?;
+    let name = &enum_.name;
 
-        Some(quote! {
-            impl crate::obj::IndexEnum for #name {
-                const ENUMERATOR_COUNT: usize = #enum_max;
-            }
-        })
-    }
+    Some(quote! {
+        impl crate::obj::IndexEnum for #name {
+            const ENUMERATOR_COUNT: usize = #enum_max;
+        }
+    })
+}
 
-    /// Creates an implementation of the engine trait for this enum.
-    ///
-    /// This will implement the trait returned by [`Enum::engine_trait`].
-    fn to_engine_trait_impl(&self) -> TokenStream {
-        let name = &self.name;
-        let engine_trait = self.engine_trait();
-
-        if self.is_bitfield {
-            quote! {
-                impl #engine_trait for #name {
-                    fn try_from_ord(ord: u64) -> Option<Self> {
-                        Some(Self { ord })
-                    }
+/// Creates an implementation of the engine trait for the given enum.
+///
+/// This will implement the trait returned by [`Enum::engine_trait`].
+fn make_enum_engine_trait_impl(enum_: &Enum) -> TokenStream {
+    let name = &enum_.name;
+    let engine_trait = enum_.engine_trait();
 
-                    fn ord(self) -> u64 {
-                        self.ord
-                    }
+    if enum_.is_bitfield {
+        quote! {
+            // We may want to add this in the future.
+            //
+            // impl #enum_name {
+            //     pub const UNSET: Self = Self { ord: 0 };
+            // }
+
+            impl #engine_trait for #name {
+                fn try_from_ord(ord: u64) -> Option<Self> {
+                    Some(Self { ord })
+                }
+
+                fn ord(self) -> u64 {
+                    self.ord
                 }
             }
-        } else {
-            let unique_ords = self.unique_ords().expect("self is an enum");
-
-            quote! {
-                impl #engine_trait for #name {
-                    fn try_from_ord(ord: i32) -> Option<Self> {
-                        match ord {
-                            #( ord @ #unique_ords )|* => Some(Self { ord }),
-                            _ => None,
-                        }
-                    }
+        }
+    } else {
+        let unique_ords = enum_.unique_ords().expect("self is an enum");
 
-                    fn ord(self) -> i32 {
-                        self.ord
+        quote! {
+            impl #engine_trait for #name {
+                fn try_from_ord(ord: i32) -> Option<Self> {
+                    match ord {
+                        #( ord @ #unique_ords )|* => Some(Self { ord }),
+                        _ => None,
                     }
                 }
+
+                fn ord(self) -> i32 {
+                    self.ord
+                }
             }
         }
     }
+}
 
-    /// Creates implementations for any bitwise operators.
-    ///
-    /// Currently this is just [`BitOr`](std::ops::BitOr) for bitfields but that could be expanded in the future.
-    fn bitwise_operators(&self) -> TokenStream {
-        let name = &self.name;
+/// Creates implementations for bitwise operators for the given enum.
+///
+/// Currently this is just [`BitOr`](std::ops::BitOr) for bitfields but that could be expanded in the future.
+fn make_enum_bitwise_operators(enum_: &Enum) -> TokenStream {
+    let name = &enum_.name;
 
-        if self.is_bitfield {
-            quote! {
-                impl std::ops::BitOr for #name {
-                    type Output = Self;
+    if enum_.is_bitfield {
+        quote! {
+            impl std::ops::BitOr for #name {
+                type Output = Self;
 
-                    fn bitor(self, rhs: Self) -> Self::Output {
-                        Self { ord: self.ord | rhs.ord }
-                    }
+                fn bitor(self, rhs: Self) -> Self::Output {
+                    Self { ord: self.ord | rhs.ord }
                 }
             }
-        } else {
-            TokenStream::new()
         }
+    } else {
+        TokenStream::new()
     }
-
-    /// Which derives should be implemented for this enum.
-    fn derives(&self) -> Vec<Ident> {
-        let mut derives = vec!["Copy", "Clone", "Eq", "PartialEq", "Hash", "Debug"];
-
-        if self.is_bitfield {
-            derives.push("Default");
-        }
-
-        derives.into_iter().map(ident).collect()
+}
+/// Returns the documentation for the given enum.
+///
+/// Each string is one line of documentation, usually this needs to be wrapped in a `#[doc = ..]`.
+fn make_enum_doc(enum_: &Enum) -> Vec<String> {
+    let mut docs = Vec::new();
+
+    if enum_.name != enum_.godot_name {
+        docs.push(format!("Godot enum name: `{}`.", enum_.godot_name))
     }
 
-    /// Returns the documentation for this enum.
-    ///
-    /// Each string is one line of documentation, usually this needs to be wrapped in a `#[doc = ..]`.
-    fn enum_doc(&self) -> Vec<String> {
-        let mut docs = Vec::new();
-
-        if self.name != self.godot_name {
-            docs.push(format!("Godot enum name: `{}`.", self.godot_name))
-        }
-
-        docs
-    }
+    docs
 }
 
-/// Codegen methods.
-impl domain::Enumerator {
-    /// Creates a `const` definition for self of the type `enum_type`.
-    ///
-    /// That is, it'll be a definition like
-    /// ```ignore
-    /// pub const NAME: enum_type = ..;
-    /// ```
-    fn to_definition(&self, enum_type: TokenStream) -> TokenStream {
-        let Self {
-            name,
-            godot_name,
-            value,
-        } = self;
-
-        let docs = if &name.to_string() != godot_name {
-            let doc = format!("Godot enumerator name: `{godot_name}`");
-
-            quote! {
-                #[doc(alias = #godot_name)]
-                #[doc = #doc]
-            }
-        } else {
-            TokenStream::new()
-        };
+/// Creates a `const` definition for `enumerator` of the type `enum_type`.
+///
+/// That is, it'll be a definition like
+/// ```ignore
+/// pub const NAME: enum_type = ..;
+/// ```
+fn make_enumerator_definition(enumerator: &Enumerator, enum_type: TokenStream) -> TokenStream {
+    let Enumerator {
+        name,
+        godot_name,
+        value,
+    } = enumerator;
+
+    let docs = if &name.to_string() != godot_name {
+        let doc = format!("Godot enumerator name: `{godot_name}`");
 
         quote! {
-            #docs
-            pub const #name: #enum_type = #enum_type {
-                ord: #value
-            };
+            #[doc(alias = #godot_name)]
+            #[doc = #doc]
         }
+    } else {
+        TokenStream::new()
+    };
+
+    quote! {
+        #docs
+        pub const #name: #enum_type = #enum_type {
+            ord: #value
+        };
     }
 }