style: Make clippy happy

clap_complete/src/shells/elvish.rs

@@ -20,8 +20,7 @@ impl Generator for Elvish {
             .get_bin_name()
             .expect("crate::generate should have set the bin_name");
 
-        let mut names = vec![];
-        let subcommands_cases = generate_inner(cmd, "", &mut names);
+        let subcommands_cases = generate_inner(cmd, "");
 
         let result = format!(
             r#"
@@ -67,11 +66,7 @@ fn get_tooltip<T: ToString>(help: Option<&StyledStr>, data: T) -> String {
     }
 }
 
-fn generate_inner<'help>(
-    p: &Command,
-    previous_command_name: &str,
-    names: &mut Vec<&'help str>,
-) -> String {
+fn generate_inner(p: &Command, previous_command_name: &str) -> String {
     debug!("generate_inner");
 
     let command_name = if previous_command_name.is_empty() {
@@ -135,7 +130,7 @@ fn generate_inner<'help>(
     );
 
     for subcommand in p.get_subcommands() {
-        let subcommand_subcommands_cases = generate_inner(subcommand, &command_name, names);
+        let subcommand_subcommands_cases = generate_inner(subcommand, &command_name);
         subcommands_cases.push_str(&subcommand_subcommands_cases);
     }
 

clap_complete/src/shells/powershell.rs

@@ -20,8 +20,7 @@ impl Generator for PowerShell {
             .get_bin_name()
             .expect("crate::generate should have set the bin_name");
 
-        let mut names = vec![];
-        let subcommands_cases = generate_inner(cmd, "", &mut names);
+        let subcommands_cases = generate_inner(cmd, "");
 
         let result = format!(
             r#"
@@ -72,11 +71,7 @@ fn get_tooltip<T: ToString>(help: Option<&StyledStr>, data: T) -> String {
     }
 }
 
-fn generate_inner<'help>(
-    p: &Command,
-    previous_command_name: &str,
-    names: &mut Vec<&'help str>,
-) -> String {
+fn generate_inner(p: &Command, previous_command_name: &str) -> String {
     debug!("generate_inner");
 
     let command_name = if previous_command_name.is_empty() {
@@ -171,7 +166,7 @@ fn generate_inner<'help>(
     );
 
     for subcommand in p.get_subcommands() {
-        let subcommand_subcommands_cases = generate_inner(subcommand, &command_name, names);
+        let subcommand_subcommands_cases = generate_inner(subcommand, &command_name);
         subcommands_cases.push_str(&subcommand_subcommands_cases);
     }
 

clap_complete/src/shells/zsh.rs

@@ -646,7 +646,7 @@ fn write_positionals_of(p: &Command) -> String {
                 .replace(']', "\\]")
                 .replace('\'', "'\\''")
                 .replace(':', "\\:"),
-            value_completion = value_completion(arg).unwrap_or_else(|| "".to_string())
+            value_completion = value_completion(arg).unwrap_or_default()
         );
 
         debug!("write_positionals_of:iter: Wrote...{}", a);

clap_complete_fig/src/fig.rs

@@ -32,7 +32,7 @@ impl Generator for Fig {
         )
         .unwrap();
 
-        gen_fig_inner(command, &[], 2, cmd, &mut buffer);
+        gen_fig_inner(&[], 2, cmd, &mut buffer);
 
         write!(&mut buffer, "}};\n\nexport default completion;\n").unwrap();
 
@@ -51,13 +51,7 @@ fn escape_string(string: &str) -> String {
         .replace('\r', "")
 }
 
-fn gen_fig_inner(
-    root_command: &str,
-    parent_commands: &[&str],
-    indent: usize,
-    cmd: &Command,
-    buffer: &mut String,
-) {
+fn gen_fig_inner(parent_commands: &[&str], indent: usize, cmd: &Command, buffer: &mut String) {
     if cmd.has_subcommands() {
         write!(buffer, "{:indent$}subcommands: [\n", "", indent = indent).unwrap();
         // generate subcommands
@@ -113,13 +107,7 @@ fn gen_fig_inner(
 
             let mut parent_commands: Vec<_> = parent_commands.into();
             parent_commands.push(subcommand.get_name());
-            gen_fig_inner(
-                root_command,
-                &parent_commands,
-                indent + 4,
-                subcommand,
-                buffer,
-            );
+            gen_fig_inner(&parent_commands, indent + 4, subcommand, buffer);
 
             write!(buffer, "{:indent$}}},\n", "", indent = indent + 2).unwrap();
         }

clap_lex/tests/lexer.rs

@@ -5,7 +5,7 @@ fn insert() {
 
     assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("bin")));
     assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("a")));
-    raw.insert(&cursor, &["1", "2", "3"]);
+    raw.insert(&cursor, ["1", "2", "3"]);
     assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("1")));
     assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("2")));
     assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("3")));

