style: Make clippy happy

clap_builder/src/builder/command.rs

@@ -631,7 +631,7 @@ impl Command {
     /// [`env::args_os`]: std::env::args_os()
     /// [`Command::get_matches`]: Command::get_matches()
     pub fn get_matches_mut(&mut self) -> ArgMatches {
-        self.try_get_matches_from_mut(&mut env::args_os())
+        self.try_get_matches_from_mut(env::args_os())
             .unwrap_or_else(|e| e.exit())
     }
 

clap_builder/src/builder/debug_asserts.rs

@@ -370,7 +370,7 @@ pub(crate) fn assert_app(cmd: &Command) {
             "Command {}: {}",
             cmd.get_name(),
             "`{bin}` template variable was removed in clap5, use `{name}` instead"
-        )
+        );
     }
 
     cmd._panic_on_missing_help(cmd.is_help_expected_set());

clap_complete/src/dynamic/completer.rs

@@ -92,7 +92,7 @@ pub fn complete(
                         if value.is_some() {
                             ParseState::ValueDone
                         } else {
-                            ParseState::Opt(opt.unwrap().clone())
+                            ParseState::Opt(opt.unwrap())
                         }
                     }
                     Some(clap::ArgAction::SetTrue) | Some(clap::ArgAction::SetFalse) => {
@@ -115,7 +115,7 @@ pub fn complete(
                 Some(opt) => {
                     state = match short.next_value_os() {
                         Some(_) => ParseState::ValueDone,
-                        None => ParseState::Opt(opt.clone()),
+                        None => ParseState::Opt(opt),
                     };
                 }
                 None => {
@@ -142,7 +142,7 @@ pub fn complete(
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-enum ParseState {
+enum ParseState<'a> {
     /// Parsing a value done, there is no state to record.
     ValueDone,
 
@@ -150,7 +150,7 @@ enum ParseState {
     Pos(usize),
 
     /// Parsing a optional flag argument
-    Opt(clap::Arg),
+    Opt(&'a clap::Arg),
 }
 
 fn complete_arg(
@@ -158,7 +158,7 @@ fn complete_arg(
     cmd: &clap::Command,
     current_dir: Option<&std::path::Path>,
     pos_index: usize,
-    state: ParseState,
+    state: ParseState<'_>,
 ) -> Result<Vec<CompletionCandidate>, std::io::Error> {
     debug!(
         "complete_arg: arg={:?}, cmd={:?}, current_dir={:?}, pos_index={:?}, state={:?}",
@@ -202,7 +202,7 @@ fn complete_arg(
                         completions.extend(hidden_longs_aliases(cmd).into_iter().filter(|comp| {
                             comp.get_content()
                                 .starts_with(format!("--{}", flag).as_str())
-                        }))
+                        }));
                     }
                 }
             } else if arg.is_escape() || arg.is_stdio() || arg.is_empty() {
@@ -236,7 +236,7 @@ fn complete_arg(
             } else if let Some(short) = arg.to_short() {
                 if !short.is_negative_number() {
                     // Find the first takes_value option.
-                    let (leading_flags, takes_value_opt, mut short) = parse_shortflags(&cmd, short);
+                    let (leading_flags, takes_value_opt, mut short) = parse_shortflags(cmd, short);
 
                     // Clone `short` to `peek_short` to peek whether the next flag is a `=`.
                     if let Some(opt) = takes_value_opt {
@@ -250,7 +250,7 @@ fn complete_arg(
 
                         let value = short.next_value_os().unwrap_or(OsStr::new(""));
                         completions.extend(
-                            complete_arg_value(value.to_str().ok_or(value), &opt, current_dir)
+                            complete_arg_value(value.to_str().ok_or(value), opt, current_dir)
                                 .into_iter()
                                 .map(|comp| {
                                     CompletionCandidate::new(format!(
@@ -299,11 +299,11 @@ fn complete_arg(
             }
         }
         ParseState::Opt(opt) => {
-            completions.extend(complete_arg_value(arg.to_value(), &opt, current_dir));
+            completions.extend(complete_arg_value(arg.to_value(), opt, current_dir));
         }
     }
     if completions.iter().any(|a| a.is_visible()) {
-        completions.retain(|a| a.is_visible())
+        completions.retain(|a| a.is_visible());
     }
 
     Ok(completions)
@@ -452,7 +452,7 @@ fn longs_and_visible_aliases(p: &clap::Command) -> Vec<CompletionCandidate> {
         .filter_map(|a| {
             a.get_long_and_visible_aliases().map(|longs| {
                 longs.into_iter().map(|s| {
-                    CompletionCandidate::new(format!("--{}", s.to_string()))
+                    CompletionCandidate::new(format!("--{}", s))
                         .help(a.get_help().cloned())
                         .visible(!a.is_hide_set())
                 })
@@ -470,7 +470,7 @@ fn hidden_longs_aliases(p: &clap::Command) -> Vec<CompletionCandidate> {
         .filter_map(|a| {
             a.get_aliases().map(|longs| {
                 longs.into_iter().map(|s| {
-                    CompletionCandidate::new(format!("--{}", s.to_string()))
+                    CompletionCandidate::new(format!("--{}", s))
                         .help(a.get_help().cloned())
                         .visible(false)
                 })
@@ -526,7 +526,7 @@ fn subcommands(p: &clap::Command) -> Vec<CompletionCandidate> {
                         .help(sc.get_about().cloned())
                         .visible(!sc.is_hide_set())
                 })
-                .chain(sc.get_aliases().into_iter().map(|s| {
+                .chain(sc.get_aliases().map(|s| {
                     CompletionCandidate::new(s.to_string())
                         .help(sc.get_about().cloned())
                         .visible(false)
@@ -535,11 +535,11 @@ fn subcommands(p: &clap::Command) -> Vec<CompletionCandidate> {
         .collect()
 }
 
-/// Parse the short flags and find the first takes_value option.
-fn parse_shortflags<'s>(
-    cmd: &clap::Command,
+/// Parse the short flags and find the first `takes_value` option.
+fn parse_shortflags<'c, 's>(
+    cmd: &'c clap::Command,
     mut short: clap_lex::ShortFlags<'s>,
-) -> (OsString, Option<clap::Arg>, clap_lex::ShortFlags<'s>) {
+) -> (OsString, Option<&'c clap::Arg>, clap_lex::ShortFlags<'s>) {
     let takes_value_opt;
     let mut leading_flags = OsString::new();
     // Find the first takes_value option.
@@ -579,7 +579,7 @@ fn parse_shortflags<'s>(
         }
     }
 
-    (leading_flags, takes_value_opt.cloned(), short)
+    (leading_flags, takes_value_opt, short)
 }
 
 /// A completion candidate definition

clap_complete/src/dynamic/shells/elvish.rs

@@ -8,7 +8,7 @@ impl crate::dynamic::Completer for Elvish {
     }
     fn write_registration(
         &self,
-        name: &str,
+        _name: &str,
         bin: &str,
         completer: &str,
         buf: &mut dyn std::io::Write,

clap_complete/tests/testsuite/dynamic.rs

@@ -52,7 +52,7 @@ fn suggest_hidden_long_flags() {
     assert_data_eq!(
         complete!(cmd, "--hello-world-h"),
         snapbox::str!["--hello-world-hidden"]
-    )
+    );
 }
 
 #[test]
@@ -90,7 +90,7 @@ test_hidden-alias_visible"
     assert_data_eq!(
         complete!(cmd, "test_hidden-alias_h"),
         snapbox::str!["test_hidden-alias_hidden"]
-    )
+    );
 }
 
 #[test]
@@ -142,7 +142,7 @@ fn suggest_hidden_possible_value() {
     assert_data_eq!(
         complete!(cmd, "--test=test-h"),
         snapbox::str!["--test=test-hidden\tSay hello to the moon"]
-    )
+    );
 }
 
 #[test]
@@ -436,7 +436,7 @@ pos_c"
     assert_data_eq!(
         complete!(cmd, "-ciF=[TAB]", current_dir = Some(testdir_path)),
         snapbox::str![""]
-    )
+    );
 }
 
 fn complete(cmd: &mut Command, args: impl AsRef<str>, current_dir: Option<&Path>) -> String {