Merge pull request #726 from godot-rust/qol/variant-constants

Treat `VariantType` and `VariantOperator` like regular engine enums

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,78 +29,38 @@ 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
         }
     }
 }
 
 pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStream {
     let VariantEnums {
         variant_ty_enumerators_pascal,
+        variant_ty_enumerators_shout,
         variant_ty_enumerators_rust,
         ..
     } = 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 +70,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,
@@ -129,11 +84,14 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
         impl VariantDispatch {
             pub fn from_variant(variant: &Variant) -> Self {
                 match variant.get_type() {
-                    VariantType::Nil => Self::Nil,
+                    VariantType::NIL => Self::Nil,
                     #(
-                        VariantType::#variant_ty_enumerators_pascal
+                        VariantType::#variant_ty_enumerators_shout
                             => 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()),
                 }
             }
         }
@@ -167,20 +125,8 @@ pub fn make_core_central_code(api: &ExtensionApi, ctx: &mut Context) -> TokenStr
 
 struct VariantEnums {
     variant_ty_enumerators_pascal: Vec<Ident>,
+    variant_ty_enumerators_shout: 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 +154,30 @@ 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_shout: 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 shout_case = builtin.godot_shout_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_shout.push(ident(shout_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 +187,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 +198,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)
+}