Re: [PATCH v3 3/8] rust: alloc: add ArrayVec

[sashiko-bot@kernel.org]

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] rust: alloc: missing #[inline] on small ArrayVec methods
--

commit 272001023e1b94a98c5055e880db10e4aff13e9a
Author: Eliot Courtney <ecourtney@nvidia.com>

rust: alloc: add ArrayVec

Adds a fixed capacity vector backed by an array of uninitialized memory. The
ArrayVec is also initializable with a closure to avoid constructing it on
the stack, which is useful for small varying size arrays on the stack or
larger ones initialized into caller-provided memory.

> diff --git a/rust/kernel/alloc/arrayvec.rs b/rust/kernel/alloc/arrayvec.rs
> new file mode 100644
> index 0000000000000..4172a982e4775
> --- /dev/null
> +++ b/rust/kernel/alloc/arrayvec.rs
[ ... ]
> +    /// Appends an element to the back of the [`ArrayVec`].
> +    ///
> +    /// Fails when the [`ArrayVec`] is full, handing the element back in [`PushError`].
> +    pub fn push(&mut self, v: T) -> Result<(), PushError<T>> {

[Severity: Low]
The rust subsystem coding guidelines recommend that small functions in
abstractions like the kernel crate be annotated with #[inline]. Since push
is a trivial wrapper around try_push_init, should it have an #[inline]
annotation to avoid sub-optimal inlining?

> +        self.try_push_init(v)
> +            .map_err(|PushInitError::Full(v)| PushError(v))
> +    }
> +
> +    /// Appends an element to the back of the [`ArrayVec`] by initializing it in place.
> +    ///
> +    /// Fails with [`FullError`] when the [`ArrayVec`] is full.
> +    pub fn push_init(&mut self, init: impl Init<T>) -> Result<(), FullError> {

[Severity: Low]
Similarly, push_init is a trivial wrapper around try_push_init. Would it be
appropriate to add an #[inline] annotation here as well?

> +        self.try_push_init(init)
> +            .map_err(|PushInitError::Full(_)| FullError)
> +    }
[ ... ]
> +    /// Returns a slice of `MaybeUninit<T>` for the remaining spare capacity of the [`ArrayVec`].
> +    fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>] {

[Severity: Low]
Since spare_capacity_mut is a small internal helper returning a slice,
should it also be annotated with #[inline]?

> +        // PANIC: `len` never exceeds `N` by the type invariants.
> +        &mut self.data[self.len..]
> +    }
> +}
[ ... ]
> +impl<T, const N: usize> Borrow<[T]> for ArrayVec<T, N> {
> +    fn borrow(&self) -> &[T] {

[Severity: Low]
This trait method is a one-line wrapper around as_slice. Does it need an
#[inline] annotation following the coding guidelines?

> +        self.as_slice()
> +    }
> +}
[ ... ]
> +impl<'a, T, const N: usize> IntoIterator for &'a ArrayVec<T, N> {
> +    type Item = &'a T;
> +    type IntoIter = slice::Iter<'a, T>;
> +
> +    fn into_iter(self) -> Self::IntoIter {

[Severity: Low]
This trait method is a one-line wrapper around iter. Should an #[inline]
annotation be added here?

> +        self.iter()
> +    }
> +}

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260928-b4-nvkv-v3-0-f04504c262c2@nvidia.com?part=3