Merge pull request clap-rs#4684 from martinfrances107/clippy

clap-rs#4683 Clippy: make format!() calls more readable.

clap_complete/examples/completion-derive.rs

@@ -75,9 +75,9 @@ fn main() {
 
     if let Some(generator) = opt.generator {
         let mut cmd = Opt::command();
-        eprintln!("Generating completion file for {:?}...", generator);
+        eprintln!("Generating completion file for {generator:?}...");
         print_completions(generator, &mut cmd);
     } else {
-        println!("{:#?}", opt);
+        println!("{opt:#?}");
     }
 }

clap_complete/examples/completion.rs

@@ -103,7 +103,7 @@ fn main() {
 
     if let Some(generator) = matches.get_one::<Shell>("generator") {
         let mut cmd = build_cli();
-        eprintln!("Generating completion file for {}...", generator);
+        eprintln!("Generating completion file for {generator}...");
         print_completions(*generator, &mut cmd);
     }
 }

clap_complete/src/shells/bash.rs

@@ -10,7 +10,7 @@ pub struct Bash;
 
 impl Generator for Bash {
     fn file_name(&self, name: &str) -> String {
-        format!("{}.bash", name)
+        format!("{name}.bash")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn Write) {
@@ -114,9 +114,6 @@ fn all_subcommands(cmd: &Command) -> String {
             "{parent_fn_name},{name})
                 cmd=\"{fn_name}\"
                 ;;",
-            parent_fn_name = parent_fn_name,
-            name = name,
-            fn_name = fn_name,
         ));
     }
 
@@ -221,22 +218,22 @@ fn all_options_for_path(cmd: &Command, path: &str) -> String {
 
     let mut opts = String::new();
     for short in utils::shorts_and_visible_aliases(p) {
-        write!(&mut opts, "-{} ", short).unwrap();
+        write!(&mut opts, "-{short} ").unwrap();
     }
     for long in utils::longs_and_visible_aliases(p) {
-        write!(&mut opts, "--{} ", long).unwrap();
+        write!(&mut opts, "--{long} ").unwrap();
     }
     for pos in p.get_positionals() {
         if let Some(vals) = utils::possible_values(pos) {
             for value in vals {
                 write!(&mut opts, "{} ", value.get_name()).unwrap();
             }
         } else {
-            write!(&mut opts, "{} ", pos).unwrap();
+            write!(&mut opts, "{pos} ").unwrap();
         }
     }
     for (sc, _) in utils::subcommands(p) {
-        write!(&mut opts, "{} ", sc).unwrap();
+        write!(&mut opts, "{sc} ").unwrap();
     }
     opts.pop();
 

clap_complete/src/shells/elvish.rs

@@ -12,7 +12,7 @@ pub struct Elvish;
 
 impl Generator for Elvish {
     fn file_name(&self, name: &str) -> String {
-        format!("{}.elv", name)
+        format!("{name}.elv")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn Write) {
@@ -46,8 +46,6 @@ set edit:completion:arg-completer[{bin_name}] = {{|@words|
     $completions[$command]
 }}
 "#,
-            bin_name = bin_name,
-            subcommands_cases = subcommands_cases
         );
 
         w!(buf, result.as_bytes());
@@ -83,15 +81,15 @@ fn generate_inner(p: &Command, previous_command_name: &str) -> String {
             let tooltip = get_tooltip(option.get_help(), shorts[0]);
             for short in shorts {
                 completions.push_str(&preamble);
-                completions.push_str(format!("-{} '{}'", short, tooltip).as_str());
+                completions.push_str(format!("-{short} '{tooltip}'").as_str());
             }
         }
 
         if let Some(longs) = option.get_long_and_visible_aliases() {
             let tooltip = get_tooltip(option.get_help(), longs[0]);
             for long in longs {
                 completions.push_str(&preamble);
-                completions.push_str(format!("--{} '{}'", long, tooltip).as_str());
+                completions.push_str(format!("--{long} '{tooltip}'").as_str());
             }
         }
     }
@@ -101,15 +99,15 @@ fn generate_inner(p: &Command, previous_command_name: &str) -> String {
             let tooltip = get_tooltip(flag.get_help(), shorts[0]);
             for short in shorts {
                 completions.push_str(&preamble);
-                completions.push_str(format!("-{} '{}'", short, tooltip).as_str());
+                completions.push_str(format!("-{short} '{tooltip}'").as_str());
             }
         }
 
         if let Some(longs) = flag.get_long_and_visible_aliases() {
             let tooltip = get_tooltip(flag.get_help(), longs[0]);
             for long in longs {
                 completions.push_str(&preamble);
-                completions.push_str(format!("--{} '{}'", long, tooltip).as_str());
+                completions.push_str(format!("--{long} '{tooltip}'").as_str());
             }
         }
     }