clap_mangen/src/render.rs

@@ -300,7 +300,7 @@ fn option_environment(opt: &clap::Arg) -> Option<Vec<Inline>> {
     } else if let Some(env) = opt.get_env() {
         return Some(vec![
             roman("May also be specified with the "),
-            bold(env.to_string_lossy().to_owned()),
+            bold(env.to_string_lossy().into_owned()),
             roman(" environment variable. "),
         ]);
     }

src/builder/command.rs

@@ -675,7 +675,7 @@ impl Command {
                     );
 
                     debug!("Command::try_get_matches_from_mut: Reinserting command into arguments so subcommand parser matches it");
-                    raw_args.insert(&cursor, &[&command]);
+                    raw_args.insert(&cursor, [&command]);
                     debug!("Command::try_get_matches_from_mut: Clearing name and bin_name so that displayed command name starts with applet name");
                     self.name = "".into();
                     self.bin_name = None;

src/builder/os_str.rs

@@ -116,7 +116,7 @@ impl From<&'static std::ffi::OsStr> for OsStr {
 
 impl From<&'_ &'static std::ffi::OsStr> for OsStr {
     fn from(name: &'_ &'static std::ffi::OsStr) -> Self {
-        Self::from_static_ref(*name)
+        Self::from_static_ref(name)
     }
 }
 

src/builder/str.rs

@@ -66,7 +66,7 @@ impl From<&'static str> for Str {
 
 impl From<&'_ &'static str> for Str {
     fn from(name: &'_ &'static str) -> Self {
-        Self::from_static_ref(*name)
+        Self::from_static_ref(name)
     }
 }
 

src/output/help.rs

