Improve code

5 files changed, 147 insertions, 115 deletions

diff --git a/build_system/src/build.rs b/build_system/src/build.rs
index 58c36412ea5..e2819c37ad9 100644
--- a/build_system/src/build.rs
+++ b/build_system/src/build.rs
@@ -1,5 +1,7 @@
 use crate::config::set_config;
-use crate::utils::{get_gcc_path, run_command_with_env, run_command_with_output, walk_dir};
+use crate::utils::{
+    get_gcc_path, run_command, run_command_with_env, run_command_with_output_and_env, walk_dir,
+};
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fs;
@@ -9,7 +11,6 @@ use std::path::Path;
 struct BuildArg {
     codegen_release_channel: bool,
     sysroot_release_channel: bool,
-    no_default_features: bool,
     features: Vec<String>,
     gcc_path: String,
 }
@@ -21,27 +22,31 @@ impl BuildArg {
             gcc_path,
             ..Default::default()
         };
+        // We skip binary name and the `build` command.
         let mut args = std::env::args().skip(2);
 
         while let Some(arg) = args.next() {
             match arg.as_str() {
                 "--release" => build_arg.codegen_release_channel = true,
                 "--release-sysroot" => build_arg.sysroot_release_channel = true,
-                "--no-default-features" => build_arg.no_default_features = true,
+                "--no-default-features" => {
+                    build_arg.features.push("--no-default-features".to_string());
+                }
                 "--features" => {
                     if let Some(arg) = args.next() {
+                        build_arg.features.push("--features".to_string());
                         build_arg.features.push(arg.as_str().into());
                     } else {
-                        return Err(format!(
-                            "Expected a value after `--features`, found nothing"
-                        ));
+                        return Err(
+                            "Expected a value after `--features`, found nothing".to_string()
+                        );
                     }
                 }
                 "--help" => {
                     Self::usage();
                     return Ok(None);
                 }
-                a => return Err(format!("Unknown argument `{a}`")),
+                arg => return Err(format!("Unknown argument `{}`", arg)),
             }
         }
         Ok(Some(build_arg))
