clippy::uninlined_format_args: Apply clippy suggestions

`cargo clippy` now suggests that one uses lined arguments for `format!`
and friends, when possible:

https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args

> Added in: 1.66.0`

`CONTRIBUTING.md` suggests one runs this, before publishing a change:
```bash
cargo clippy --all --all-targets --all-features -- -D warnings`
```
But, at the moment, this command generated more than a thousand warnings
for me on `master`.

This change is just `cargo clippy --fix`, with flags to only show
`clippy::uninlined_format_args`, followed by `cargo fmt`.

Author: ilya-bobyr

build.rs

@@ -15,9 +15,9 @@ fn main() {
     println!("cargo:rerun-if-env-changed=RUSTUP_OVERRIDE_BUILD_TRIPLE");
     println!("cargo:rerun-if-env-changed=TARGET");
     match from_build() {
-        Ok(triple) => eprintln!("Computed build based partial target triple: {:#?}", triple),
+        Ok(triple) => eprintln!("Computed build based partial target triple: {triple:#?}"),
         Err(s) => {
-            eprintln!("Unable to parse target '{}' as a PartialTargetTriple", s);
+            eprintln!("Unable to parse target '{s}' as a PartialTargetTriple");
             eprintln!(
                 "If you are attempting to bootstrap a new target you may need to adjust the\n\
                permitted values found in src/dist/triple.rs"
@@ -26,5 +26,5 @@ fn main() {
         }
     }
     let target = env::var("TARGET").unwrap();
-    println!("cargo:rustc-env=TARGET={}", target);
+    println!("cargo:rustc-env=TARGET={target}");
 }

download/src/lib.rs

@@ -374,7 +374,7 @@ pub mod reqwest_be {
         let mut req = client.get(url.as_str());
 
         if resume_from != 0 {
-            req = req.header(header::RANGE, format!("bytes={}-", resume_from));
+            req = req.header(header::RANGE, format!("bytes={resume_from}-"));
         }
 
         Ok(req.send()?)
@@ -391,7 +391,7 @@ pub mod reqwest_be {
         if url.scheme() == "file" {
             let src = url
                 .to_file_path()
-                .map_err(|_| DownloadError::Message(format!("bogus file url: '{}'", url)))?;
+                .map_err(|_| DownloadError::Message(format!("bogus file url: '{url}'")))?;
             if !src.is_file() {
                 // Because some of rustup's logic depends on checking
                 // the error when a downloaded file doesn't exist, make

download/tests/download-curl-resume.rs

@@ -34,7 +34,7 @@ fn callback_gets_all_data_as_if_the_download_happened_all_at_once() {
 
     let addr = serve_file(b"xxx45".to_vec());
 
-    let from_url = format!("http://{}", addr).parse().unwrap();
+    let from_url = format!("http://{addr}").parse().unwrap();
 
     let callback_partial = AtomicBool::new(false);
     let callback_len = Mutex::new(None);

download/tests/download-reqwest-resume.rs

@@ -40,7 +40,7 @@ fn callback_gets_all_data_as_if_the_download_happened_all_at_once() {
 
     let addr = serve_file(b"xxx45".to_vec());
 
-    let from_url = format!("http://{}", addr).parse().unwrap();
+    let from_url = format!("http://{addr}").parse().unwrap();
 
     let callback_partial = AtomicBool::new(false);
     let callback_len = Mutex::new(None);

download/tests/support/mod.rs

@@ -50,7 +50,7 @@ async fn run_server(addr_tx: Sender<SocketAddr>, addr: SocketAddr, contents: Vec
     addr_tx.send(addr).unwrap();
 
     if let Err(e) = server.await {
-        eprintln!("server error: {}", e);
+        eprintln!("server error: {e}");
     }
 }
 

src/cli/common.rs

@@ -24,7 +24,7 @@ use crate::{Cfg, Notification, Toolchain, UpdateStatus};
 pub(crate) const WARN_COMPLETE_PROFILE: &str = "downloading with complete profile isn't recommended unless you are a developer of the rust language";
 
 pub(crate) fn confirm(question: &str, default: bool) -> Result<bool> {
-    write!(process().stdout(), "{} ", question)?;
+    write!(process().stdout(), "{question} ")?;
     let _ = std::io::stdout().flush();
     let input = read_line()?;
 
@@ -68,7 +68,7 @@ pub(crate) fn confirm_advanced() -> Result<Confirm> {
 }
 
 pub(crate) fn question_str(question: &str, default: &str) -> Result<String> {
-    writeln!(process().stdout(), "{} [{}]", question, default)?;
+    writeln!(process().stdout(), "{question} [{default}]")?;
     let _ = std::io::stdout().flush();
     let input = read_line()?;
 
@@ -83,7 +83,7 @@ pub(crate) fn question_str(question: &str, default: &str) -> Result<String> {
 
 pub(crate) fn question_bool(question: &str, default: bool) -> Result<bool> {
     let default_text = if default { "(Y/n)" } else { "(y/N)" };
-    writeln!(process().stdout(), "{} {}", question, default_text)?;
+    writeln!(process().stdout(), "{question} {default_text}")?;
 
     let _ = std::io::stdout().flush();
     let input = read_line()?;
@@ -132,7 +132,7 @@ impl NotifyOnConsole {
             }
         };
         let level = n.level();
-        for n in format!("{}", n).lines() {
+        for n in format!("{n}").lines() {
             match level {
                 NotificationLevel::Verbose => {
                     if self.verbose {
@@ -234,17 +234,17 @@ fn show_channel_updates(cfg: &Cfg, toolchains: Vec<(String, Result<UpdateStatus>
     for (name, banner, width, color, version, previous_version) in data {
         let padding = max_width - width;
         let padding: String = " ".repeat(padding);
-        let _ = write!(t, "  {}", padding);
+        let _ = write!(t, "  {padding}");
         let _ = t.attr(term2::Attr::Bold);
         if let Some(color) = color {
             let _ = t.fg(color);
         }
-        let _ = write!(t, "{} ", name);
-        let _ = write!(t, "{}", banner);
+        let _ = write!(t, "{name} ");
+        let _ = write!(t, "{banner}");
         let _ = t.reset();
-        let _ = write!(t, " - {}", version);
+        let _ = write!(t, " - {version}");
         if let Some(previous_version) = previous_version {
-            let _ = write!(t, " (from {})", previous_version);
+            let _ = write!(t, " (from {previous_version})");
         }
         let _ = writeln!(t);
     }
@@ -354,10 +354,10 @@ pub(crate) fn list_targets(toolchain: &Toolchain<'_>) -> Result<utils::ExitCode>
                 .expect("rust-std should have a target");
             if component.installed {
                 let _ = t.attr(term2::Attr::Bold);
-                let _ = writeln!(t, "{} (installed)", target);
+                let _ = writeln!(t, "{target} (installed)");
                 let _ = t.reset();
             } else if component.available {
-                let _ = writeln!(t, "{}", target);
+                let _ = writeln!(t, "{target}");
             }
         }
     }
@@ -377,7 +377,7 @@ pub(crate) fn list_installed_targets(toolchain: &Toolchain<'_>) -> Result<utils:
                 .as_ref()
                 .expect("rust-std should have a target");
             if component.installed {
-                writeln!(t, "{}", target)?;
+                writeln!(t, "{target}")?;
             }
         }
     }
@@ -392,10 +392,10 @@ pub(crate) fn list_components(toolchain: &Toolchain<'_>) -> Result<utils::ExitCo
         let name = component.name;
         if component.installed {
             t.attr(term2::Attr::Bold)?;
-            writeln!(t, "{} (installed)", name)?;
+            writeln!(t, "{name} (installed)")?;
             t.reset()?;
         } else if component.available {
-            writeln!(t, "{}", name)?;
+            writeln!(t, "{name}")?;
         }
     }
 

src/cli/download_tracker.rs

@@ -211,7 +211,7 @@ impl DownloadTracker {
                     ),
                 };
 
-                let _ = write!(self.term, "{}", output);
+                let _ = write!(self.term, "{output}");
                 // Since stdout is typically line-buffered and we don't print a newline, we manually flush.
                 let _ = self.term.flush();
                 self.displayed_charcount = Some(output.chars().count());
@@ -250,10 +250,10 @@ impl fmt::Display for Display {
             return f.write_str("Unknown");
         }
         match format_dhms(secs) {
-            (0, 0, 0, s) => write!(f, "{:2.0}s", s),
-            (0, 0, m, s) => write!(f, "{:2.0}m {:2.0}s", m, s),
-            (0, h, m, s) => write!(f, "{:2.0}h {:2.0}m {:2.0}s", h, m, s),
-            (d, h, m, s) => write!(f, "{:3.0}d {:2.0}h {:2.0}m {:2.0}s", d, h, m, s),
+            (0, 0, 0, s) => write!(f, "{s:2.0}s"),
+            (0, 0, m, s) => write!(f, "{m:2.0}m {s:2.0}s"),
+            (0, h, m, s) => write!(f, "{h:2.0}h {m:2.0}m {s:2.0}s"),
+            (d, h, m, s) => write!(f, "{d:3.0}d {h:2.0}h {m:2.0}m {s:2.0}s"),
         }
     }
 }

src/cli/errors.rs

@@ -29,10 +29,7 @@ fn maybe_suggest_toolchain(bad_name: &str) -> String {
     }
 
     if NUMBERED.is_match(bad_name) {
-        return format!(
-            ". Toolchain numbers tend to have three parts, e.g. {}.0",
-            bad_name
-        );
+        return format!(". Toolchain numbers tend to have three parts, e.g. {bad_name}.0");
     }
 
     // Suggest only for very small differences

src/cli/markdown.rs

@@ -48,7 +48,7 @@ impl<'a, T: Terminal + 'a> LineWrapper<'a, T> {
         }
 
         // Write the word
-        let _ = write!(self.w, "{}", word);
+        let _ = write!(self.w, "{word}");
         self.pos += word_len;
     }
     fn write_space(&mut self) {

src/cli/rustup_mode.rs

@@ -55,8 +55,7 @@ where
         "Eventually this command will be a true alias.  Until then:",
     ));
     (cfg.notify_handler)(Notification::PlainVerboseMessage(&format!(
-        "  Please use `rustup {}` instead",
-        instead
+        "  Please use `rustup {instead}` instead"
     )));
     callee(cfg, matches)
 }
@@ -72,15 +71,15 @@ pub fn main() -> Result<utils::ExitCode> {
             message,
             ..
         }) => {
-            writeln!(process().stdout().lock(), "{}", message)?;
+            writeln!(process().stdout().lock(), "{message}")?;
             return Ok(utils::ExitCode(0));
         }
         Err(clap::Error {
             kind: VersionDisplayed,
             message,
             ..
         }) => {
-            writeln!(process().stdout().lock(), "{}", message)?;
+            writeln!(process().stdout().lock(), "{message}")?;
             info!("This is the version for the rustup toolchain manager, not the rustc compiler.");
 
             fn rustc_version() -> std::result::Result<String, Box<dyn std::error::Error>> {
@@ -114,7 +113,7 @@ pub fn main() -> Result<utils::ExitCode> {
                 ]
                 .contains(kind)
                 {
-                    writeln!(process().stdout().lock(), "{}", message)?;
+                    writeln!(process().stdout().lock(), "{message}")?;
                     return Ok(utils::ExitCode(1));
                 }
             }
@@ -815,7 +814,7 @@ fn update_bare_triple_check(cfg: &Cfg, name: &str) -> Result<()> {
                     "\nyou may use one of the following toolchains:"
                 )?;
                 for n in &candidates {
-                    writeln!(process().stdout(), "{}", n)?;
+                    writeln!(process().stdout(), "{n}")?;
                 }
                 writeln!(process().stdout(),)?;
             }
@@ -832,7 +831,7 @@ fn default_bare_triple_check(cfg: &Cfg, name: &str) -> Result<()> {
         let default_name = default.map(|t| t.name().to_string()).unwrap_or_default();
         if let Ok(mut desc) = PartialToolchainDesc::from_str(&default_name) {
             desc.target = triple;
-            let maybe_toolchain = format!("{}", desc);
+            let maybe_toolchain = format!("{desc}");
             let toolchain = cfg.get_toolchain(maybe_toolchain.as_ref(), false)?;
             if toolchain.name() == default_name {
                 warn!(
@@ -903,7 +902,7 @@ fn check_updates(cfg: &Cfg) -> Result<utils::ExitCode> {
                 let current_version = distributable.show_version()?;
                 let dist_version = distributable.show_dist_version()?;
                 let _ = t.attr(term2::Attr::Bold);
-                write!(t, "{} - ", name)?;
+                write!(t, "{name} - ")?;
                 match (current_version, dist_version) {
                     (None, None) => {
                         let _ = t.fg(term2::color::RED);
@@ -913,19 +912,19 @@ fn check_updates(cfg: &Cfg) -> Result<utils::ExitCode> {
                         let _ = t.fg(term2::color::GREEN);
                         write!(t, "Up to date")?;
                         let _ = t.reset();
-                        writeln!(t, " : {}", cv)?;
+                        writeln!(t, " : {cv}")?;
                     }
                     (Some(cv), Some(dv)) => {
                         let _ = t.fg(term2::color::YELLOW);
                         write!(t, "Update available")?;
                         let _ = t.reset();
-                        writeln!(t, " : {} -> {}", cv, dv)?;
+                        writeln!(t, " : {cv} -> {dv}")?;
                     }
                     (None, Some(dv)) => {
                         let _ = t.fg(term2::color::YELLOW);
                         write!(t, "Update available")?;
                         let _ = t.reset();
-                        writeln!(t, " : (Unknown version) -> {}", dv)?;
+                        writeln!(t, " : (Unknown version) -> {dv}")?;
                     }
                 }
             }
@@ -1141,9 +1140,9 @@ fn show(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<utils::ExitCode> {
         let default_name = default_name?;
         for it in installed_toolchains {
             if default_name == it {
-                writeln!(t, "{} (default)", it)?;
+                writeln!(t, "{it} (default)")?;
             } else {
-                writeln!(t, "{}", it)?;
+                writeln!(t, "{it}")?;
             }
             if verbose {
                 if let Ok(toolchain) = cfg.get_toolchain(&it, false) {
@@ -1203,9 +1202,9 @@ fn show(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<utils::ExitCode> {
                 {
                     writeln!(t, "no active toolchain")?;
                 } else if let Some(cause) = err.source() {
-                    writeln!(t, "(error: {}, {})", err, cause)?;
+                    writeln!(t, "(error: {err}, {cause})")?;
                 } else {
-                    writeln!(t, "(error: {})", err)?;
+                    writeln!(t, "(error: {err})")?;
                 }
             }
         }
@@ -1220,7 +1219,7 @@ fn show(cfg: &Cfg, m: &ArgMatches<'_>) -> Result<utils::ExitCode> {
         E: From<term::Error> + From<std::io::Error>,
     {
         t.attr(term2::Attr::Bold)?;
-        writeln!(t, "{}", s)?;
+        writeln!(t, "{s}")?;
         writeln!(t, "{}", "-".repeat(s.len()))?;
         writeln!(t)?;
         t.reset()?;
@@ -1665,7 +1664,7 @@ impl FromStr for CompletionCommand {
                 let completion_options = COMPLETIONS
                     .iter()
                     .map(|&(v, _)| v)
-                    .fold("".to_owned(), |s, v| format!("{}{}, ", s, v));
+                    .fold("".to_owned(), |s, v| format!("{s}{v}, "));
                 Err(format!(
                     "[valid values: {}]",
                     completion_options.trim_end_matches(", ")
@@ -1678,7 +1677,7 @@ impl FromStr for CompletionCommand {
 impl fmt::Display for CompletionCommand {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match COMPLETIONS.iter().find(|&(_, cmd)| cmd == self) {
-            Some(&(val, _)) => write!(f, "{}", val),
+            Some(&(val, _)) => write!(f, "{val}"),
             None => unreachable!(),
         }
     }
@@ -1709,9 +1708,8 @@ fn output_completion_script(shell: Shell, command: CompletionCommand) -> Result<
             writeln!(
                 term2::stdout(),
                 "if command -v rustc >/dev/null 2>&1; then\n\
-                    \tsource \"$(rustc --print sysroot)\"{}\n\
+                    \tsource \"$(rustc --print sysroot)\"{script}\n\
                  fi",
-                script,
             )?;
         }
     }