Implement bitwise operators and Default impl for DuplicateFlags mainly.

Author: rsethc

godot-codegen/src/generator/enums.rs

@@ -115,6 +115,18 @@ pub fn make_enum_definition_with(
         let index_enum_impl = make_enum_index_impl(enum_);
         let bitwise_impls = make_enum_bitwise_operators(enum_, enum_bitmask.as_ref());
 
+        let special_default_impl = if let Some(override_default) = enum_.override_default.as_ref() {
+            quote! {
+                impl Default for #name {
+                    fn default() -> Self {
+                        #override_default
+                    }
+                }
+            }
+        } else {
+            TokenStream::new()
+        };
+
         let var_trait_set = if enum_.is_exhaustive {
             quote! {
                 fn var_set(field: &mut Self, value: Self::Via) {
@@ -144,6 +156,7 @@ pub fn make_enum_definition_with(
             #engine_trait_impl
             #index_enum_impl
             #bitwise_impls
+            #special_default_impl
 
             impl crate::meta::GodotConvert for #name {
                 type Via = #ord_type;
@@ -485,7 +498,12 @@ fn make_enum_as_str(enum_: &Enum) -> TokenStream {
 
 /// 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.
+/// Currently, for bitfields this is the following (but could be expanded in the future):
+/// - [`BitOr`](std::ops::BitOr)
+/// - [`BitOrAssign`](std::ops::BitOrAssign)
+/// - [`BitAnd`](std::ops::BitAnd)
+/// - [`BitAndAssign`](std::ops::BitAndAssign)
+/// - [`Not`](std::ops::Not) (there is not a separate 'BitNot' trait)
 fn make_enum_bitwise_operators(enum_: &Enum, enum_bitmask: Option<&RustTy>) -> TokenStream {
     let name = &enum_.name;
 
@@ -507,6 +525,31 @@ fn make_enum_bitwise_operators(enum_: &Enum, enum_bitmask: Option<&RustTy>) -> T
                     *self = *self | rhs;
                 }
             }
+
+            impl std::ops::BitAnd for #name {
+                type Output = Self;
+
+                #[inline]
+                fn bitand(self, rhs: Self) -> Self::Output {
+                    Self { ord: self.ord & rhs.ord }
+                }
+            }
+
+            impl std::ops::BitAndAssign for #name {
+                #[inline]
+                fn bitand_assign(&mut self, rhs: Self) {
+                    *self = *self & rhs;
+                }
+            }
+
+            impl std::ops::Not for #name {
+                type Output = Self;
+
+                #[inline]
+                fn not(self) -> Self::Output {
+                    Self { ord: !self.ord }
+                }
+            }
         }
     } else if let Some(mask_enum) = enum_bitmask {
         // Enum that has an accompanying bitfield for masking.

godot-codegen/src/models/domain/enums.rs

@@ -20,6 +20,7 @@ pub struct Enum {
     pub godot_name: String,
     pub surrounding_class: Option<TyName>,
     pub is_bitfield: bool,
+    pub override_default: Option<TokenStream>,
     pub is_private: bool,
     pub is_exhaustive: bool,
     pub enumerators: Vec<Enumerator>,
@@ -33,7 +34,7 @@ impl Enum {
         // Debug is implemented manually, using enumerator name. This can be derived once we use proper enums.
         let mut derives = vec!["Copy", "Clone", "Eq", "PartialEq", "Hash"];
 
-        if self.is_bitfield {
+        if self.is_bitfield && self.override_default.is_none() {
             derives.push("Default");
         }
 

godot-codegen/src/models/domain_mapping.rs

@@ -766,6 +766,8 @@ impl Enum {
             .unwrap_or(json_is_bitfield);
         let is_private = special_cases::is_enum_private(surrounding_class, &godot_name);
         let is_exhaustive = special_cases::is_enum_exhaustive(surrounding_class, &godot_name);
+        let override_default =
+            special_cases::does_enum_have_special_default(surrounding_class, &godot_name);
 
         let rust_enum_name = conv::make_enum_name_str(&godot_name);
         let rust_enumerator_names = {
@@ -800,6 +802,7 @@ impl Enum {
             godot_name,
             surrounding_class: surrounding_class.cloned(),
             is_bitfield,
+            override_default,
             is_private,
             is_exhaustive,
             enumerators,

godot-codegen/src/special_cases/special_cases.rs

@@ -1361,6 +1361,27 @@ pub fn is_enum_bitfield(class_name: Option<&TyName>, enum_name: &str) -> Option<
     }
 }
 
+/// For types where a [`Default`](Default) is helpful, but the default value should
+/// be something other than what would be returned by a `#[derive(Default)]` implementation.
+/// 
+/// An example of this is `DuplicateFlags`, where the default flags to `duplicate` are non-zero,
+/// so if one wants to use "all flags except one" in `duplicate_ex`, the most natural way to do
+/// so would be to pass `DuplicateFlags::default() & !DuplicateFlags::USE_INSTATANTIATION` to `flags`.
+/// 
+/// * `Some(TokenStream)` -> function body which will be psted into the `Default::default` implementation.
+/// * `None` -> no special default, i.e. if a Default is generated it will be with an automatic derive.
+#[rustfmt::skip]
+pub fn does_enum_have_special_default(class_name: Option<&TyName>, enum_name: &str) -> Option<TokenStream> {
+    let class_name = class_name.map(|c| c.godot_ty.as_str());
+    match (class_name, enum_name) {
+        (Some("Node"), "DuplicateFlags") => Some(quote! {
+            Self::SIGNALS | Self::GROUPS | Self::SCRIPTS | Self::USE_INSTANTIATION
+        }),
+
+        _ => None
+    }
+}
+
 /// Whether an enum can be combined with another enum (return value) for bitmasking purposes.
 ///
 /// If multiple masks are ever necessary, this can be extended to return a slice instead of Option.