Treat VariantType and VariantOperator like regular engine enums

Avoids two separate code paths for enum codegen, and makes sure the generated API is the same
(e.g. EngineEnum, IndexEnum traits).

VariantType requires still a bit of special handling, as its definition must be available in
godot-ffi, while the trait impls are only written in godot-core. Thus, the codegen is split.

Retains deprecation for old VariantType and VariantOperator enumerators.

Author: Bromeon

godot-codegen/src/generator/central_files.rs

@@ -8,26 +8,18 @@
 use crate::context::Context;
 use crate::conv;
 use crate::generator::{enums, gdext_build_struct};
-use crate::models::domain::{Enumerator, ExtensionApi};
+use crate::models::domain::ExtensionApi;
 use crate::util::ident;
-use proc_macro2::{Ident, Literal, TokenStream};
+use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote, ToTokens};
 
-pub fn make_sys_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStream {
-    let VariantEnums {
-        variant_ty_enumerators_pascal,
-        variant_ty_enumerators_ord,
-        variant_op_enumerators_pascal,
-        variant_op_enumerators_ord,
-        ..
-    } = make_variant_enums(api, ctx);
-
+pub fn make_sys_central_code(api: &ExtensionApi) -> TokenStream {
     let build_config_struct = gdext_build_struct::make_gdext_build_struct(&api.godot_version);
+    let (variant_type_enum, variant_type_deprecated_enumerators) =
+        make_variant_type_enum(api, true);
     let [opaque_32bit, opaque_64bit] = make_opaque_types(api);
 
     quote! {
-        use crate::{GDExtensionVariantOperator, GDExtensionVariantType};
-
         #[cfg(target_pointer_width = "32")]
         pub mod types {
             #(#opaque_32bit)*
@@ -37,66 +29,24 @@ pub fn make_sys_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStre
             #(#opaque_64bit)*
         }
 
-
         // ----------------------------------------------------------------------------------------------------------------------------------------------
 
         #build_config_struct
-
-        // ----------------------------------------------------------------------------------------------------------------------------------------------
-
-        #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-        #[repr(i32)]
-        pub enum VariantType {
-            Nil = 0,
-            #(
-                #variant_ty_enumerators_pascal = #variant_ty_enumerators_ord,
-            )*
-        }
+        #variant_type_enum
 
         impl VariantType {
+            // This will need refactoring if VariantType is changed to a real enum.
             #[doc(hidden)]
-            pub fn from_sys(enumerator: GDExtensionVariantType) -> Self {
-                // Annoying, but only stable alternative is transmute(), which dictates enum size.
-                match enumerator {
-                    0 => Self::Nil,
-                    #(
-                        #variant_ty_enumerators_ord => Self::#variant_ty_enumerators_pascal,
-                    )*
-                    _ => unreachable!("invalid variant type {}", enumerator)
-                }
+            pub fn from_sys(enumerator: crate::GDExtensionVariantType) -> Self {
+                Self { ord: enumerator as i32 }
             }
 
             #[doc(hidden)]
-            pub fn sys(self) -> GDExtensionVariantType {
-                self as _
+            pub fn sys(self) -> crate::GDExtensionVariantType {
+                self.ord as _
             }
-        }
 
-        // ----------------------------------------------------------------------------------------------------------------------------------------------
-
-        #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-        #[repr(i32)]
-        pub enum VariantOperator {
-            #(
-                #variant_op_enumerators_pascal = #variant_op_enumerators_ord,
-            )*
-        }
-
-        impl VariantOperator {
-            #[doc(hidden)]
-            pub fn from_sys(enumerator: GDExtensionVariantOperator) -> Self {
-                match enumerator {
-                    #(
-                        #variant_op_enumerators_ord => Self::#variant_op_enumerators_pascal,
-                    )*
-                    _ => unreachable!("invalid variant operator {}", enumerator)
-                }
-            }
-
-            #[doc(hidden)]
-            pub fn sys(self) -> GDExtensionVariantOperator {
-                self as _
-            }
+            #variant_type_deprecated_enumerators
         }
     }
 }
@@ -109,6 +59,7 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
     } = make_variant_enums(api, ctx);
 
     let global_enum_defs = make_global_enums(api);
+    let variant_type_traits = make_variant_type_enum(api, false).0;
 
     // TODO impl Clone, Debug, PartialEq, PartialOrd, Hash for VariantDispatch
     // TODO could use try_to().unwrap_unchecked(), since type is already verified. Also directly overload from_variant().
