fixed minor warnings

Author: JavaDerg

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "imstr"
-version = "0.2.0"
-edition = "2021"
+version = "0.3.0"
+edition = "2024"
 description = "Cheaply clonable and slicable immutable strings"
 documentation = "https://docs.rs/imstr"
 repository = "https://github.com/xfbs/imstr"

src/data.rs

@@ -115,15 +115,15 @@ impl<T> Data<T> for Arc<T> {
     }
 
     fn get(&self) -> &T {
-        &self
+        self
     }
 
     fn get_mut(&mut self) -> Option<&mut T> {
         Arc::get_mut(self)
     }
 
     fn ptr_eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self, &other)
+        Arc::ptr_eq(self, other)
     }
 }
 
@@ -133,15 +133,15 @@ impl<T> Data<T> for Rc<T> {
     }
 
     fn get(&self) -> &T {
-        &self
+        self
     }
 
     fn get_mut(&mut self) -> Option<&mut T> {
         Rc::get_mut(self)
     }
 
     fn ptr_eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self, &other)
+        Rc::ptr_eq(self, other)
     }
 }
 
@@ -151,15 +151,15 @@ impl<T: Clone> Data<T> for Box<T> {
     }
 
     fn get(&self) -> &T {
-        &self
+        self
     }
 
     fn get_mut(&mut self) -> Option<&mut T> {
         Some(self)
     }
 
     fn ptr_eq(&self, other: &Self) -> bool {
-        core::ptr::eq(&self, &other)
+        core::ptr::eq(self, other)
     }
 }
 

src/error.rs

@@ -1,6 +1,6 @@
 //! Error types
 use alloc::fmt::{Display, Formatter, Result};
-pub use alloc::string::{FromUtf16Error, FromUtf8Error};
+pub use alloc::string::{FromUtf8Error, FromUtf16Error};
 
 /// A possible error when slicing a [`ImString`](crate::ImString).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -46,8 +46,8 @@ fn slice_error_traits() {
         // implements partial eq
         assert_eq!(error, new);
         // implements debug
-        alloc::format!("{error:?}");
+        let _ = alloc::format!("{error:?}");
         // implements display
-        alloc::format!("{new}");
+        let _ = alloc::format!("{new}");
     }
 }

src/nom.rs

@@ -3,9 +3,10 @@ use crate::string::{CharIndices, Chars, ImString};
 use alloc::string::String;
 use core::str::FromStr;
 use nom::{
-    error::ErrorKind, AsBytes, Compare, CompareResult, Err, ExtendInto, FindSubstring, Input,
-    Needed, Offset, ParseTo,
+    AsBytes, Compare, CompareResult, ExtendInto, FindSubstring, Input, Needed, Offset, ParseTo,
 };
+#[cfg(test)]
+use nom::{Err, error::ErrorKind};
 
 /// Test that the specified function behaves the same regardless of whether the type is `&str` or
 /// `ImString`.

src/string.rs

@@ -21,10 +21,10 @@ use core::{
     },
     str::FromStr,
 };
-#[cfg(feature = "std")]
-use std::{ffi::OsStr, net::ToSocketAddrs, path::Path};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "std")]
+use std::{ffi::OsStr, net::ToSocketAddrs, path::Path};
 
 /// Threadsafe shared storage for string.
 pub type Threadsafe = Arc<String>;
@@ -136,7 +136,7 @@ impl<S: Data<String>> ImString<S> {
     /// ```
     pub fn from_std_string(string: String) -> Self {
         ImString {
-            offset: 0..string.as_bytes().len(),
+            offset: 0..string.len(),
             string: S::new(string),
         }
     }
@@ -183,7 +183,7 @@ impl<S: Data<String>> ImString<S> {
         }
 
         let string = self.string.get_mut().unwrap();
-        return &mut string[self.offset.clone()];
+        &mut string[self.offset.clone()]
     }
 
     unsafe fn try_modify_unchecked<F: FnOnce(&mut String)>(&mut self, f: F) -> bool {
@@ -235,11 +235,11 @@ impl<S: Data<String>> ImString<S> {
     /// assert_eq!(string, "hello");
     /// ```
     pub fn into_std_string(mut self) -> String {
-        if self.offset.start == 0 {
-            if let Some(string) = self.string.get_mut() {
-                string.truncate(self.offset.end);
-                return core::mem::take(string);
-            }
+        if self.offset.start == 0
+            && let Some(string) = self.string.get_mut()
+        {
+            string.truncate(self.offset.end);
+            return core::mem::take(string);
         }
 
         self.as_str().to_string()
@@ -390,7 +390,7 @@ impl<S: Data<String>> ImString<S> {
     /// assert_eq!(sparkle_heart, "💖");
     /// ```
     pub unsafe fn from_utf8_unchecked(vec: Vec<u8>) -> Self {
-        ImString::from_std_string(String::from_utf8_unchecked(vec))
+        unsafe { ImString::from_std_string(String::from_utf8_unchecked(vec)) }
     }
 
     /// Converts an [`ImString`] into a byte vector.
@@ -414,8 +414,8 @@ impl<S: Data<String>> ImString<S> {
 
     unsafe fn unchecked_append<F: FnOnce(String) -> String>(&mut self, f: F) {
         match self.string.get_mut() {
-            Some(mut string_ref) if self.offset.start == 0 => {
-                let mut string: String = core::mem::take(&mut string_ref);
+            Some(string_ref) if self.offset.start == 0 => {
+                let mut string: String = core::mem::take(string_ref);
                 string.truncate(self.offset.end);
                 *string_ref = f(string);
             }
@@ -425,7 +425,7 @@ impl<S: Data<String>> ImString<S> {
             }
         }
 
-        self.offset.end = self.string.get().as_bytes().len();
+        self.offset.end = self.string.get().len();
     }
 
     /// Inserts a character into this string at the specified index.
@@ -534,7 +534,7 @@ impl<S: Data<String>> ImString<S> {
     /// assert_eq!(string.pop(), None);
     /// ```
     pub fn pop(&mut self) -> Option<char> {
-        let last_char = self.as_str().chars().rev().next()?;
+        let last_char = self.as_str().chars().next_back()?;
         self.offset.end -= last_char.len_utf8();
         Some(last_char)
     }
@@ -1135,7 +1135,7 @@ impl<S: Data<String>> Eq for ImString<S> {}
 
 impl<S: Data<String>> PartialOrd<ImString<S>> for ImString<S> {
     fn partial_cmp(&self, other: &ImString<S>) -> Option<Ordering> {
-        self.as_str().partial_cmp(other.as_str())
+        Some(self.cmp(other))
     }
 }
 
@@ -1199,8 +1199,8 @@ impl<S: Data<String>> Index<RangeFrom<usize>> for ImString<S> {
 
 impl<S: Data<String>> Index<RangeFull> for ImString<S> {
     type Output = str;
-    fn index(&self, index: RangeFull) -> &str {
-        &self.as_str()[index]
+    fn index(&self, _index: RangeFull) -> &str {
+        self.as_str()
     }
 }
 
@@ -1601,7 +1601,7 @@ mod tests {
 
             // make sure both versions are identical
             assert_eq!(string_uppercase, &*string_slice);
-            drop(string_slice);
+            let _ = string_slice;
             assert_eq!(string, string_uppercase);
         }