@@ -18,7 +18,7 @@ pub(crate) fn write_help(writer: &mut StyledStr, cmd: &Command, usage: &Usage<'_
             use super::HelpTemplate;
             if let Some(tmpl) = cmd.get_help_template() {
                 for (style, content) in tmpl.iter() {
-                    if style == None {
+                    if style.is_none() {
                         HelpTemplate::new(writer, cmd, usage, use_long)
                             .write_templated_help(content);
                     } else {

src/output/help_template.rs

@@ -427,7 +427,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
             // If it's NextLineHelp we don't care to compute how long it is because it may be
             // NextLineHelp on purpose simply *because* it's so long and would throw off all other
             // args alignment
-            should_show_arg(self.use_long, *arg)
+            should_show_arg(self.use_long, arg)
         }) {
             if longest_filter(arg) {
                 longest = longest.max(display_width(&arg.to_string()));
@@ -674,7 +674,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
     /// Will use next line help on writing args.
     fn will_args_wrap(&self, args: &[&Arg], longest: usize) -> bool {
         args.iter()
-            .filter(|arg| should_show_arg(self.use_long, *arg))
+            .filter(|arg| should_show_arg(self.use_long, arg))
             .any(|arg| {
                 let spec_vals = &self.spec_vals(arg);
                 self.arg_next_line_help(arg, spec_vals, longest)

src/parser/parser.rs

@@ -1573,7 +1573,7 @@ impl<'cmd> Parser<'cmd> {
             suggested_trailing_arg,
             Usage::new(self.cmd)
                 .required(&required)
-                .create_usage_with_title(&*used),
+                .create_usage_with_title(&used),
         )
     }
 

tests/builder/app_settings.rs

@@ -315,7 +315,7 @@ Options:
         .about("tests stuff")
         .version("1.3")
         .hide_possible_values(true)
-        .args(&[
+        .args([
             arg!(-o --opt <opt> "some option").value_parser(["one", "two"]),
             arg!([arg1] "some pos arg").value_parser(["three", "four"]),
         ]);
@@ -327,7 +327,7 @@ Options:
 fn stop_delim_values_only_pos_follows() {
     let r = Command::new("onlypos")
         .dont_delimit_trailing_values(true)
-        .args(&[arg!(f: -f <flag> "some opt"), arg!([arg] ... "some arg")])
+        .args([arg!(f: -f <flag> "some opt"), arg!([arg] ... "some arg")])
         .try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
     assert!(r.is_ok(), "{}", r.unwrap_err());
     let m = r.unwrap();
@@ -338,7 +338,7 @@ fn stop_delim_values_only_pos_follows() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["-f", "-g,x"]
+        ["-f", "-g,x"]
     );
 }
 
@@ -355,14 +355,14 @@ fn dont_delim_values_trailingvararg() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["test", "--foo", "-Wl,-bar"]
+        ["test", "--foo", "-Wl,-bar"]
     );
 }
 
 #[test]
 fn delim_values_only_pos_follows() {
     let r = Command::new("onlypos")
-        .args(&[arg!(f: -f [flag] "some opt"), arg!([arg] ... "some arg")])
+        .args([arg!(f: -f [flag] "some opt"), arg!([arg] ... "some arg")])
         .try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
     assert!(r.is_ok(), "{}", r.unwrap_err());
     let m = r.unwrap();
@@ -373,7 +373,7 @@ fn delim_values_only_pos_follows() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["-f", "-g,x"]
+        ["-f", "-g,x"]
     );
 }
 
@@ -389,14 +389,14 @@ fn delim_values_trailingvararg() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["test", "--foo", "-Wl,-bar"]
+        ["test", "--foo", "-Wl,-bar"]
     );
 }
 
 #[test]
 fn delim_values_only_pos_follows_with_delim() {
     let r = Command::new("onlypos")
-        .args(&[
+        .args([
             arg!(f: -f [flag] "some opt"),
             arg!([arg] ... "some arg").value_delimiter(','),
         ])
@@ -410,7 +410,7 @@ fn delim_values_only_pos_follows_with_delim() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["-f", "-g", "x"]
+        ["-f", "-g", "x"]
     );
 }
 
@@ -430,7 +430,7 @@ fn delim_values_trailingvararg_with_delim() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["test", "--foo", "-Wl", "-bar"]
+        ["test", "--foo", "-Wl", "-bar"]
     );
 }
 
@@ -623,7 +623,7 @@ fn disable_help_subcommand() {
 
 #[test]
 fn dont_collapse_args() {
-    let cmd = Command::new("clap-test").version("v1.4.8").args(&[
+    let cmd = Command::new("clap-test").version("v1.4.8").args([
         Arg::new("arg1").help("some"),
         Arg::new("arg2").help("some"),
         Arg::new("arg3").help("some"),
@@ -1170,7 +1170,7 @@ fn aaos_opts_mult_req_delims() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["some", "other", "one", "two"]
+        ["some", "other", "one", "two"]
     );
 }
 
@@ -1201,7 +1201,7 @@ fn aaos_opts_mult() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["first", "overrides", "some", "other", "val"]
+        ["first", "overrides", "some", "other", "val"]
     );
 }
 
@@ -1219,7 +1219,7 @@ fn aaos_pos_mult() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["some", "other", "value"]
+        ["some", "other", "value"]
     );
 }
 
@@ -1240,7 +1240,7 @@ fn aaos_option_use_delim_false() {
             .unwrap()
             .map(|v| v.as_str())
             .collect::<Vec<_>>(),
-        &["one,two"]
+        ["one,two"]
     );
 }
 

tests/builder/arg_aliases.rs

@@ -99,15 +99,15 @@ fn get_aliases() {
     assert!(a.get_short_and_visible_aliases().is_none());
     assert_eq!(
         a.get_long_and_visible_aliases().unwrap(),
-        &["aliases", "alias4", "alias5", "alias6"]
+        ["aliases", "alias4", "alias5", "alias6"]
     );
     assert_eq!(
         a.get_visible_aliases().unwrap(),
-        &["alias4", "alias5", "alias6"]
+        ["alias4", "alias5", "alias6"]
     );
     assert_eq!(
         a.get_all_aliases().unwrap(),
-        &["alias1", "alias2", "alias3", "alias4", "alias5", "alias6"]
+        ["alias1", "alias2", "alias3", "alias4", "alias5", "alias6"]
     );
     assert_eq!(a.get_visible_short_aliases().unwrap(), vec!['d', 'e', 'f']);
     assert_eq!(

tests/builder/arg_matches.rs

@@ -51,7 +51,7 @@ fn ids_ignore_overridden() {
 fn arg_matches_if_present_wrong_arg() {
     let m = Command::new("test")
         .arg(Arg::new("flag").short('f').action(ArgAction::SetTrue))
-        .try_get_matches_from(&["test", "-f"])
+        .try_get_matches_from(["test", "-f"])
         .unwrap();
 
     assert!(*m.get_one::<bool>("flag").expect("defaulted by clap"));
@@ -64,7 +64,7 @@ fn arg_matches_if_present_wrong_arg() {
 fn arg_matches_value_of_wrong_arg() {
     let m = Command::new("test")
         .arg(Arg::new("opt").short('o').action(ArgAction::Set))
-        .try_get_matches_from(&["test", "-o", "val"])
+        .try_get_matches_from(["test", "-o", "val"])
         .unwrap();
 
     assert_eq!(m.get_one::<String>("opt").map(|v| v.as_str()), Some("val"));
@@ -77,7 +77,7 @@ fn arg_matches_value_of_wrong_arg() {
 fn arg_matches_subcommand_matches_wrong_sub() {
     let m = Command::new("test")
         .subcommand(Command::new("speed"))
-        .try_get_matches_from(&["test", "speed"])
+        .try_get_matches_from(["test", "speed"])
         .unwrap();
 
     assert!(m.subcommand_matches("speed").is_some());