@@ -118,6 +69,9 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
         use crate::engine::Object;
         use crate::obj::Gd;
 
+        // Remaining trait impls for sys::VariantType (traits only defined in godot-core).
+        #variant_type_traits
+
         #[allow(dead_code)]
         pub enum VariantDispatch {
             Nil,
@@ -134,6 +88,9 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
                         VariantType::#variant_ty_enumerators_pascal
                             => Self::#variant_ty_enumerators_pascal(variant.to::<#variant_ty_enumerators_rust>()),
                     )*
+
+                    // Panic can be removed as soon as VariantType is a proper, non-exhaustive enum.
+                    _ => panic!("Variant type not supported: {:?}", variant.get_type()),
                 }
             }
         }
@@ -168,19 +125,6 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
 struct VariantEnums {
     variant_ty_enumerators_pascal: Vec<Ident>,
     variant_ty_enumerators_rust: Vec<TokenStream>,
-    variant_ty_enumerators_ord: Vec<Literal>,
-    variant_op_enumerators_pascal: Vec<Ident>,
-    variant_op_enumerators_ord: Vec<Literal>,
-}
-
-fn collect_variant_operators(api: &ExtensionApi) -> Vec<&Enumerator> {
-    let variant_operator_enum = api
-        .global_enums
-        .iter()
-        .find(|e| &e.name == "VariantOperator") // in JSON: "Variant.Operator"
-        .expect("missing enum for VariantOperator in JSON");
-
-    variant_operator_enum.enumerators.iter().collect()
 }
 
 fn make_opaque_types(api: &ExtensionApi) -> [Vec<TokenStream>; 2] {
@@ -208,49 +152,27 @@ fn make_opaque_type(godot_original_name: &str, size: usize) -> TokenStream {
 }
 
 fn make_variant_enums(api: &ExtensionApi, ctx: &mut Context) -> VariantEnums {
-    let variant_operators = collect_variant_operators(api);
-
     // Generate builtin methods, now with info for all types available.
     // Separate vectors because that makes usage in quote! easier.
     let len = api.builtins.len();
 
     let mut result = VariantEnums {
         variant_ty_enumerators_pascal: Vec::with_capacity(len),
         variant_ty_enumerators_rust: Vec::with_capacity(len),
-        variant_ty_enumerators_ord: Vec::with_capacity(len),
-        variant_op_enumerators_pascal: Vec::new(),
-        variant_op_enumerators_ord: Vec::new(),
     };
 
     // Note: NIL is not part of this iteration, it will be added manually.
     for builtin in api.builtins.iter() {
         let original_name = builtin.godot_original_name();
         let rust_ty = conv::to_rust_type(original_name, None, ctx);
         let pascal_case = conv::to_pascal_case(original_name);
-        let ord = builtin.unsuffixed_ord_lit();
 
         result
             .variant_ty_enumerators_pascal
             .push(ident(&pascal_case));
         result
             .variant_ty_enumerators_rust
             .push(rust_ty.to_token_stream());
-        result.variant_ty_enumerators_ord.push(ord);
-    }
-
-    for op in variant_operators {
-        let pascal_name = conv::to_pascal_case(&op.name.to_string());
-
-        let enumerator_name = if pascal_name == "Module" {
-            ident("Modulo")
-        } else {
-            ident(&pascal_name)
-        };
-
-        result.variant_op_enumerators_pascal.push(enumerator_name);
-        result
-            .variant_op_enumerators_ord
-            .push(op.value.unsuffixed_lit());
     }
 
     result
@@ -260,8 +182,8 @@ fn make_global_enums(api: &ExtensionApi) -> Vec<TokenStream> {
     let mut global_enum_defs = vec![];
 
     for enum_ in api.global_enums.iter() {
-        // Skip those enums which are already manually handled.
-        if enum_.name == "VariantType" || enum_.name == "VariantOperator" {
+        // Skip VariantType, which is already defined in godot-ffi.
+        if enum_.name == "VariantType" {
             continue;
         }
 
@@ -271,3 +193,20 @@ fn make_global_enums(api: &ExtensionApi) -> Vec<TokenStream> {
 
     global_enum_defs
 }
+
+fn make_variant_type_enum(api: &ExtensionApi, is_definition: bool) -> (TokenStream, TokenStream) {
+    let variant_type_enum = api
+        .global_enums
+        .iter()
+        .find(|e| e.name == "VariantType")
+        .expect("missing VariantType enum in API JSON");
+
+    let define_enum = is_definition;
+    let define_traits = !is_definition;
+
+    let enum_definition =
+        enums::make_enum_definition_with(variant_type_enum, define_enum, define_traits);
+    let deprecated_enumerators = enums::make_deprecated_enumerators(variant_type_enum);
+
+    (enum_definition, deprecated_enumerators)
+}

godot-codegen/src/generator/enums.rs

@@ -10,6 +10,7 @@
 //! See also models/domain/enums.rs for other enum-related methods.
 
 use crate::models::domain::{Enum, Enumerator};
+use crate::{conv, util};
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 
@@ -25,6 +26,14 @@ pub fn make_enums(enums: &[Enum], cfg_attributes: &TokenStream) -> TokenStream {
 ///
 /// This will also implement all relevant traits and generate appropriate constants for each enumerator.
 pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
+    make_enum_definition_with(enum_, true, true)
+}
+
+pub fn make_enum_definition_with(
+    enum_: &Enum,
+    define_enum: bool,
+    define_traits: bool,
+) -> TokenStream {
     // Things needed for the type definition
     let derives = enum_.derives();
     let enum_doc = make_enum_doc(enum_);
@@ -36,47 +45,65 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
         .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
-        }
+    let definition = define_enum.then(|| {
+        // Workaround because traits are defined in separate crate, but need access to field `ord`.
+        let vis = (!define_traits).then(|| {
+            quote! {
+                #[doc(hidden)] pub
+            }
+        });
+
+        quote! {
+            #[repr(transparent)]
+            #[derive( #( #derives ),* )]
+            #( #[doc = #enum_doc] )*
+            pub struct #name {
+                #vis ord: #ord_type
+            }
 
-        impl #name {
-            #( #enumerators )*
+            impl #name {
+                #( #enumerators )*
+            }
         }
+    });
 
-        #engine_trait_impl
-        #index_enum_impl
-        #bitwise_impls
+    let traits = define_traits.then(|| {
+        // 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_);
 
-        impl crate::builtin::meta::GodotConvert for #name {
-            type Via = #ord_type;
-        }
+        quote! {
+            #engine_trait_impl
+            #index_enum_impl
+            #bitwise_impls
 
-        impl crate::builtin::meta::ToGodot for #name {
-            fn to_godot(&self) -> Self::Via {
-                <Self as #engine_trait>::ord(*self)
+            impl crate::builtin::meta::GodotConvert for #name {
+                type Via = #ord_type;
             }
-        }
 
-        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::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))
+                }
             }
         }
