Fix clippy::semicolon_if_nothing_returned warnings

Author: pvdrz

src/binary_heap.rs

@@ -222,7 +222,7 @@ where
     /// assert!(heap.is_empty());
     /// ```
     pub fn clear(&mut self) {
-        self.data.clear()
+        self.data.clear();
     }
 
     /// Returns the length of the binary heap.

src/deque.rs

@@ -895,7 +895,7 @@ impl<T, S: VecStorage<T> + ?Sized> Extend<T> for DequeInner<T, S> {
 }
 impl<'a, T: 'a + Copy, S: VecStorage<T> + ?Sized> Extend<&'a T> for DequeInner<T, S> {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().copied())
+        self.extend(iter.into_iter().copied());
     }
 }
 

src/histbuf.rs

@@ -292,7 +292,7 @@ impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
             ptr::drop_in_place(ptr::slice_from_raw_parts_mut(
                 self.data.borrow_mut().as_mut_ptr().cast::<T>(),
                 self.len(),
-            ))
+            ));
         }
     }
 
@@ -513,7 +513,7 @@ where
     where
         I: IntoIterator<Item = &'a T>,
     {
-        self.extend(iter.into_iter().cloned())
+        self.extend(iter.into_iter().cloned());
     }
 }
 
@@ -817,7 +817,7 @@ mod tests {
             assert_eq_iter(
                 [head, tail].iter().copied().flatten(),
                 buffer.oldest_ordered(),
-            )
+            );
         }
     }
 

src/indexmap.rs

@@ -1296,7 +1296,7 @@ where
     where
         I: IntoIterator<Item = (&'a K, &'a V)>,
     {
-        self.extend(iterable.into_iter().map(|(&key, &value)| (key, value)))
+        self.extend(iterable.into_iter().map(|(&key, &value)| (key, value)));
     }
 }
 
@@ -1479,7 +1479,7 @@ mod tests {
                      mem::size_of::<u16>() // hash
                 ) + // buckets
                 mem::size_of::<usize>() // entries.length
-        )
+        );
     }
 
     #[test]
@@ -1671,7 +1671,7 @@ mod tests {
                 assert_eq!(value, *v.insert(value).unwrap());
             }
         };
-        assert_eq!(value, *src.get(&key).unwrap())
+        assert_eq!(value, *src.get(&key).unwrap());
     }
 
     #[test]
@@ -1691,7 +1691,7 @@ mod tests {
                 panic!("Entry not found");
             }
         };
-        assert_eq!(value2, *src.get(&key).unwrap())
+        assert_eq!(value2, *src.get(&key).unwrap());
     }
 
     #[test]

src/indexset.rs

@@ -212,7 +212,7 @@ impl<T, S, const N: usize> IndexSet<T, S, N> {
     /// assert!(v.is_empty());
     /// ```
     pub fn clear(&mut self) {
-        self.map.clear()
+        self.map.clear();
     }
 }
 
@@ -560,7 +560,7 @@ where
     where
         I: IntoIterator<Item = T>,
     {
-        self.map.extend(iterable.into_iter().map(|k| (k, ())))
+        self.map.extend(iterable.into_iter().map(|k| (k, ())));
     }
 }
 
@@ -573,7 +573,7 @@ where
     where
         I: IntoIterator<Item = &'a T>,
     {
-        self.extend(iterable.into_iter().cloned())
+        self.extend(iterable.into_iter().cloned());
     }
 }
 

src/lib.rs

@@ -147,6 +147,7 @@
     clippy::option_if_let_else,
     clippy::ptr_as_ptr,
     clippy::doc_markdown,
+    clippy::semicolon_if_nothing_returned
 )]
 
 pub use binary_heap::BinaryHeap;

src/linear_map.rs

@@ -85,7 +85,7 @@ where
     /// assert!(map.is_empty());
     /// ```
     pub fn clear(&mut self) {
-        self.buffer.clear()
+        self.buffer.clear();
     }
 
     /// Returns true if the map contains a value for the specified key.