@@ -68,37 +73,37 @@ fn build_sysroot(
     target_triple: &str,
 ) -> Result<(), String> {
     std::env::set_current_dir("build_sysroot")
-        .map_err(|e| format!("Failed to go to `build_sysroot` directory: {e:?}"))?;
+        .map_err(|error| format!("Failed to go to `build_sysroot` directory: {:?}", error))?;
     // Cleanup for previous run
-    //     v Clean target dir except for build scripts and incremental cache
-   let _e = walk_dir(
+    // Clean target dir except for build scripts and incremental cache
+    let _ = walk_dir(
         "target",
         |dir: &Path| {
             for top in &["debug", "release"] {
-                let _e = fs::remove_dir_all(dir.join(top).join("build"));
-                let _e = fs::remove_dir_all(dir.join(top).join("deps"));
-                let _e = fs::remove_dir_all(dir.join(top).join("examples"));
-                let _e = fs::remove_dir_all(dir.join(top).join("native"));
+                let _ = fs::remove_dir_all(dir.join(top).join("build"));
+                let _ = fs::remove_dir_all(dir.join(top).join("deps"));
+                let _ = fs::remove_dir_all(dir.join(top).join("examples"));
+                let _ = fs::remove_dir_all(dir.join(top).join("native"));
 
-                let _e = walk_dir(
+                let _ = walk_dir(
                     dir.join(top),
                     |sub_dir: &Path| {
                         if sub_dir
                             .file_name()
-                            .map(|s| s.to_str().unwrap().starts_with("libsysroot"))
+                            .map(|filename| filename.to_str().unwrap().starts_with("libsysroot"))
                             .unwrap_or(false)
                         {
-                            let _e = fs::remove_dir_all(sub_dir);
+                            let _ = fs::remove_dir_all(sub_dir);
                         }
                         Ok(())
                     },
                     |file: &Path| {
                         if file
                             .file_name()
-                            .map(|s| s.to_str().unwrap().starts_with("libsysroot"))
+                            .map(|filename| filename.to_str().unwrap().starts_with("libsysroot"))
                             .unwrap_or(false)
                         {
-                            let _e = fs::remove_file(file);
+                            let _ = fs::remove_file(file);
                         }
                         Ok(())
                     },
@@ -109,21 +114,21 @@ fn build_sysroot(
         |_| Ok(()),
     );
 
-    let _e = fs::remove_file("Cargo.lock");
-    let _e = fs::remove_file("test_target/Cargo.lock");
-    let _e = fs::remove_dir_all("sysroot");
+    let _ = fs::remove_file("Cargo.lock");
+    let _ = fs::remove_file("test_target/Cargo.lock");
+    let _ = fs::remove_dir_all("sysroot");
 
     // Builds libs
     let channel = if release_mode {
         let rustflags = env
-            .get(&"RUSTFLAGS".to_owned())
+            .get("RUSTFLAGS")
             .cloned()
             .unwrap_or_default();
         env.insert(
-            "RUSTFLAGS".to_owned(),
-            format!("{rustflags} -Zmir-opt-level=3"),
+            "RUSTFLAGS".to_string(),
+            format!("{} -Zmir-opt-level=3", rustflags),
         );
-        run_command_with_output(
+        run_command_with_output_and_env(
             &[
                 &"cargo",
                 &"build",
@@ -136,7 +141,7 @@ fn build_sysroot(
         )?;
         "release"
     } else {
-        run_command_with_output(
+        run_command_with_output_and_env(
             &[
                 &"cargo",
                 &"build",
@@ -152,12 +157,14 @@ fn build_sysroot(
     };
 
     // Copy files to sysroot
-    let sysroot_path = format!("sysroot/lib/rustlib/{target_triple}/lib/");
+    let sysroot_path = format!("sysroot/lib/rustlib/{}/lib/", target_triple);
     fs::create_dir_all(&sysroot_path)
-        .map_err(|e| format!("Failed to create directory `{sysroot_path}`: {e:?}"))?;
-    let copier = |d: &Path| run_command_with_output(&[&"cp", &"-r", &d, &sysroot_path], None, None);
+        .map_err(|error| format!("Failed to create directory `{}`: {:?}", sysroot_path, error))?;
+    let copier = |dir_to_copy: &Path| {
+        run_command(&[&"cp", &"-r", &dir_to_copy, &sysroot_path], None).map(|_| ())
+    };
     walk_dir(
-        &format!("target/{target_triple}/{channel}/deps"),
+        &format!("target/{}/{}/deps", target_triple, channel),
         copier,
         copier,
     )?;
@@ -169,21 +176,25 @@ fn build_codegen(args: &BuildArg) -> Result<(), String> {
     let mut env = HashMap::new();
 
     let current_dir =
-        std::env::current_dir().map_err(|e| format!("`current_dir` failed: {e:?}"))?;
-    env.insert(
-        "RUST_COMPILER_RT_ROOT".to_owned(),
-        format!("{}", current_dir.join("llvm/compiler-rt").display()),
-    );
-    env.insert("LD_LIBRARY_PATH".to_owned(), args.gcc_path.clone());
-    env.insert("LIBRARY_PATH".to_owned(), args.gcc_path.clone());
+        std::env::current_dir().map_err(|error| format!("`current_dir` failed: {:?}", error))?;
+    if let Ok(rt_root) = std::env::var("RUST_COMPILER_RT_ROOT") {
+        env.insert("RUST_COMPILER_RT_ROOT".to_string(), rt_root);
+    } else {
+        env.insert(
+            "RUST_COMPILER_RT_ROOT".to_string(),
+            format!("{}", current_dir.join("llvm/compiler-rt").display()),
+        );
+    }
+    env.insert("LD_LIBRARY_PATH".to_string(), args.gcc_path.clone());
+    env.insert("LIBRARY_PATH".to_string(), args.gcc_path.clone());
 
     let mut command: Vec<&dyn AsRef<OsStr>> = vec![&"cargo", &"rustc"];
     if args.codegen_release_channel {
         command.push(&"--release");
-        env.insert("CHANNEL".to_owned(), "release".to_owned());
-        env.insert("CARGO_INCREMENTAL".to_owned(), "1".to_owned());
+        env.insert("CHANNEL".to_string(), "release".to_string());
+        env.insert("CARGO_INCREMENTAL".to_string(), "1".to_string());
     } else {
-        env.insert("CHANNEL".to_owned(), "debug".to_owned());
+        env.insert("CHANNEL".to_string(), "debug".to_string());
     }
     let ref_features = args.features.iter().map(|s| s.as_str()).collect::<Vec<_>>();
     for feature in &ref_features {
@@ -194,10 +205,14 @@ fn build_codegen(args: &BuildArg) -> Result<(), String> {
     let config = set_config(&mut env, &[], Some(&args.gcc_path))?;
 
     // We voluntarily ignore the error.
-    let _e = fs::remove_dir_all("target/out");
+    let _ = fs::remove_dir_all("target/out");
     let gccjit_target = "target/out/gccjit";
-    fs::create_dir_all(gccjit_target)
-        .map_err(|e| format!("Failed to create directory `{gccjit_target}`: {e:?}"))?;
+    fs::create_dir_all(gccjit_target).map_err(|error| {
+        format!(
+            "Failed to create directory `{}`: {:?}",
+            gccjit_target, error
+        )
+    })?;
 
     println!("[BUILD] sysroot");
     build_sysroot(
@@ -210,7 +225,7 @@ fn build_codegen(args: &BuildArg) -> Result<(), String> {
 
 pub fn run() -> Result<(), String> {
     let args = match BuildArg::new()? {
-        Some(a) => a,
+        Some(args) => args,
         None => return Ok(()),
     };
     build_codegen(&args)?;
diff --git a/build_system/src/config.rs b/build_system/src/config.rs
index 5160eb2ecae..4f2e33f0f99 100644
--- a/build_system/src/config.rs
+++ b/build_system/src/config.rs
@@ -14,19 +14,19 @@ pub fn set_config(
     test_flags: &[String],
     gcc_path: Option<&str>,
 ) -> Result<ConfigInfo, String> {
-    env.insert("CARGO_INCREMENTAL".to_owned(), "0".to_owned());
+    env.insert("CARGO_INCREMENTAL".to_string(), "0".to_string());
 
     let gcc_path = match gcc_path {
-        Some(g) => g.to_owned(),
+        Some(path) => path.to_string(),
         None => get_gcc_path()?,
     };
-    env.insert("GCC_PATH".to_owned(), gcc_path.clone());
+    env.insert("GCC_PATH".to_string(), gcc_path.clone());
 
     let os_name = get_os_name()?;
     let dylib_ext = match os_name.as_str() {
         "Linux" => "so",
         "Darwin" => "dylib",
-        os => return Err(format!("unsupported OS `{os}`")),
+        os => return Err(format!("unsupported OS `{}`", os)),
     };
     let host_triple = get_rustc_host_triple()?;
     let mut linker = None;
@@ -44,77 +44,81 @@ pub fn set_config(
             linker = Some("-Clinker=aarch64-linux-gnu-gcc");
             run_wrapper = Some("qemu-aarch64 -L /usr/aarch64-linux-gnu");
         } else {
-            return Err(format!("unknown non-native platform `{target_triple}`"));
+            return Err(format!("unknown non-native platform `{}`", target_triple));
         }
     }
-    // Since we don't support ThinLTO, disable LTO completely when not trying to do LTO.
-    // TODO(antoyo): remove when we can handle ThinLTO.
-    let disable_lto_lfags = "-Clto=off";
-    let current_dir = std_env::current_dir().map_err(|e| format!("`current_dir` failed: {e:?}"))?;
+    let current_dir =
+        std_env::current_dir().map_err(|error| format!("`current_dir` failed: {:?}", error))?;
+    let channel = if let Some(channel) = env.get("CHANNEL") {
+        channel.as_str()
+    } else {
+        "debug"
+    };
     let cg_backend_path = current_dir
         .join("target")
-        .join(if let Some(channel) = env.get(&"CHANNEL".to_owned()) {
-            channel.as_str()
-        } else {
-            "debug"
-        })
-        .join(&format!("librustc_codegen_gcc.{dylib_ext}"));
+        .join(channel)
+        .join(&format!("librustc_codegen_gcc.{}", dylib_ext));
     let sysroot_path = current_dir.join("build_sysroot/sysroot");
     let mut rustflags = Vec::new();
-    if let Some(cg_rustflags) = env.get(&"CG_RUSTFLAGS".to_owned()) {
+    if let Some(cg_rustflags) = env.get("CG_RUSTFLAGS") {
         rustflags.push(cg_rustflags.clone());
     }
     if let Some(linker) = linker {
-        rustflags.push(linker.to_owned());
+        rustflags.push(linker.to_string());
     }
     rustflags.extend_from_slice(&[
-        "-Csymbol-mangling-version=v0".to_owned(),
-        "-Cdebuginfo=2".to_owned(),
-        disable_lto_lfags.to_owned(),
+        "-Csymbol-mangling-version=v0".to_string(),
+        "-Cdebuginfo=2".to_string(),
         format!("-Zcodegen-backend={}", cg_backend_path.display()),
-        "--sysroot".to_owned(),
-        format!("{}", sysroot_path.display()),
+        "--sysroot".to_string(),
+        sysroot_path.display().to_string(),
     ]);
+
+    // Since we don't support ThinLTO, disable LTO completely when not trying to do LTO.
+    // TODO(antoyo): remove when we can handle ThinLTO.
+    if !env.contains_key(&"FAT_LTO".to_string()) {
+        rustflags.push("-Clto=off".to_string());
+    }
     rustflags.extend_from_slice(test_flags);
     // FIXME(antoyo): remove once the atomic shim is gone
     if os_name == "Darwin" {
         rustflags.extend_from_slice(&[
-            "-Clink-arg=-undefined".to_owned(),
-            "-Clink-arg=dynamic_lookup".to_owned(),
+            "-Clink-arg=-undefined".to_string(),
+            "-Clink-arg=dynamic_lookup".to_string(),
         ]);
     }
-    env.insert("RUSTFLAGS".to_owned(), rustflags.join(" "));
+    env.insert("RUSTFLAGS".to_string(), rustflags.join(" "));
     // display metadata load errors
-    env.insert("RUSTC_LOG".to_owned(), "warn".to_owned());
+    env.insert("RUSTC_LOG".to_string(), "warn".to_string());
 
+    let sysroot = current_dir.join(&format!(
+        "build_sysroot/sysroot/lib/rustlib/{}/lib",
+        target_triple
+    ));
     let ld_library_path = format!(
         "{target}:{sysroot}:{gcc_path}",
         target = current_dir.join("target/out").display(),
-        sysroot = current_dir
-            .join(&format!(
-                "build_sysroot/sysroot/lib/rustlib/{target_triple}/lib"
-            ),)
-            .display(),
+        sysroot = sysroot.display(),
     );
-    env.insert("LD_LIBRARY_PATH".to_owned(), ld_library_path.clone());
-    env.insert("DYLD_LIBRARY_PATH".to_owned(), ld_library_path);
+    env.insert("LD_LIBRARY_PATH".to_string(), ld_library_path.clone());
+    env.insert("DYLD_LIBRARY_PATH".to_string(), ld_library_path);
 
     // NOTE: To avoid the -fno-inline errors, use /opt/gcc/bin/gcc instead of cc.
     // To do so, add a symlink for cc to /opt/gcc/bin/gcc in our PATH.
     // Another option would be to add the following Rust flag: -Clinker=/opt/gcc/bin/gcc
     let path = std::env::var("PATH").unwrap_or_default();
-    env.insert("PATH".to_owned(), format!("/opt/gcc/bin:{path}"));
+    env.insert("PATH".to_string(), format!("/opt/gcc/bin:{}", path));
 
-    let mut rustc_command = vec!["rustc".to_owned()];
+    let mut rustc_command = vec!["rustc".to_string()];
     rustc_command.extend_from_slice(&rustflags);
     rustc_command.extend_from_slice(&[
-        "-L".to_owned(),
-        "crate=target/out".to_owned(),
-        "--out-dir".to_owned(),
-        "target/out".to_owned(),
+        "-L".to_string(),
+        "crate=target/out".to_string(),
+        "--out-dir".to_string(),
+        "target/out".to_string(),
     ]);
     Ok(ConfigInfo {
-        target_triple: target_triple.to_owned(),
+        target_triple: target_triple.to_string(),
         rustc_command,
         run_wrapper,
     })
diff --git a/build_system/src/prepare.rs b/build_system/src/prepare.rs
index 6274628378e..b258ddf3664 100644
--- a/build_system/src/prepare.rs
+++ b/build_system/src/prepare.rs
@@ -7,7 +7,7 @@ use std::path::Path;
 fn prepare_libcore(sysroot_path: &Path) -> Result<(), String> {
     let rustc_path = match get_rustc_path() {
         Some(path) => path,
-        None => return Err("`rustc` path not found".to_owned()),
+        None => return Err("`rustc` path not found".to_string()),
     };
 
     let parent = match rustc_path.parent() {
@@ -18,27 +18,28 @@ fn prepare_libcore(sysroot_path: &Path) -> Result<(), String> {
     let rustlib_dir = parent
         .join("../lib/rustlib/src/rust")
         .canonicalize()
-        .map_err(|e| format!("Failed to canonicalize path: {e:?}"))?;
+        .map_err(|error| format!("Failed to canonicalize path: {:?}", error))?;
     if !rustlib_dir.is_dir() {
-        return Err("Please install `rust-src` component".to_owned());
+        return Err("Please install `rust-src` component".to_string());
     }
 
     let sysroot_dir = sysroot_path.join("sysroot_src");
     if sysroot_dir.is_dir() {
-        if let Err(e) = fs::remove_dir_all(&sysroot_dir) {
+        if let Err(error) = fs::remove_dir_all(&sysroot_dir) {
             return Err(format!(
                 "Failed to remove `{}`: {:?}",
                 sysroot_dir.display(),
-                e
+                error,
             ));
         }
     }
 
     let sysroot_library_dir = sysroot_dir.join("library");
-    fs::create_dir_all(&sysroot_library_dir).map_err(|e| {
+    fs::create_dir_all(&sysroot_library_dir).map_err(|error| {
         format!(
-            "Failed to create folder `{}`: {e:?}",
+            "Failed to create folder `{}`: {:?}",
             sysroot_library_dir.display(),
+            error,
         )
     })?;
 
@@ -90,8 +91,8 @@ fn prepare_libcore(sysroot_path: &Path) -> Result<(), String> {
     for file_path in patches {
         println!("[GIT] apply `{}`", file_path.display());
         let path = Path::new("../..").join(file_path);
-        run_command_with_output(&[&"git", &"apply", &path], Some(&sysroot_dir), None)?;
-        run_command_with_output(&[&"git", &"add", &"-A"], Some(&sysroot_dir), None)?;
+        run_command_with_output(&[&"git", &"apply", &path], Some(&sysroot_dir))?;
+        run_command_with_output(&[&"git", &"add", &"-A"], Some(&sysroot_dir))?;
         run_command_with_output(
             &[
                 &"git",
@@ -101,7 +102,6 @@ fn prepare_libcore(sysroot_path: &Path) -> Result<(), String> {
                 &format!("Patch {}", path.display()),
             ],
             Some(&sysroot_dir),
-            None,
         )?;
     }
     println!("Successfully prepared libcore for building");
@@ -139,12 +139,11 @@ where
         "crate_patches",
         |_| Ok(()),
         |file_path| {
-            let s = file_path.as_os_str().to_str().unwrap();
-            if s.contains(&filter) && s.ends_with(".patch") {
+            let patch = file_path.as_os_str().to_str().unwrap();
+            if patch.contains(&filter) && patch.ends_with(".patch") {
                 run_command_with_output(
                     &[&"git", &"am", &file_path.canonicalize().unwrap()],
                     Some(&repo_path),
-                    None,
                 )?;
             }
             Ok(())
diff --git a/build_system/src/rustc_info.rs b/build_system/src/rustc_info.rs
index 38c0045c7b3..0988b56d81e 100644
--- a/build_system/src/rustc_info.rs
+++ b/build_system/src/rustc_info.rs
@@ -8,5 +8,5 @@ pub fn get_rustc_path() -> Option<PathBuf> {
     }
     run_command(&[&"rustup", &"which", &"rustc"], None)
         .ok()
-        .map(|out| Path::new(String::from_utf8(out.stdout).unwrap().trim()).to_owned())
+        .map(|out| Path::new(String::from_utf8(out.stdout).unwrap().trim()).to_path_buf())
 }
diff --git a/build_system/src/utils.rs b/build_system/src/utils.rs
index 1724e275595..536f33a8029 100644
--- a/build_system/src/utils.rs
+++ b/build_system/src/utils.rs
@@ -80,6 +80,19 @@ pub fn run_command_with_env(
 pub fn run_command_with_output(
     input: &[&dyn AsRef<OsStr>],
     cwd: Option<&Path>,
+) -> Result<(), String> {
+    let exit_status = get_command_inner(input, cwd, None)
+        .spawn()
+        .map_err(|e| command_error(input, &cwd, e))?
+        .wait()
+        .map_err(|e| command_error(input, &cwd, e))?;
+    check_exit_status(input, cwd, exit_status)?;
+    Ok(())
+}
+
+pub fn run_command_with_output_and_env(
+    input: &[&dyn AsRef<OsStr>],
+    cwd: Option<&Path>,
     env: Option<&HashMap<String, String>>,
 ) -> Result<(), String> {
     let exit_status = get_command_inner(input, cwd, env)
@@ -111,7 +124,7 @@ pub fn cargo_install(to_install: &str) -> Result<(), String> {
         return Ok(());
     }
     // We voluntarily ignore this error.
-    if run_command_with_output(&[&"cargo", &"install", &to_install], None, None).is_err() {
+    if run_command_with_output(&[&"cargo", &"install", &to_install], None).is_err() {
         println!("Skipping installation of `{to_install}`");
     }
     Ok(())
@@ -122,11 +135,11 @@ pub fn get_os_name() -> Result<String, String> {
     let name = std::str::from_utf8(&output.stdout)
         .unwrap_or("")
         .trim()
-        .to_owned();
+        .to_string();
     if !name.is_empty() {
         Ok(name)
     } else {
-        Err(format!("Failed to retrieve the OS name"))
+        Err("Failed to retrieve the OS name".to_string())
     }
 }
 
@@ -138,14 +151,14 @@ pub fn get_rustc_host_triple() -> Result<String, String> {
         if !line.starts_with("host:") {
             continue;
         }
-        return Ok(line.split(':').nth(1).unwrap().trim().to_owned());
+        return Ok(line.split(':').nth(1).unwrap().trim().to_string());
     }
-    Err("Cannot find host triple".to_owned())
+    Err("Cannot find host triple".to_string())
 }
 
 pub fn get_gcc_path() -> Result<String, String> {
     let content = match fs::read_to_string("gcc_path") {
-        Ok(c) => c,
+        Ok(content) => content,
         Err(_) => {
             return Err(
                 "Please put the path to your custom build of libgccjit in the file \
@@ -156,15 +169,16 @@ pub fn get_gcc_path() -> Result<String, String> {
     };
     match content
         .split('\n')
-        .map(|l| l.trim())
-        .filter(|l| !l.is_empty())
+        .map(|line| line.trim())
+        .filter(|line| !line.is_empty())
         .next()
     {
         Some(gcc_path) => {
             let path = Path::new(gcc_path);
             if !path.exists() {
                 Err(format!(
-                    "Path `{gcc_path}` contained in the `gcc_path` file doesn't exist"
+                    "Path `{}` contained in the `gcc_path` file doesn't exist",
+                    gcc_path,
                 ))
             } else {
                 Ok(gcc_path.into())
@@ -182,8 +196,8 @@ pub struct CloneResult {
 pub fn git_clone(to_clone: &str, dest: Option<&Path>) -> Result<CloneResult, String> {
     let repo_name = to_clone.split('/').last().unwrap();
     let repo_name = match repo_name.strip_suffix(".git") {
-        Some(n) => n.to_owned(),
-        None => repo_name.to_owned(),
+        Some(n) => n.to_string(),
+        None => repo_name.to_string(),
     };
 
     let dest = dest
@@ -196,7 +210,7 @@ pub fn git_clone(to_clone: &str, dest: Option<&Path>) -> Result<CloneResult, Str
         });
     }
 
-    run_command_with_output(&[&"git", &"clone", &to_clone, &dest], None, None)?;
+    run_command_with_output(&[&"git", &"clone", &to_clone, &dest], None)?;
     Ok(CloneResult {
         ran_clone: true,
         repo_name,
@@ -210,11 +224,11 @@ where
     F: FnMut(&Path) -> Result<(), String>,
 {
     let dir = dir.as_ref();
-    for entry in
-        fs::read_dir(dir).map_err(|e| format!("Failed to read dir `{}`: {e:?}", dir.display()))?
+    for entry in fs::read_dir(dir)
+        .map_err(|error| format!("Failed to read dir `{}`: {:?}", dir.display(), error))?
     {
-        let entry =
-            entry.map_err(|e| format!("Failed to read entry in `{}`: {e:?}", dir.display()))?;
+        let entry = entry
+            .map_err(|error| format!("Failed to read entry in `{}`: {:?}", dir.display(), error))?;
         let entry_path = entry.path();
         if entry_path.is_dir() {
             dir_cb(&entry_path)?;