[PATCH] rust: num: Add inline annotation to Bounded methods

[Link Mauve]

It was previously generating a ton of very short functions, such as
<<kernel::num::bounded::Bounded<u32, 32>>::shr::<17, 15>> or
<<kernel::num::bounded::Bounded<u16, 16>>::new::<16384>> on use.

These are obviously better inlined, although I wasn’t completely sure
between #[inline] and #[inline(always)], but the former worked fine in
my setup so I went for it, we can always adjust it later.

Signed-off-by: Link Mauve <linkmauve@xxxxxxxxxxxx>
---
 rust/kernel/num/bounded.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/rust/kernel/num/bounded.rs b/rust/kernel/num/bounded.rs
index 0b32f4343922..d3486675046a 100644
--- a/rust/kernel/num/bounded.rs
+++ b/rust/kernel/num/bounded.rs
@@ -264,6 +264,7 @@ impl<const N: u32> Bounded<$type, N> {
                 ", 4>::new::<7>();")]
             /// assert_eq!(v.get(), 7);
             /// ```
+            #[inline]
             pub const fn new<const VALUE: $type>() -> Self {
                 // Statically assert that `VALUE` fits within the set number of bits.
                 const_assert!(fits_within!(VALUE, $type, N));
@@ -309,6 +310,7 @@ impl<T, const N: u32> Bounded<T, N>
     /// # Safety
     ///
     /// The caller must ensure that `value` can be represented within `N` bits.
+    #[inline]
     const unsafe fn __new(value: T) -> Self {
         // Enforce the type invariants.
         // `N` cannot be zero.
@@ -350,6 +352,7 @@ impl<T, const N: u32> Bounded<T, N>
     /// let v = Bounded::<i8, 4>::try_new(8);
     /// assert_eq!(v, None);
     /// ```
+    #[inline]
     pub fn try_new(value: T) -> Option<Self> {
         fits_within(value, N).then(|| {
             // SAFETY: `fits_within` confirmed that `value` can be represented within `N` bits.
@@ -412,6 +415,7 @@ pub fn from_expr(expr: T) -> Self {
     /// let v = Bounded::<u32, 4>::new::<7>();
     /// assert_eq!(v.get(), 7u32);
     /// ```
+    #[inline]
     pub const fn get(self) -> T {
         self.0
     }
@@ -430,6 +434,7 @@ pub const fn get(self) -> T {
     /// // The contained values are equal even though `larger_v` has a bigger capacity.
     /// assert_eq!(larger_v, v);
     /// ```
+    #[inline]
     pub const fn extend<const M: u32>(self) -> Bounded<T, M> {
         const_assert!(
             M >= N,
@@ -459,6 +464,7 @@ pub const fn extend<const M: u32>(self) -> Bounded<T, M> {
     /// // ... but doesn't fit within `2` bits.
     /// assert_eq!(v.try_shrink::<2>(), None);
     /// ```
+    #[inline]
     pub fn try_shrink<const M: u32>(self) -> Option<Bounded<T, M>> {
         Bounded::<T, M>::try_new(self.get())
     }
@@ -482,6 +488,7 @@ pub fn try_shrink<const M: u32>(self) -> Option<Bounded<T, M>> {
     /// // This won't build: a `u8` is smaller than the required 12 bits.
     /// // let _: Bounded<u8, 12> = v.cast();
     /// ```
+    #[inline]
     pub fn cast<U>(self) -> Bounded<U, N>
     where
         U: TryFrom<T> + Integer,
@@ -510,6 +517,7 @@ pub fn cast<U>(self) -> Bounded<U, N>
     ///
     /// assert_eq!(v_shifted.get(), 0xff);
     /// ```
+    #[inline]
     pub fn shr<const SHIFT: u32, const RES: u32>(self) -> Bounded<T, RES> {
         const_assert!(SHIFT < T::BITS);
         const_assert!(RES + SHIFT >= N);
@@ -563,6 +571,7 @@ pub fn shr_exact<const SHIFT: u32, const RES: u32>(self) -> Option<Bounded<T, RE
     ///
     /// assert_eq!(v_shifted.get(), 0xff00);
     /// ```
+    #[inline]
     pub fn shl<const SHIFT: u32, const RES: u32>(self) -> Bounded<T, RES> {
         const_assert!(RES >= N + SHIFT);
 

base-commit: 2efb7a11f1aa4d2dc285fe2680cca22cb9f72f64
-- 
2.56.0