EngineBitfield::all_constants()

Author: Bromeon

godot-codegen/src/generator/enums.rs

@@ -227,6 +227,8 @@ fn make_enum_engine_trait_impl(enum_: &Enum, enum_bitmask: Option<&RustTy>) -> T
     if enum_.is_bitfield {
         // Bitfields: u64, assume any combination is valid.
 
+        let constants_function = make_bitfield_constants_function(enum_);
+
         quote! {
             // We may want to add this in the future.
             //
@@ -242,6 +244,8 @@ fn make_enum_engine_trait_impl(enum_: &Enum, enum_bitmask: Option<&RustTy>) -> T
                 fn ord(self) -> u64 {
                     self.ord
                 }
+
+                #constants_function
             }
         }
     } else if enum_.is_exhaustive {
@@ -347,7 +351,7 @@ fn make_enum_values_and_constants_functions(enum_: &Enum) -> TokenStream {
 
         // all_constants() includes every constant unconditionally.
         all_constants.push(quote! {
-            crate::meta::inspect::EnumConstant::new(#rust_name, #godot_name, #ordinal, #name::#constant)
+            crate::meta::inspect::EnumConstant::new(#rust_name, #godot_name, #name::#constant)
         });
 
         // values() contains value only if distinct (first time seen) and not MAX.
@@ -433,6 +437,40 @@ fn make_enum_str_functions(enum_: &Enum) -> TokenStream {
     }
 }
 
+/// Creates the `all_constants()` implementation for the bitfield.
+fn make_bitfield_constants_function(enum_: &Enum) -> TokenStream {
+    let name = &enum_.name;
+
+    let all_constants = enum_.enumerators.iter().map(|enumerator| {
+        let Enumerator {
+            name: constant,
+            godot_name,
+            value: EnumeratorValue::Bitfield(_ord),
+            ..
+        } = enumerator
+        else {
+            panic!("bitfield enum contains non-bitfield enumerators")
+        };
+
+        let rust_name = constant.to_string();
+        let godot_name_str = godot_name.to_string();
+
+        quote! {
+            crate::meta::inspect::EnumConstant::new(#rust_name, #godot_name_str, #name::#constant)
+        }
+    });
+
+    quote! {
+        fn all_constants() -> &'static [crate::meta::inspect::EnumConstant<#name>] {
+            const {
+                &[
+                    #( #all_constants ),*
+                ]
+            }
+        }
+    }
+}
+
 /// 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.

godot-core/src/builtin/vectors/vector_axis.rs

@@ -69,7 +69,6 @@ macro_rules! impl_vector_axis_enum {
                         EnumConstant::new(
                             stringify!($axis),
                             concat!("AXIS_", stringify!($axis)),
-                            $AxisEnum::$axis as i32,
                             $AxisEnum::$axis
                         ),
                     )+

godot-core/src/meta/inspect.rs

@@ -7,34 +7,32 @@
 
 //! Introspection metadata for Godot engine types.
 
-/// Metadata for a single enum constant.
+/// Metadata for a single enum or bitfield constant.
+///
+/// Returned by [`EngineEnum::all_constants()`][crate::obj::EngineEnum::all_constants] and
+/// [`EngineBitfield::all_constants()`][crate::obj::EngineBitfield::all_constants].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct EnumConstant<T: Copy + 'static> {
     rust_name: &'static str,
     godot_name: &'static str,
-    ord: i32,
     value: T,
 }
 
 impl<T: Copy + 'static> EnumConstant<T> {
     /// Creates a new enum constant metadata entry.
-    pub(crate) const fn new(
-        rust_name: &'static str,
-        godot_name: &'static str,
-        ord: i32,
-        value: T,
-    ) -> Self {
+    pub(crate) const fn new(rust_name: &'static str, godot_name: &'static str, value: T) -> Self {
         Self {
             rust_name,
             godot_name,
-            ord,
             value,
         }
     }
 
-    /// Rust name of the enum variant, usually without Prefix (e.g. `"ESCAPE"` for `Key::ESCAPE`).
+    /// Rust name of the constant, usually without prefix (e.g. `"ESCAPE"` for `Key::ESCAPE`).
     ///
-    /// This is returned by [`EngineEnum::as_str()`](crate::obj::EngineEnum::as_str()).
+    /// For enums, this is the value returned by [`EngineEnum::as_str()`](crate::obj::EngineEnum::as_str()) **if the value is unique.**
+    /// If multiple enum values share the same ordinal, then this function will return each one separately, while `as_str()` will return the
+    /// first one.
     pub const fn rust_name(&self) -> &'static str {
         self.rust_name
     }
@@ -44,12 +42,9 @@ impl<T: Copy + 'static> EnumConstant<T> {
         self.godot_name
     }
 
-    /// Ordinal value of this enum variant.
-    pub const fn ord(&self) -> i32 {
-        self.ord
-    }
-
-    /// The enum value itself.
+    /// The Rust value itself.
+    ///
+    /// Use `value().ord()` to get the ordinal value.
     pub const fn value(&self) -> T {
         self.value
     }

godot-core/src/obj/traits.rs

@@ -200,9 +200,10 @@ pub trait EngineEnum: Copy {
 
     /// Returns a slice of distinct enum values.
     ///
-    /// This excludes MAX constants and deduplicates aliases, providing only meaningful enum values.
+    /// This excludes `MAX` constants at the end (existing only to express the number of enumerators) and deduplicates aliases,
+    /// providing only meaningful enum values. See [`all_constants()`][Self::all_constants] for a complete list of all constants,
     ///
-    /// This enables iteration over distinct enum variants:
+    /// Enables iteration over distinct enum variants:
     /// ```no_run
     /// use godot::classes::window;
     /// use godot::obj::EngineEnum;
@@ -215,18 +216,19 @@ pub trait EngineEnum: Copy {
 
     /// Returns metadata for all enum constants.
     ///
-    /// This includes all constants as they appear in the enum definition, including duplicates and MAX constants.
+    /// This includes all constants as they appear in the enum definition, including duplicates and `MAX` constants.
+    /// For a list of useful, distinct values, use [`values()`][Self::values].
     ///
-    /// This enables complete introspection and debugging:
+    /// This enables introspection of available constants:
     /// ```no_run
     /// use godot::classes::window;
     /// use godot::obj::EngineEnum;
     ///
     /// for constant in window::Mode::all_constants() {
-    ///     println!("* {}: {} (ord: {})",
+    ///     println!("* window::Mode.{} (original {}) has ordinal value {}.",
     ///         constant.rust_name(),
     ///         constant.godot_name(),
-    ///         constant.ord()
+    ///         constant.value().ord()
     ///     );
     /// }
     /// ```
@@ -249,6 +251,25 @@ pub trait EngineBitfield: Copy {
     fn is_set(self, flag: Self) -> bool {
         self.ord() & flag.ord() != 0
     }
+
+    /// Returns metadata for all bitfield constants.
+    ///
+    /// This includes all constants as they appear in the bitfield definition.
+    ///
+    /// Enables introspection of available constants:
+    /// ```no_run
+    /// use godot::global::KeyModifierMask;
+    /// use godot::obj::EngineBitfield;
+    ///
+    /// for constant in KeyModifierMask::all_constants() {
+    ///     println!("* KeyModifierMask.{} (original {}) has ordinal value {}.",
+    ///         constant.rust_name(),
+    ///         constant.godot_name(),
+    ///         constant.value().ord()
+    ///     );
+    /// }
+    /// ```
+    fn all_constants() -> &'static [EnumConstant<Self>];
 }
 
 /// Trait for enums that can be used as indices in arrays.

itest/rust/src/engine_tests/engine_enum_test.rs

@@ -97,7 +97,7 @@ fn enum_values_duplicates() {
         }
 
         assert_eq!(c.value(), value);
-        assert_eq!(c.ord(), ord);
+        assert_eq!(c.value().ord(), ord);
     }
 
     assert_eq!(InlineAlignment::values(), &expected_distinct_values);
@@ -156,26 +156,38 @@ fn enum_all_constants() {
     let first = constants[0];
     assert_eq!(first.rust_name(), "TOP_TO");
     assert_eq!(first.godot_name(), "INLINE_ALIGNMENT_TOP_TO");
-    assert_eq!(first.ord(), 0);
     assert_eq!(first.value(), InlineAlignment::TOP_TO);
+    assert_eq!(first.value().ord(), 0);
 
     // Check specific constants at known indices, with equal ordinals.
     let known_a = constants[2];
     let known_b = constants[11];
 
-    assert_eq!(known_a.ord(), 3);
     assert_eq!(known_a.rust_name(), "BASELINE_TO");
     assert_eq!(known_a.godot_name(), "INLINE_ALIGNMENT_BASELINE_TO");
     assert_eq!(known_a.value(), InlineAlignment::BASELINE_TO);
+    assert_eq!(known_a.value().ord(), 3);
 
-    assert_eq!(known_b.ord(), 3);
     assert_eq!(known_b.rust_name(), "IMAGE_MASK");
     assert_eq!(known_b.godot_name(), "INLINE_ALIGNMENT_IMAGE_MASK");
     assert_eq!(known_b.value(), InlineAlignment::IMAGE_MASK);
+    assert_eq!(known_b.value().ord(), 3);
 
     // "Front-end" values are equal, too.
     assert_eq!(
         InlineAlignment::IMAGE_MASK.ord(),
         InlineAlignment::BASELINE_TO.ord()
     );
 }
+
+#[itest]
+fn bitfield_all_constants() {
+    let shift_constant = KeyModifierMask::all_constants()
+        .iter()
+        .find(|c| c.rust_name() == "SHIFT")
+        .expect("SHIFT constant should exist");
+
+    assert_eq!(shift_constant.godot_name(), "KEY_MASK_SHIFT");
+    assert_eq!(shift_constant.value(), KeyModifierMask::SHIFT);
+    assert_eq!(shift_constant.value().ord(), 1 << 25);
+}