changed bitfields to be i64 instead of u64

Author: TCROC

godot-codegen/src/generator/enums.rs

@@ -89,15 +89,15 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
                 }
             }
         };
-        enum_ord_type = quote! { u64 };
+        enum_ord_type = quote! { i64 };
         self_as_trait = quote! { <Self as crate::obj::EngineBitfield> };
         engine_impl = quote! {
             impl crate::obj::EngineBitfield for #rust_enum_name {
-                fn try_from_ord(ord: u64) -> Option<Self> {
+                fn try_from_ord(ord: i64) -> Option<Self> {
                     Some(Self { ord })
                 }
 
-                fn ord(self) -> u64 {
+                fn ord(self) -> i64 {
                     self.ord
                 }
             }
@@ -128,7 +128,7 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
 
     // Enumerator ordinal stored as i32, since that's enough to hold all current values and the default repr in C++.
     // Public interface is i64 though, for consistency (and possibly forward compatibility?).
-    // Bitfield ordinals are stored as u64. See also: https://github.com/godotengine/godot-cpp/pull/1320
+    // Bitfield ordinals are stored as i64.
     quote! {
         #[repr(transparent)]
         #[derive(#( #derives ),*)]
@@ -172,8 +172,8 @@ pub fn make_enumerator_ord(ord: i32) -> Literal {
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Implementation
 
-fn make_bitfield_flag_ord(ord: u64) -> Literal {
-    Literal::u64_suffixed(ord)
+fn make_bitfield_flag_ord(ord: i64) -> Literal {
+    Literal::i64_suffixed(ord)
 }
 
 fn make_enumerator_definition(enumerator: &Enumerator) -> TokenStream {

godot-codegen/src/models/domain.rs

@@ -201,15 +201,15 @@ pub struct Enumerator {
 }
 pub enum EnumeratorValue {
     Enum(i32),
-    Bitfield(u64),
+    Bitfield(i64),
 }
 
 impl EnumeratorValue {
     pub fn to_i64(&self) -> i64 {
         // Conversion is safe because i64 is used in the original JSON.
         match self {
             EnumeratorValue::Enum(i) => *i as i64,
-            EnumeratorValue::Bitfield(i) => *i as i64,
+            EnumeratorValue::Bitfield(i) => *i,
         }
     }
 

godot-codegen/src/models/domain_mapping.rs

@@ -543,14 +543,7 @@ impl Enum {
 impl Enumerator {
     pub fn from_json(json: &JsonEnumConstant, rust_name: Ident, is_bitfield: bool) -> Self {
         let value = if is_bitfield {
-            let ord = json.value.try_into().unwrap_or_else(|_| {
-                panic!(
-                    "bitfield value {} = {} is negative; please report this",
-                    json.name, json.value
-                )
-            });
-
-            EnumeratorValue::Bitfield(ord)
+            EnumeratorValue::Bitfield(json.value)
         } else {
             let ord = json.value.try_into().unwrap_or_else(|_| {
                 panic!(

godot-core/src/obj/traits.rs

@@ -161,12 +161,12 @@ pub trait EngineEnum: Copy {
 
 /// Auto-implemented for all engine-provided bitfields.
 pub trait EngineBitfield: Copy {
-    fn try_from_ord(ord: u64) -> Option<Self>;
+    fn try_from_ord(ord: i64) -> Option<Self>;
 
     /// Ordinal value of the bit flag, as specified in Godot.
-    fn ord(self) -> u64;
+    fn ord(self) -> i64;
 
-    fn from_ord(ord: u64) -> Self {
+    fn from_ord(ord: i64) -> Self {
         Self::try_from_ord(ord)
             .unwrap_or_else(|| panic!("ordinal {ord} does not map to any valid bit flag"))
     }