Fix clippy lints

Author: newAM

.github/workflows/build.yml

@@ -101,6 +101,18 @@ jobs:
       - name: cargo fmt --check
         run: cargo fmt --all -- --check
 
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+          targets: i686-unknown-linux-gnu
+      - run: cargo clippy --all --target i686-unknown-linux-gnu -- --deny warnings
+
   # Compilation check
   check:
     name: check

CHANGELOG.md

@@ -7,7 +7,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-- configure `stable_deref_trait` as a platform-dependent dependency
+### Changed
+
+- Changed `stable_deref_trait` to a platform-dependent dependency.
+
+### Fixed
+
+- Fixed clippy lints.
 
 ## [v0.8.0] - 2023-11-07
 

src/binary_heap.rs

@@ -233,7 +233,7 @@ where
     /// assert_eq!(heap.peek(), Some(&5));
     /// ```
     pub fn peek(&self) -> Option<&T> {
-        self.data.as_slice().get(0)
+        self.data.as_slice().first()
     }
 
     /// Returns a mutable reference to the greatest item in the binary heap, or
@@ -297,6 +297,7 @@ where
 
     /// Removes the *top* (greatest if max-heap, smallest if min-heap) item from the binary heap and
     /// returns it, without checking if the binary heap is empty.
+    #[allow(clippy::missing_safety_doc)] // TODO
     pub unsafe fn pop_unchecked(&mut self) -> T {
         let mut item = self.data.pop_unchecked();
 
@@ -330,6 +331,7 @@ where
     }
 
     /// Pushes an item onto the binary heap without first checking if it's full.
+    #[allow(clippy::missing_safety_doc)] // TODO
     pub unsafe fn push_unchecked(&mut self, item: T) {
         let old_len = self.len();
         self.data.push_unchecked(item);

src/deque.rs

@@ -283,7 +283,7 @@ impl<T, const N: usize> Deque<T, N> {
         let index = self.front;
         self.full = false;
         self.front = Self::increment(self.front);
-        (self.buffer.get_unchecked_mut(index).as_ptr() as *const T).read()
+        self.buffer.get_unchecked_mut(index).as_ptr().read()
     }
 
     /// Removes an item from the back of the deque and returns it, without checking that the deque
@@ -297,7 +297,7 @@ impl<T, const N: usize> Deque<T, N> {
 
         self.full = false;
         self.back = Self::decrement(self.back);
-        (self.buffer.get_unchecked_mut(self.back).as_ptr() as *const T).read()
+        self.buffer.get_unchecked_mut(self.back).as_ptr().read()
     }
 
     /// Appends an `item` to the front of the deque

src/histbuf.rs

@@ -117,6 +117,21 @@ impl<T, const N: usize> HistoryBuffer<T, N> {
         }
     }
 
+    /// Returns true if the buffer is empty.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use heapless::HistoryBuffer;
+    ///
+    /// let x: HistoryBuffer<u8, 16> = HistoryBuffer::new();
+    /// assert!(x.is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Returns the capacity of the buffer, which is the length of the
     /// underlying backing array.
     #[inline]
