Fix naming/refactoring misses

Author: Bluefinger

crates/bevy_ecs/src/identifier/bits.rs

@@ -11,7 +11,7 @@ bitflags! {
         /// [`super::IdKind::Placeholder`] or [`super::IdKind::Entity`].
         const IS_PLACEHOLDER = 0b1000_0000_0000_0000_0000_0000_0000_0000;
         /// Flag for determining whether the [`super::Identifier`] is in a
-        /// `toggeable` state or not.
+        /// `togglable` state or not.
         const IS_TOGGLABLE = 0b0100_0000_0000_0000_0000_0000_0000_0000;
 
         const _ = !0;
@@ -36,7 +36,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn smoke_test() {
+    fn flag_bits_are_correctly_determined() {
         // Both flag bits are set
         let bits: u32 = 0xC0FF_EEEE;
 

crates/bevy_ecs/src/identifier/masks.rs

@@ -139,7 +139,7 @@ mod tests {
         // Excludes the most significant bit as that is a flag bit.
         assert_eq!(IdentifierMask::extract_value_from_high(high), HIGH_MASK);
 
-        // Start bit and end bit are ones.
+        // Start two bits and end bit are ones.
         let high: u32 = 0xC000_0001;
 
         assert_eq!(IdentifierMask::extract_value_from_high(high), 0x0000_0001);
@@ -152,12 +152,12 @@ mod tests {
 
     #[test]
     fn pack_flag_bits() {
-        // All bits are ones expect the 2 most significant bits, which are zero
+        // All bits are ones except the 2 most significant bits, which are zero
         let high: u32 = 0x7FFF_FFFF;
 
         assert_eq!(
             IdentifierMask::pack_flags_into_high(high, IdentifierFlagBits::IS_PLACEHOLDER),
-            // The IS_HIDDEN flag is cleared and the IS_PLACEHOLDER flag is enabled
+            // The IS_TOGGLABLE flag is cleared and the IS_PLACEHOLDER flag is enabled
             0xBFFF_FFFF
         );
 

crates/bevy_ecs/src/identifier/mod.rs

@@ -31,7 +31,7 @@ pub struct Identifier {
 }
 
 impl Identifier {
-    /// Construct a new [`Identifier`]. The `high` parameter is masked so to pack
+    /// Construct a new [`Identifier`]. The `high` parameter is masked so we can pack
     /// the high value and bit flags into the same field.
     #[inline(always)]
     pub const fn new(
@@ -95,7 +95,7 @@ impl Identifier {
         IdentifierMask::extract_kind_from_high(self.high.get())
     }
 
-    /// Returns with the [`Identifier`] is in a `hidden` state.
+    /// Returns with the [`Identifier`] is in a `togglable` state.
     #[inline(always)]
     pub const fn is_togglable(self) -> bool {
         self.flags().contains(IdentifierFlagBits::IS_TOGGLABLE)
@@ -114,16 +114,16 @@ impl Identifier {
         IdentifierMask::extract_flags_from_high(self.high.get())
     }
 
-    /// Returns a `hidden` [`Identifier`].
+    /// Returns a `togglable` [`Identifier`].
     #[inline(always)]
     #[must_use]
-    pub const fn set_hidden(self, state: bool) -> Identifier {
+    pub const fn set_togglable(self, state: bool) -> Identifier {
         Self {
             low: self.low,
             // SAFETY: the high component will always be non-zero due to either the
             // placeholder flag or the value component not being modified and either
             // one guaranteed to be one due to Identifier being initialised with the
-            // correct invariants checked. As such, modifying the hidden bit will
+            // correct invariants checked. As such, modifying the togglable bit will
             // never result in a zero value.
             high: unsafe {
                 NonZeroU32::new_unchecked(IdentifierMask::set_togglable_flag_in_high(
@@ -275,7 +275,7 @@ mod tests {
 
         assert!(id.is_togglable());
 
-        let id = id.set_hidden(false);
+        let id = id.set_togglable(false);
 
         assert_eq!(id.to_bits(), 0x3FFF_FFFF_0000_000C);
         assert!(!id.is_togglable());