@@ -119,7 +117,7 @@ fn generate_inner(p: &Command, previous_command_name: &str) -> String {
         let tooltip = get_tooltip(subcommand.get_about(), data);
 
         completions.push_str(&preamble);
-        completions.push_str(format!("{} '{}'", data, tooltip).as_str());
+        completions.push_str(format!("{data} '{tooltip}'").as_str());
     }
 
     let mut subcommands_cases = format!(

clap_complete/src/shells/fish.rs

@@ -12,7 +12,7 @@ pub struct Fish;
 
 impl Generator for Fish {
     fn file_name(&self, name: &str) -> String {
-        format!("{}.fish", name)
+        format!("{name}.fish")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn Write) {
@@ -56,7 +56,7 @@ fn gen_fish_inner(
     //      -n "__fish_use_subcommand"               # complete for command "myprog"
     //      -n "__fish_seen_subcommand_from subcmd1" # complete for command "myprog subcmd1"
 
-    let mut basic_template = format!("complete -c {}", root_command);
+    let mut basic_template = format!("complete -c {root_command}");
 
     if parent_commands.is_empty() {
         if cmd.has_subcommands() {
@@ -68,10 +68,10 @@ fn gen_fish_inner(
                 " -n \"{}\"",
                 parent_commands
                     .iter()
-                    .map(|command| format!("__fish_seen_subcommand_from {}", command))
+                    .map(|command| format!("__fish_seen_subcommand_from {command}"))
                     .chain(
                         cmd.get_subcommands()
-                            .map(|command| format!("not __fish_seen_subcommand_from {}", command))
+                            .map(|command| format!("not __fish_seen_subcommand_from {command}"))
                     )
                     .collect::<Vec<_>>()
                     .join("; and ")
@@ -87,7 +87,7 @@ fn gen_fish_inner(
 
         if let Some(shorts) = option.get_short_and_visible_aliases() {
             for short in shorts {
-                template.push_str(format!(" -s {}", short).as_str());
+                template.push_str(format!(" -s {short}").as_str());
             }
         }
 
@@ -113,7 +113,7 @@ fn gen_fish_inner(
 
         if let Some(shorts) = flag.get_short_and_visible_aliases() {
             for short in shorts {
-                template.push_str(format!(" -s {}", short).as_str());
+                template.push_str(format!(" -s {short}").as_str());
             }
         }
 

clap_complete/src/shells/powershell.rs

@@ -12,7 +12,7 @@ pub struct PowerShell;
 
 impl Generator for PowerShell {
     fn file_name(&self, name: &str) -> String {
-        format!("_{}.ps1", name)
+        format!("_{name}.ps1")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn Write) {

clap_complete/src/shells/shell.rs

@@ -42,7 +42,7 @@ impl FromStr for Shell {
                 return Ok(*variant);
             }
         }
-        Err(format!("invalid variant: {}", s))
+        Err(format!("invalid variant: {s}"))
     }
 }
 

clap_complete/src/shells/zsh.rs

@@ -11,7 +11,7 @@ pub struct Zsh;
 
 impl Generator for Zsh {
     fn file_name(&self, name: &str) -> String {
-        format!("_{}", name)
+        format!("_{name}")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn Write) {
@@ -111,8 +111,8 @@ _{bin_name_underscore}_commands() {{
     all_subcommands.sort();
     all_subcommands.dedup();
 
-    for &(_, ref bin_name) in &all_subcommands {
-        debug!("subcommand_details:iter: bin_name={}", bin_name);
+    for (_, ref bin_name) in &all_subcommands {
+        debug!("subcommand_details:iter: bin_name={bin_name}");
 
         ret.push(format!(
             "\
@@ -223,14 +223,12 @@ fn get_subcommands_of(parent: &Command) -> String {
     let subcommand_names = utils::subcommands(parent);
     let mut all_subcommands = vec![];
 
-    for &(ref name, ref bin_name) in &subcommand_names {
+    for (ref name, ref bin_name) in &subcommand_names {
         debug!(
-            "get_subcommands_of:iter: parent={}, name={}, bin_name={}",
+            "get_subcommands_of:iter: parent={}, name={name}, bin_name={bin_name}",
             parent.get_name(),
-            name,
-            bin_name,
         );
-        let mut segments = vec![format!("({})", name)];
+        let mut segments = vec![format!("({name})")];
         let subcommand_args = get_args_of(
             parser_of(parent, bin_name).expect(INTERNAL_ERROR_MSG),
             Some(parent),
@@ -458,8 +456,8 @@ fn write_opts_of(p: &Command, p_global: Option<&Command>) -> String {
             Some(val) => val[0].to_string(),
         };
         let vc = match value_completion(o) {
-            Some(val) => format!(":{}:{}", vn, val),
-            None => format!(":{}: ", vn),
+            Some(val) => format!(":{vn}:{val}"),
+            None => format!(":{vn}: "),
         };
         let vc = vc.repeat(o.get_num_args().expect("built").min_values());
 
@@ -502,11 +500,11 @@ fn arg_conflicts(cmd: &Command, arg: &Arg, app_global: Option<&Command>) -> Stri
     fn push_conflicts(conflicts: &[&Arg], res: &mut Vec<String>) {
         for conflict in conflicts {
             if let Some(s) = conflict.get_short() {
-                res.push(format!("-{}", s));
+                res.push(format!("-{s}"));
             }
 
             if let Some(l) = conflict.get_long() {
-                res.push(format!("--{}", l));
+                res.push(format!("--{l}"));
             }
         }
     }
@@ -568,13 +566,7 @@ fn write_flags_of(p: &Command, p_global: Option<&Command>) -> String {
 
             if let Some(short_aliases) = f.get_visible_short_aliases() {
                 for alias in short_aliases {
-                    let s = format!(
-                        "'{conflicts}{multiple}-{arg}[{help}]' \\",
-                        multiple = multiple,
-                        conflicts = conflicts,
-                        arg = alias,
-                        help = help
-                    );
+                    let s = format!("'{conflicts}{multiple}-{alias}[{help}]' \\",);
 
                     debug!("write_flags_of:iter: Wrote...{}", &*s);
 

clap_complete_fig/src/fig.rs

@@ -11,7 +11,7 @@ pub struct Fig;
 
 impl Generator for Fig {
     fn file_name(&self, name: &str) -> String {
-        format!("{}.ts", name)
+        format!("{name}.ts")
     }
 
     fn generate(&self, cmd: &Command, buf: &mut dyn std::io::Write) {
@@ -267,11 +267,11 @@ fn gen_options(cmd: &Command, indent: usize) -> String {
             let mut flags = vec![];
 
             if let Some(shorts) = flag.get_short_and_visible_aliases() {
-                flags.extend(shorts.iter().map(|s| format!("-{}", s)));
+                flags.extend(shorts.iter().map(|s| format!("-{s}")));
             }
 
             if let Some(longs) = flag.get_long_and_visible_aliases() {
-                flags.extend(longs.iter().map(|s| format!("--{}", s)));
+                flags.extend(longs.iter().map(|s| format!("--{s}")));
             }
 
             if flags.len() > 1 {

clap_mangen/src/render.rs

@@ -36,19 +36,19 @@ pub(crate) fn synopsis(roff: &mut Roff, cmd: &clap::Command) {
         match (opt.get_short(), opt.get_long()) {
             (Some(short), Some(long)) => {
                 line.push(roman(lhs));
-                line.push(bold(format!("-{}", short)));
+                line.push(bold(format!("-{short}")));
                 line.push(roman("|"));
-                line.push(bold(format!("--{}", long)));
+                line.push(bold(format!("--{long}",)));
                 line.push(roman(rhs));
             }
             (Some(short), None) => {
                 line.push(roman(lhs));
-                line.push(bold(format!("-{} ", short)));
+                line.push(bold(format!("-{short} ")));
                 line.push(roman(rhs));
             }
             (None, Some(long)) => {
                 line.push(roman(lhs));
-                line.push(bold(format!("--{}", long)));
+                line.push(bold(format!("--{long}")));
                 line.push(roman(rhs));
             }
             (None, None) => continue,
@@ -168,7 +168,7 @@ pub(crate) fn options(roff: &mut Roff, cmd: &clap::Command) {
         header.push(roman(rhs));
 
         if let Some(defs) = option_default_values(pos) {
-            header.push(roman(format!(" {}", defs)));
+            header.push(roman(format!(" {defs}")));
         }
 
         let mut body = vec![];
@@ -273,11 +273,11 @@ fn markers(required: bool) -> (&'static str, &'static str) {
 }
 
 fn short_option(opt: char) -> Inline {
-    bold(format!("-{}", opt))
+    bold(format!("-{opt}"))
 }
 
 fn long_option(opt: &str) -> Inline {
-    bold(format!("--{}", opt))
+    bold(format!("--{opt}"))
 }
 
 fn option_help(opt: &clap::Arg) -> Option<&clap::builder::StyledStr> {
@@ -319,7 +319,7 @@ fn option_default_values(opt: &clap::Arg) -> Option<String> {
             .collect::<Vec<_>>()
             .join(",");
 
-        return Some(format!("[default: {}]", values));
+        return Some(format!("[default: {values}]"));
     }
 
     None
@@ -343,7 +343,7 @@ fn format_possible_values(possibles: &Vec<&clap::builder::PossibleValue>) -> (Ve
         for value in possibles {
             let val_name = value.get_name();
             match value.get_help() {
-                Some(help) => lines.push(format!("{}: {}", val_name, help)),
+                Some(help) => lines.push(format!("{val_name}: {help}")),
                 None => lines.push(val_name.to_string()),
             }
         }

examples/derive_ref/augment_args.rs

@@ -23,5 +23,5 @@ fn main() {
     let derived_matches = DerivedArgs::from_arg_matches(&matches)
         .map_err(|err| err.exit())
         .unwrap();
-    println!("Value of derived: {:#?}", derived_matches);
+    println!("Value of derived: {derived_matches:#?}");
 }

examples/derive_ref/augment_subcommands.rs

@@ -17,5 +17,5 @@ fn main() {
     let derived_subcommands = Subcommands::from_arg_matches(&matches)
         .map_err(|err| err.exit())
         .unwrap();
-    println!("Derived subcommands: {:#?}", derived_subcommands);
+    println!("Derived subcommands: {derived_subcommands:#?}");
 }

examples/derive_ref/flatten_hand_args.rs

@@ -87,5 +87,5 @@ struct Cli {
 
 fn main() {
     let args = Cli::parse();
-    println!("{:#?}", args);
+    println!("{args:#?}");
 }

examples/derive_ref/hand_subcommand.rs

@@ -75,5 +75,5 @@ struct Cli {
 
 fn main() {
     let args = Cli::parse();
-    println!("{:#?}", args);
+    println!("{args:#?}");
 }