@@ -219,7 +234,7 @@ impl<T, const N: usize> HistoryBuffer<T, N> {
     /// }
     ///
     /// ```
-    pub fn oldest_ordered<'a>(&'a self) -> OldestOrdered<'a, T, N> {
+    pub fn oldest_ordered(&self) -> OldestOrdered<'_, T, N> {
         if self.filled {
             OldestOrdered {
                 buf: self,

src/indexmap.rs

@@ -1,7 +1,7 @@
 use core::{
     borrow::Borrow,
     fmt,
-    hash::{BuildHasher, Hash, Hasher as _},
+    hash::{BuildHasher, Hash},
     iter::FromIterator,
     mem,
     num::NonZeroU32,
@@ -64,7 +64,7 @@ impl HashValue {
     }
 
     fn probe_distance(&self, mask: usize, current: usize) -> usize {
-        current.wrapping_sub(self.desired_pos(mask) as usize) & mask
+        current.wrapping_sub(self.desired_pos(mask)) & mask
     }
 }
 
@@ -364,7 +364,7 @@ where
     fn clone(&self) -> Self {
         Self {
             entries: self.entries.clone(),
-            indices: self.indices.clone(),
+            indices: self.indices,
         }
     }
 }
@@ -961,7 +961,7 @@ where
         K: Borrow<Q>,
         Q: ?Sized + Hash + Eq,
     {
-        if self.len() == 0 {
+        if self.is_empty() {
             return None;
         }
         let h = hash_with(key, &self.build_hasher);
@@ -1238,9 +1238,7 @@ where
     K: ?Sized + Hash,
     S: BuildHasher,
 {
-    let mut h = build_hasher.build_hasher();
-    key.hash(&mut h);
-    HashValue(h.finish() as u16)
+    HashValue(build_hasher.hash_one(key) as u16)
 }
 
 #[cfg(test)]

src/linear_map.rs

@@ -448,6 +448,7 @@ pub struct Iter<'a, K, V> {
 impl<'a, K, V> Iterator for Iter<'a, K, V> {
     type Item = (&'a K, &'a V);
 
+    #[allow(clippy::needless_borrowed_reference)]
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next().map(|&(ref k, ref v)| (k, v))
     }

src/mpmc.rs

@@ -145,7 +145,8 @@ impl<T, const N: usize> MpMcQueue<T, N> {
         crate::sealed::power_of_two::<N>();
 
         // Const assert on size.
-        Self::ASSERT[!(N < (IntSize::MAX as usize)) as usize];
+        #[allow(clippy::no_effect)]
+        Self::ASSERT[(N >= (IntSize::MAX as usize)) as usize];
 
         let mut cell_count = 0;
 
@@ -204,6 +205,7 @@ impl<T> Cell<T> {
     }
 }
 
+#[allow(clippy::comparison_chain)]
 unsafe fn dequeue<T>(
     buffer: *mut Cell<T>,
     dequeue_pos: &AtomicTargetSize,
@@ -243,6 +245,7 @@ unsafe fn dequeue<T>(
     Some(data)
 }
 
+#[allow(clippy::comparison_chain)]
 unsafe fn enqueue<T>(
     buffer: *mut Cell<T>,
     enqueue_pos: &AtomicTargetSize,

src/pool/arc.rs

@@ -221,7 +221,7 @@ where
     P: ArcPool,
 {
     fn as_ref(&self) -> &P::Data {
-        &**self
+        self
     }
 }
 

src/sealed.rs

@@ -1,29 +1,24 @@
-#[allow(dead_code)]
-#[allow(path_statements)]
+#[allow(dead_code, path_statements, clippy::no_effect)]
 pub(crate) const fn smaller_than<const N: usize, const MAX: usize>() {
     Assert::<N, MAX>::LESS;
 }
 
-#[allow(dead_code)]
-#[allow(path_statements)]
+#[allow(dead_code, path_statements, clippy::no_effect)]
 pub(crate) const fn greater_than_eq_0<const N: usize>() {
     Assert::<N, 0>::GREATER_EQ;
 }
 
-#[allow(dead_code)]
-#[allow(path_statements)]
+#[allow(dead_code, path_statements, clippy::no_effect)]
 pub(crate) const fn greater_than_0<const N: usize>() {
     Assert::<N, 0>::GREATER;
 }
 
-#[allow(dead_code)]
-#[allow(path_statements)]
+#[allow(dead_code, path_statements, clippy::no_effect)]
 pub(crate) const fn greater_than_1<const N: usize>() {
     Assert::<N, 1>::GREATER;
 }
 
-#[allow(dead_code)]
-#[allow(path_statements)]
+#[allow(dead_code, path_statements, clippy::no_effect)]
 pub(crate) const fn power_of_two<const N: usize>() {
     Assert::<N, 0>::GREATER;
     Assert::<N, 0>::POWER_OF_TWO;
@@ -42,6 +37,7 @@ impl<const L: usize, const R: usize> Assert<L, R> {
     pub const LESS_EQ: usize = R - L;
 
     /// Const assert hack
+    #[allow(clippy::erasing_op)]
     pub const NOT_EQ: isize = 0 / (R as isize - L as isize);
 
     /// Const assert hack