src/sorted_linked_list.rs

@@ -769,7 +769,7 @@ where
     /// ```
     #[inline]
     pub fn finish(self) {
-        drop(self)
+        drop(self);
     }
 }
 
@@ -924,14 +924,14 @@ mod tests {
         ll.push(2).unwrap();
         ll.push(3).unwrap();
 
-        assert!(ll.is_full())
+        assert!(ll.is_full());
     }
 
     #[test]
     fn test_empty() {
         let ll: SortedLinkedList<u32, LinkedIndexUsize, Max, 3> = SortedLinkedList::new_usize();
 
-        assert!(ll.is_empty())
+        assert!(ll.is_empty());
     }
 
     #[test]

src/spsc.rs

@@ -307,7 +307,7 @@ impl<T, S: Storage> QueueInner<T, S> {
     /// to create a copy of `item`, which could result in `T`'s destructor running on `item`
     /// twice.
     pub unsafe fn enqueue_unchecked(&mut self, val: T) {
-        self.inner_enqueue_unchecked(val)
+        self.inner_enqueue_unchecked(val);
     }
 
     // The memory for dequeuing is "owned" by the head pointer,.
@@ -677,7 +677,7 @@ impl<T, S: Storage> ProducerInner<'_, T, S> {
     /// See [`Queue::enqueue_unchecked`]
     #[inline]
     pub unsafe fn enqueue_unchecked(&mut self, val: T) {
-        self.rb.inner_enqueue_unchecked(val)
+        self.rb.inner_enqueue_unchecked(val);
     }
 
     /// Returns if there is any space to enqueue a new item. When this returns true, at

src/string/mod.rs

@@ -519,7 +519,7 @@ impl<S: VecStorage<u8> + ?Sized> StringInner<S> {
     pub fn truncate(&mut self, new_len: usize) {
         if new_len <= self.len() {
             assert!(self.is_char_boundary(new_len));
-            self.vec.truncate(new_len)
+            self.vec.truncate(new_len);
         }
     }
 
@@ -619,7 +619,7 @@ impl<S: VecStorage<u8> + ?Sized> StringInner<S> {
     /// ```
     #[inline]
     pub fn clear(&mut self) {
-        self.vec.clear()
+        self.vec.clear();
     }
 }
 
@@ -701,7 +701,7 @@ impl<S: VecStorage<u8> + ?Sized> fmt::Display for StringInner<S> {
 impl<S: VecStorage<u8> + ?Sized> hash::Hash for StringInner<S> {
     #[inline]
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
-        <str as hash::Hash>::hash(self, hasher)
+        <str as hash::Hash>::hash(self, hasher);
     }
 }
 
@@ -1153,26 +1153,26 @@ mod tests {
         let number = 5;
         let float = 3.12;
         let formatted = format!(15; "{:0>3} plus {float}", number).unwrap();
-        assert_eq!(formatted, "005 plus 3.12")
+        assert_eq!(formatted, "005 plus 3.12");
     }
     #[test]
     fn format_inferred_capacity() {
         let number = 5;
         let float = 3.12;
         let formatted: String<15> = format!("{:0>3} plus {float}", number).unwrap();
-        assert_eq!(formatted, "005 plus 3.12")
+        assert_eq!(formatted, "005 plus 3.12");
     }
 
     #[test]
     fn format_overflow() {
         let i = 1234567;
         let formatted = format!(4; "13{}", i);
-        assert_eq!(formatted, Err(core::fmt::Error))
+        assert_eq!(formatted, Err(core::fmt::Error));
     }
 
     #[test]
     fn format_plain_string_overflow() {
         let formatted = format!(2; "123");
-        assert_eq!(formatted, Err(core::fmt::Error))
+        assert_eq!(formatted, Err(core::fmt::Error));
     }
 }