chore: fix lints

Author: funbiscuit

embedded-cli/src/arguments.rs

@@ -46,7 +46,7 @@ impl<'a> ArgList<'a> {
     }
 }
 
-impl<'a> PartialEq for ArgList<'a> {
+impl PartialEq for ArgList<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.args().eq(other.args())
     }

embedded-cli/src/buffer.rs

@@ -27,7 +27,7 @@ impl<const SIZE: usize> Buffer for [u8; SIZE] {
     }
 }
 
-impl<'a> Buffer for &'a mut [u8] {
+impl Buffer for &mut [u8] {
     fn as_slice(&self) -> &[u8] {
         self
     }

embedded-cli/src/cli.rs

@@ -56,7 +56,7 @@ where
     }
 }
 
-impl<'a, W, E> Debug for CliHandle<'a, W, E>
+impl<W, E> Debug for CliHandle<'_, W, E>
 where
     W: Write<Error = E>,
     E: embedded_io::Error,

embedded-cli/src/command.rs

@@ -92,14 +92,14 @@ impl<'a> RawCommand<'a> {
     }
 }
 
-impl<'a> Autocomplete for RawCommand<'a> {
+impl Autocomplete for RawCommand<'_> {
     #[cfg(feature = "autocomplete")]
     fn autocomplete(_: Request<'_>, _: &mut Autocompletion<'_>) {
         // noop
     }
 }
 
-impl<'a> Help for RawCommand<'a> {
+impl Help for RawCommand<'_> {
     #[cfg(feature = "help")]
     fn command_count() -> usize {
         0
@@ -156,7 +156,7 @@ mod tests {
         assert_eq!(
             RawCommand::from_tokens(&input_tokens).unwrap(),
             RawCommand {
-                name: name,
+                name,
                 args: ArgList::new(arg_tokens)
             }
         );

embedded-cli/src/service.rs

@@ -51,7 +51,7 @@ impl<'a> From<FromArgumentError<'a>> for ParseError<'a> {
     }
 }
 
-impl<'a, E: embedded_io::Error> From<E> for ProcessError<'a, E> {
+impl<E: embedded_io::Error> From<E> for ProcessError<'_, E> {
     fn from(value: E) -> Self {
         Self::WriteError(value)
     }

embedded-cli/src/utils.rs

@@ -123,9 +123,7 @@ pub fn encode_utf8(ch: char, buf: &mut [u8]) -> &str {
 
     buf[0] = code as u8 | first_b_mask;
 
-    unsafe {
-        return core::str::from_utf8_unchecked(&buf[..len]);
-    }
+    unsafe { core::str::from_utf8_unchecked(&buf[..len]) }
 }
 
 pub fn trim_start(input: &str) -> &str {

embedded-cli/src/writer.rs

@@ -11,7 +11,7 @@ pub struct Writer<'a, W: Write<Error = E>, E: Error> {
     writer: &'a mut W,
 }
 
-impl<'a, W: Write<Error = E>, E: Error> Debug for Writer<'a, W, E> {
+impl<W: Write<Error = E>, E: Error> Debug for Writer<'_, W, E> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Writer")
             .field("last_bytes", &self.last_bytes)
@@ -98,15 +98,15 @@ impl<'a, W: Write<Error = E>, E: Error> Writer<'a, W, E> {
     }
 }
 
-impl<'a, W: Write<Error = E>, E: Error> uWrite for Writer<'a, W, E> {
+impl<W: Write<Error = E>, E: Error> uWrite for Writer<'_, W, E> {
     type Error = E;
 
     fn write_str(&mut self, s: &str) -> Result<(), E> {
         self.write_str(s)
     }
 }
 
-impl<'a, W: Write<Error = E>, E: Error> core::fmt::Write for Writer<'a, W, E> {
+impl<W: Write<Error = E>, E: Error> core::fmt::Write for Writer<'_, W, E> {
     fn write_str(&mut self, s: &str) -> core::fmt::Result {
         self.write_str(s).map_err(|_| core::fmt::Error)?;
         Ok(())

embedded-cli/tests/cli/terminal.rs

@@ -68,7 +68,7 @@ impl Terminal {
             };
 
             if let Some(normal) = normal {
-                for c in normal.chars().into_iter() {
+                for c in normal.chars() {
                     match c {
                         '\r' => {
                             cursor = 0;
@@ -80,16 +80,13 @@ impl Terminal {
                         c if c >= ' ' => {
                             let current = output.last_mut().unwrap();
                             if current.chars().count() > cursor {
-                                current
-                                    .remove(current.char_indices().skip(cursor).next().unwrap().0);
+                                current.remove(current.char_indices().nth(cursor).unwrap().0);
                             } else {
                                 while current.chars().count() < cursor {
                                     current.push(' ');
                                 }
                             }
-                            if let Some((insert_pos, _)) =
-                                current.char_indices().skip(cursor).next()
-                            {
+                            if let Some((insert_pos, _)) = current.char_indices().nth(cursor) {
                                 current.insert(insert_pos, c);
                             } else {
                                 current.push(c);
@@ -110,21 +107,18 @@ impl Terminal {
                     }
                     // cursor backward
                     "\x1B[D" => {
-                        if cursor > 0 {
-                            cursor -= 1;
-                        }
+                        cursor = cursor.saturating_sub(1);
                     }
                     // delete char
                     "\x1B[P" => {
                         if current.chars().count() > cursor {
-                            current.remove(current.char_indices().skip(cursor).next().unwrap().0);
+                            current.remove(current.char_indices().nth(cursor).unwrap().0);
                         }
                     }
                     // insert char
                     "\x1B[@" => {
                         if current.chars().count() > cursor {
-                            current
-                                .insert(current.char_indices().skip(cursor).next().unwrap().0, ' ');
+                            current.insert(current.char_indices().nth(cursor).unwrap().0, ' ');
                         }
                     }
                     // clear whole line

embedded-cli/tests/cli/wrapper.rs

@@ -55,7 +55,7 @@ macro_rules! impl_convert {
             }
         }
 
-        impl crate::wrapper::CommandConvert for $to_ty {
+        impl $crate::wrapper::CommandConvert for $to_ty {
             fn convert(
                 cmd: embedded_cli::command::RawCommand<'_>,
             ) -> Result<Self, crate::wrapper::ParseError> {
@@ -153,7 +153,7 @@ impl<'a> From<CliParseError<'a>> for ParseError {
                 Self::UnexpectedLongOption { name: name.into() }
             }
             CliParseError::UnexpectedShortOption { name } => {
-                Self::UnexpectedShortOption { name: name.into() }
+                Self::UnexpectedShortOption { name: name }
             }
             CliParseError::UnknownCommand => Self::UnknownCommand,
             _ => Self::Other,