+    });
+
+    quote! {
+        #definition
+        #traits
     }
 }
 
@@ -203,3 +230,32 @@ fn make_enumerator_definition(enumerator: &Enumerator, enum_type: TokenStream) -
         };
     }
 }
+
+pub(crate) fn make_deprecated_enumerators(enum_: &Enum) -> TokenStream {
+    let enum_name = &enum_.name;
+    let deprecated_enumerators = enum_.enumerators.iter().filter_map(|enumerator| {
+        let Enumerator { name, .. } = enumerator;
+
+        if name == "MAX" {
+            return None;
+        }
+
+        let converted = conv::to_pascal_case(&name.to_string())
+            .replace("2d", "2D")
+            .replace("3d", "3D");
+
+        let pascal_name = util::ident(&converted);
+        let msg = format!("Use `{enum_name}::{name}` instead.");
+
+        let decl = quote! {
+            #[deprecated = #msg]
+            pub const #pascal_name: #enum_name = Self::#name;
+        };
+
+        Some(decl)
+    });
+
+    quote! {
+        #( #deprecated_enumerators )*
+    }
+}

godot-codegen/src/generator/mod.rs

@@ -55,11 +55,10 @@ pub fn generate_sys_module_file(sys_gen_path: &Path, submit_fn: &mut SubmitFn) {
 
 pub fn generate_sys_central_file(
     api: &ExtensionApi,
-    ctx: &mut Context,
     sys_gen_path: &Path,
     submit_fn: &mut SubmitFn,
 ) {
-    let sys_code = central_files::make_sys_central_code(api, ctx);
+    let sys_code = central_files::make_sys_central_code(api);
 
     submit_fn(sys_gen_path.join("central.rs"), sys_code);
 }