refactor: simplify conditional logic using then method (#1860)

Author: xtqqczze

find-msvc-tools/src/find_tools.rs

@@ -562,19 +562,21 @@ mod impl_ {
         version: &'static str,
         env_getter: &dyn EnvGetter,
     ) -> Box<dyn Iterator<Item = PathBuf>> {
-        let Some(instances) = vs15plus_instances(target, env_getter) else {
-            return Box::new(iter::empty());
-        };
-        Box::new(instances.into_iter().filter_map(move |instance| {
-            let installation_name = instance.installation_name()?;
-            if installation_name.starts_with(&format!("VisualStudio/{}.", version))
-                || installation_name.starts_with(&format!("VisualStudioPreview/{}.", version))
-            {
-                Some(instance.installation_path()?)
-            } else {
-                None
-            }
-        }))
+        Box::new(
+            vs15plus_instances(target, env_getter)
+                .into_iter()
+                .flatten()
+                .filter_map(move |instance| {
+                    instance
+                        .installation_name()
+                        .filter(|name| {
+                            ["VisualStudio", "VisualStudioPreview"]
+                                .into_iter()
+                                .any(|kind| name.starts_with(&format!("{kind}/{version}.")))
+                        })
+                        .and_then(|_| instance.installation_path())
+                }),
+        )
     }
 
     fn find_tool_in_vs16plus_path(
@@ -864,11 +866,10 @@ mod impl_ {
         // We use the first available host architecture that can build for the target
         let (host_path, host) = hosts.iter().find_map(|&x| {
             let candidate = path.join("bin").join(format!("Host{}", x));
-            if candidate.join(target_dir).exists() {
-                Some((candidate, x))
-            } else {
-                None
-            }
+            candidate
+                .join(target_dir)
+                .exists()
+                .then_some((candidate, x))
         })?;
         // This is the path to the toolchain for a particular target, running
         // on a given host
@@ -963,12 +964,10 @@ mod impl_ {
 
     fn atl_paths(target: TargetArch, path: &Path) -> Option<(PathBuf, PathBuf)> {
         let atl_path = path.join("atlmfc");
-        let sub = target.as_vs_arch();
-        if atl_path.exists() {
-            Some((atl_path.join("lib").join(sub), atl_path.join("include")))
-        } else {
-            None
-        }
+        atl_path.exists().then(|| {
+            let sub = target.as_vs_arch();
+            (atl_path.join("lib").join(sub), atl_path.join("include"))
+        })
     }
 
     // For MSVC 14 we need to find the Universal CRT as well as either

src/bin/cc-shim.rs

@@ -46,16 +46,12 @@ fn out_file(program: &str) -> Option<PathBuf> {
 
     let out_dir = PathBuf::from(env::var_os(OUT_DIR)?);
     // Find the first nonexistent candidate file to which the program's args can be written.
-    Some((0..).find_map(|i| {
-        let candidate = out_dir.join(format!("out{i}"));
-
-        if candidate.exists() {
-            // If the file exists, commands have already run. Try again.
-            None
-        } else {
-            Some(candidate)
-        }
-    }).unwrap_or_else(|| panic!("Cannot find the first nonexistent candidate file to which the program's args can be written under out_dir '{}'", out_dir.display())))
+    Some(
+        (0..)
+            .map(|i| out_dir.join(format!("out{i}")))
+            .find(|candidate| !candidate.exists())
+            .unwrap_or_else(|| panic!("Cannot find the first nonexistent candidate file to which the program's args can be written under out_dir '{}'", out_dir.display()))
+    )
 }
 
 /// Record the args passed to the command, if this invocation records at all.

src/lib.rs

@@ -2397,11 +2397,8 @@ impl Build {
                     // So instead, we pass the deployment target with `-m*-version-min=`, and only
                     // pass it here on visionOS and Mac Catalyst where that option does not exist:
                     // https://github.com/rust-lang/cc-rs/issues/1383
-                    let version = if target.os == "visionos" || target.env == "macabi" {
-                        Some(self.apple_deployment_target(target))
-                    } else {
-                        None
-                    };
+                    let version = (target.os == "visionos" || target.env == "macabi")
+                        .then(|| self.apple_deployment_target(target));
 
                     let clang_target =
                         target.llvm_target(&self.get_raw_target()?, version.as_deref());
@@ -3476,11 +3473,9 @@ impl Build {
         let wrapper_path = Path::new(&rustc_wrapper);
         let wrapper_stem = wrapper_path.file_stem()?;
 
-        if VALID_WRAPPERS.contains(&wrapper_stem.to_str()?) {
-            Some(Cow::Owned(rustc_wrapper))
-        } else {
-            None
-        }
+        VALID_WRAPPERS
+            .contains(&wrapper_stem.to_str()?)
+            .then_some(Cow::Owned(rustc_wrapper))
     }
 
     /// Returns compiler path, optional modifier name from whitelist, and arguments vec
@@ -3565,11 +3560,10 @@ impl Build {
             Some(s) => Ok(s.as_deref().map(Path::new).map(Cow::Borrowed)),
             None => {
                 if let Ok(stdlib) = self.getenv_with_target_prefixes("CXXSTDLIB") {
-                    if stdlib.is_empty() {
-                        Ok(None)
-                    } else {
-                        Ok(Some(Cow::Owned(Path::new(&stdlib).to_owned())))
-                    }
+                    Ok((!stdlib.is_empty())
+                        .then_some(stdlib)
+                        .map(PathBuf::from)
+                        .map(Cow::from))
                 } else {
                     let target = self.get_target()?;
                     if target.env == "msvc" {

src/utilities.rs

@@ -94,12 +94,10 @@ impl<T> OnceLock<T> {
     }
 
     pub(crate) fn get(&self) -> Option<&T> {
-        if self.is_initialized() {
-            // Safe b/c checked is_initialized
-            Some(unsafe { self.get_unchecked() })
-        } else {
-            None
-        }
+        self.is_initialized().then(|| {
+            // SAFETY: `is_initialized()` returned `true`, so the value is initialized.
+            unsafe { self.get_unchecked() }
+        })
     }
 }