Add 'with' and 'without' methods to EngineBitfield.

godot-codegen/src/generator/enums.rs

@@ -485,7 +485,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:
+/// - [`BitOr`][std::ops::BitOr]
+/// - [`BitOrAssign`][std::ops::BitOrAssign]
+///
+/// While it would be possible to expand these with additional bitwise operations such as `BitAnd` and `Not`, the preferred way to manipulate
+/// flags is to use the `with` and `without` methods rather than using the bitwise operators themselves.
 fn make_enum_bitwise_operators(enum_: &Enum, enum_bitmask: Option<&RustTy>) -> TokenStream {
     let name = &enum_.name;
 

godot-core/src/obj/traits.rs

@@ -286,6 +286,16 @@ pub trait EngineBitfield: Copy + 'static {
     /// }
     /// ```
     fn all_constants() -> &'static [EnumConstant<Self>];
+
+    /// Returns the flag(s) from `self` combined with the flag(s) from `add_flags` arg.
+    fn with(self, add_flags: Self) -> Self {
+        Self::from_ord(self.ord() | add_flags.ord())
+    }
+
+    /// Returns the flag(s) from `self`, except for any that were present in the `remove_flags` arg.
+    fn without(self, remove_flags: Self) -> Self {
+        Self::from_ord(self.ord() & !remove_flags.ord())
+    }
 }
 
 /// Trait for enums that can be used as indices in arrays.

itest/rust/src/object_tests/bitfield_ops_test.rs

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use godot::classes::node::DuplicateFlags;
+use godot::obj::EngineBitfield;
+
+use crate::framework::itest;
+
+/// Necessarily since `from_ord` is not `const`.
+fn no_flags() -> DuplicateFlags {
+    // Could use `Default::default()` here. Until it is broken by `!1630`, funnily enough.
+    DuplicateFlags::from_ord(0)
+}
+
+const SIGNALS: DuplicateFlags = DuplicateFlags::SIGNALS;
+const GROUPS: DuplicateFlags = DuplicateFlags::GROUPS;
+const USE_INSTANTIATION: DuplicateFlags = DuplicateFlags::USE_INSTANTIATION;
+
+#[itest]
+fn bitfield_ops_with() {
+    let no_flags = no_flags();
+
+    assert_eq!(no_flags.with(USE_INSTANTIATION), USE_INSTANTIATION);
+
+    assert_eq!(
+        GROUPS.with(SIGNALS),
+        DuplicateFlags::from_ord(GROUPS.ord() | SIGNALS.ord())
+    );
+
+    assert_eq!(GROUPS.with(GROUPS), GROUPS);
+
+    assert_eq!(GROUPS.with(GROUPS.with(SIGNALS)), GROUPS.with(SIGNALS));
+
+    let with_then_with = GROUPS.with(SIGNALS).with(USE_INSTANTIATION);
+    assert!(with_then_with.is_set(GROUPS));
+    assert!(with_then_with.is_set(SIGNALS));
+    assert!(with_then_with.is_set(USE_INSTANTIATION));
+
+    assert_eq!(GROUPS.with(no_flags), GROUPS);
+}
+
+#[itest]
+fn bitfield_ops_without() {
+    let no_flags = no_flags();
+
+    assert_eq!(USE_INSTANTIATION.without(USE_INSTANTIATION), no_flags);
+
+    assert_eq!(SIGNALS.with(GROUPS).without(SIGNALS), GROUPS);
+
+    assert_eq!(GROUPS.without(SIGNALS), GROUPS);
+
+    assert_eq!(
+        SIGNALS
+            .with(GROUPS)
+            .without(SIGNALS.with(USE_INSTANTIATION)),
+        GROUPS
+    );
+
+    let without_then_without = GROUPS
+        .with(SIGNALS)
+        .with(USE_INSTANTIATION)
+        .without(SIGNALS)
+        .without(USE_INSTANTIATION);
+    assert!(without_then_without.is_set(GROUPS));
+    assert!(!without_then_without.is_set(SIGNALS));
+    assert!(!without_then_without.is_set(USE_INSTANTIATION));
+
+    assert_eq!(GROUPS.without(no_flags), GROUPS);
+}

itest/rust/src/object_tests/mod.rs

@@ -6,6 +6,7 @@
  */
 
 mod base_test;
+mod bitfield_ops_test;
 mod call_deferred_test;
 mod class_id_test;
 mod class_rename_test;