Avoid calling InternalBitFlags::{bits,from_bits_retain}.

nnethercote · nnethercote · commit a3f1f78b5dce · 2025-08-20T12:22:21.000+10:00
It's simpler to just use `Self()` and `.0`. Here's an example of how
that changes the output for one method:
```
         pub const fn union(self, other: Self) -&gt; Self {
-            Self::from_bits_retain(self.bits() | other.bits())
+            Self(self.0 | other.0)
         }
```
As well as being simpler, this change makes the code a tiny bit faster
to compile, and results in much better code quality (no function calls)
in dev builds.
diff --git a/src/public.rs b/src/public.rs
@@ -164,7 +164,7 @@ macro_rules! __impl_public_bitflags {
                     )*
 
                     let _ = i;
-                    Self::from_bits_retain(truncated)
+                    Self(truncated)
                 }
 
                 fn bits(&self) {
@@ -182,7 +182,7 @@ macro_rules! __impl_public_bitflags {
                 }
 
                 fn from_bits_truncate(bits) {
-                    Self(bits & Self::all().bits())
+                    Self(bits & Self::all().0)
                 }
 
                 fn from_bits_retain(bits) {
@@ -212,33 +212,33 @@ macro_rules! __impl_public_bitflags {
                 }
 
                 fn is_empty(&self) {
-                    self.bits() == <$T as $crate::Bits>::EMPTY
+                    self.0 == <$T as $crate::Bits>::EMPTY
                 }
 
                 fn is_all(&self) {
                     // NOTE: We check against `Self::all` here, not `Self::Bits::ALL`
                     // because the set of all flags may not use all bits
-                    Self::all().bits() | self.bits() == self.bits()
+                    Self::all().0 | self.0 == self.0
                 }
 
                 fn intersects(&self, other) {
-                    self.bits() & other.bits() != <$T as $crate::Bits>::EMPTY
+                    self.0 & other.0 != <$T as $crate::Bits>::EMPTY
                 }
 
                 fn contains(&self, other) {
-                    self.bits() & other.bits() == other.bits()
+                    self.0 & other.0 == other.0
                 }
 
                 fn insert(&mut self, other) {
-                    *self = Self::from_bits_retain(self.bits()).union(other);
+                    *self = Self(self.0).union(other);
                 }
 
                 fn remove(&mut self, other) {
-                    *self = Self::from_bits_retain(self.bits()).difference(other);
+                    *self = Self(self.0).difference(other);
                 }
 
                 fn toggle(&mut self, other) {
-                    *self = Self::from_bits_retain(self.bits()).symmetric_difference(other);
+                    *self = Self(self.0).symmetric_difference(other);
                 }
 
                 fn set(&mut self, other, value) {
@@ -250,23 +250,23 @@ macro_rules! __impl_public_bitflags {
                 }
 
                 fn intersection(self, other) {
-                    Self::from_bits_retain(self.bits() & other.bits())
+                    Self(self.0 & other.0)
                 }
 
                 fn union(self, other) {
-                    Self::from_bits_retain(self.bits() | other.bits())
+                    Self(self.0 | other.0)
                 }
 
                 fn difference(self, other) {
-                    Self::from_bits_retain(self.bits() & !other.bits())
+                    Self(self.0 & !other.0)
                 }
 
                 fn symmetric_difference(self, other) {
-                    Self::from_bits_retain(self.bits() ^ other.bits())
+                    Self(self.0 ^ other.0)
                 }
 
                 fn complement(self) {
-                    Self::from_bits_truncate(!self.bits())
+                    Self::from_bits_truncate(!self.0)
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ macro_rules! __impl_public_bitflags {`
`164`	`164`	`)*`
`165`	`165`
`166`	`166`	`let _ = i;`
`167`		`- Self::from_bits_retain(truncated)`
	`167`	`+ Self(truncated)`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`fn bits(&self) {`
`@@ -182,7 +182,7 @@ macro_rules! __impl_public_bitflags {`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`fn from_bits_truncate(bits) {`
`185`		`- Self(bits & Self::all().bits())`
	`185`	`+ Self(bits & Self::all().0)`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`fn from_bits_retain(bits) {`
`@@ -212,33 +212,33 @@ macro_rules! __impl_public_bitflags {`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`fn is_empty(&self) {`
`215`		`- self.bits() == <$T as $crate::Bits>::EMPTY`
	`215`	`+ self.0 == <$T as $crate::Bits>::EMPTY`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`fn is_all(&self) {`
`219`	`219`	// NOTE: We check against `Self::all` here, not `Self::Bits::ALL`
`220`	`220`	`// because the set of all flags may not use all bits`
`221`		`- Self::all().bits() \| self.bits() == self.bits()`
	`221`	`+ Self::all().0 \| self.0 == self.0`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`fn intersects(&self, other) {`
`225`		`- self.bits() & other.bits() != <$T as $crate::Bits>::EMPTY`
	`225`	`+ self.0 & other.0 != <$T as $crate::Bits>::EMPTY`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`fn contains(&self, other) {`
`229`		`- self.bits() & other.bits() == other.bits()`
	`229`	`+ self.0 & other.0 == other.0`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`fn insert(&mut self, other) {`
`233`		`- *self = Self::from_bits_retain(self.bits()).union(other);`
	`233`	`+ *self = Self(self.0).union(other);`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`fn remove(&mut self, other) {`
`237`		`- *self = Self::from_bits_retain(self.bits()).difference(other);`
	`237`	`+ *self = Self(self.0).difference(other);`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`fn toggle(&mut self, other) {`
`241`		`- *self = Self::from_bits_retain(self.bits()).symmetric_difference(other);`
	`241`	`+ *self = Self(self.0).symmetric_difference(other);`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`fn set(&mut self, other, value) {`
`@@ -250,23 +250,23 @@ macro_rules! __impl_public_bitflags {`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`fn intersection(self, other) {`
`253`		`- Self::from_bits_retain(self.bits() & other.bits())`
	`253`	`+ Self(self.0 & other.0)`
`254`	`254`	`}`
`255`	`255`
`256`	`256`	`fn union(self, other) {`
`257`		`- Self::from_bits_retain(self.bits() \| other.bits())`
	`257`	`+ Self(self.0 \| other.0)`
`258`	`258`	`}`
`259`	`259`
`260`	`260`	`fn difference(self, other) {`
`261`		`- Self::from_bits_retain(self.bits() & !other.bits())`
	`261`	`+ Self(self.0 & !other.0)`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`fn symmetric_difference(self, other) {`
`265`		`- Self::from_bits_retain(self.bits() ^ other.bits())`
	`265`	`+ Self(self.0 ^ other.0)`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`fn complement(self) {`
`269`		`- Self::from_bits_truncate(!self.bits())`
	`269`	`+ Self::from_bits_truncate(!self.0)`
`270`	`270`	`}`
`271`	`271`	`}`
`272`	`272`	`}`