Provide convenience functions exists, is_file, and is_dir, in fs.

Author: sunfishcode

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -496,11 +496,8 @@ fn thin_lto(
             // If the previous file was deleted, or we get an IO error
             // reading the file, then we'll just use `None` as the
             // prev_key_map, which will force the code to be recompiled.
-            let prev = if fs::metadata(&path).is_ok() {
-                ThinLTOKeysMap::load_from_file(&path).ok()
-            } else {
-                None
-            };
+            let prev =
+                if fs::exists(&path) { ThinLTOKeysMap::load_from_file(&path).ok() } else { None };
             let curr = ThinLTOKeysMap::from_thin_lto_modules(&data, &thin_modules, &module_names);
             (Some(path), prev, curr)
         } else {

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -15,12 +15,12 @@ pub fn find_library(name: Symbol, search_paths: &[PathBuf], sess: &Session) -> P
     for path in search_paths {
         debug!("looking for {} inside {:?}", name, path);
         let test = path.join(&oslibname);
-        if fs::metadata(&test).is_ok() {
+        if fs::exists(&test) {
             return test;
         }
         if oslibname != unixlibname {
             let test = path.join(&unixlibname);
-            if fs::metadata(&test).is_ok() {
+            if fs::exists(&test) {
                 return test;
             }
         }

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1110,19 +1110,19 @@ fn print_native_static_libs(sess: &Session, all_native_libs: &[NativeLib]) {
 fn get_object_file_path(sess: &Session, name: &str, self_contained: bool) -> PathBuf {
     let fs = sess.target_filesearch(PathKind::Native);
     let file_path = fs.get_lib_path().join(name);
-    if fs::metadata(&file_path).is_ok() {
+    if fs::exists(&file_path) {
         return file_path;
     }
     // Special directory with objects used only in self-contained linkage mode
     if self_contained {
         let file_path = fs.get_self_contained_lib_path().join(name);
-        if fs::metadata(&file_path).is_ok() {
+        if fs::exists(&file_path) {
             return file_path;
         }
     }
     for search_path in fs.search_paths() {
         let file_path = search_path.dir.join(name);
-        if fs::metadata(&file_path).is_ok() {
+        if fs::exists(&file_path) {
             return file_path;
         }
     }
@@ -1312,9 +1312,7 @@ fn detect_self_contained_mingw(sess: &Session) -> bool {
     for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) {
         let full_path = dir.join(&linker_with_extension);
         // If linker comes from sysroot assume self-contained mode
-        if fs::metadata(&full_path).map(|m| m.is_file()).unwrap_or(false)
-            && !full_path.starts_with(&sess.sysroot)
-        {
+        if fs::is_file(&full_path) && !full_path.starts_with(&sess.sysroot) {
             return false;
         }
     }
@@ -2230,7 +2228,7 @@ fn get_apple_sdk_root(sdk_name: &str) -> Result<String, String> {
                 if sdkroot.contains("iPhoneOS.platform")
                     || sdkroot.contains("iPhoneSimulator.platform") => {}
             // Ignore `SDKROOT` if it's not a valid path.
-            _ if !p.is_absolute() || p == Path::new("/") || fs::metadata(p).is_err() => {}
+            _ if !p.is_absolute() || p == Path::new("/") || !fs::exists(p) => {}
             _ => return Ok(sdkroot),
         }
     }

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -695,7 +695,7 @@ impl<'a> Linker for MsvcLinker<'a> {
         // check to see if the file is there and just omit linking to it if it's
         // not present.
         let name = format!("{}.dll.lib", lib);
-        if fs::metadata(&path.join(&name)).is_ok() {
+        if fs::exists(&path.join(&name)) {
             self.cmd.arg(name);
         }
     }

compiler/rustc_incremental/src/persist/load.rs

@@ -143,7 +143,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
                 let mut all_files_exist = true;
                 if let Some(ref file_name) = swp.work_product.saved_file {
                     let path = in_incr_comp_dir_sess(sess, file_name);
-                    if fs::metadata(&path).is_err() {
+                    if !fs::exists(&path) {
                         all_files_exist = false;
 
                         if sess.opts.debugging_opts.incremental_info {

compiler/rustc_incremental/src/persist/save.rs

@@ -74,7 +74,7 @@ pub fn save_work_product_index(
         if !new_work_products.contains_key(id) {
             work_product::delete_workproduct_files(sess, wp);
             debug_assert!(wp.saved_file.as_ref().map_or(true, |file_name| {
-                fs::metadata(in_incr_comp_dir_sess(sess, &file_name)).is_err()
+                !fs::exists(in_incr_comp_dir_sess(sess, &file_name))
             }));
         }
     }
@@ -85,7 +85,7 @@ pub fn save_work_product_index(
             .iter()
             .flat_map(|(_, wp)| wp.saved_file.iter())
             .map(|name| in_incr_comp_dir_sess(sess, name))
-            .all(|path| fs::metadata(path).is_ok())
+            .all(|path| fs::exists(path))
     });
 }
 

compiler/rustc_interface/src/passes.rs

@@ -517,9 +517,7 @@ fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool
 }
 
 fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
-    let check = |output_path: &PathBuf| {
-        fs::metadata(output_path).map(|m| m.is_dir()).unwrap_or(false).then(|| output_path.clone())
-    };
+    let check = |output_path: &PathBuf| fs::is_dir(output_path).then(|| output_path.clone());
     check_output(output_paths, check)
 }
 

compiler/rustc_interface/src/util.rs

@@ -270,7 +270,7 @@ fn get_rustc_path_inner(bin_path: &str) -> Option<PathBuf> {
         } else {
             "rustc"
         });
-        fs::metadata(&candidate).is_ok().then_some(candidate)
+        fs::exists(&candidate).then_some(candidate)
     })
 }
 
@@ -398,7 +398,7 @@ pub fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend
         })
         .find(|f| {
             info!("codegen backend candidate: {}", f.display());
-            fs::metadata(f).is_ok()
+            fs::exists(f)
         });
     let sysroot = sysroot.unwrap_or_else(|| {
         let candidates = sysroot_candidates

compiler/rustc_llvm/build.rs

@@ -206,7 +206,7 @@ fn main() {
             stripped
         } else if let Some(stripped) = lib.strip_prefix('-') {
             stripped
-        } else if fs::metadata(Path::new(lib)).is_ok() {
+        } else if fs::exists(Path::new(lib)) {
             // On MSVC llvm-config will print the full name to libraries, but
             // we're only interested in the name part
             let name = Path::new(lib).file_name().unwrap().to_str().unwrap();

compiler/rustc_metadata/src/locator.rs

@@ -664,7 +664,7 @@ impl<'a> CrateLocator<'a> {
         let mut rmetas = FxHashMap::default();
         let mut dylibs = FxHashMap::default();
         for loc in &self.exact_paths {
-            if fs::metadata(loc).is_err() {
+            if !fs::exists(loc) {
                 return Err(CrateError::ExternLocationNotExist(self.crate_name, loc.clone()));
             }
             let file = match loc.file_name().and_then(|s| s.to_str()) {
@@ -738,7 +738,7 @@ fn get_metadata_section(
     filename: &Path,
     loader: &dyn MetadataLoader,
 ) -> Result<MetadataBlob, String> {
-    if fs::metadata(filename).is_err() {
+    if !fs::exists(filename) {
         return Err(format!("no such file: '{}'", filename.display()));
     }
     let raw_bytes: MetadataRef = match flavor {

compiler/rustc_session/src/filesearch.rs

@@ -154,7 +154,7 @@ fn find_libdir(sysroot: &Path) -> Cow<'static, str> {
 
     match option_env!("CFG_LIBDIR_RELATIVE") {
         None | Some("lib") => {
-            if fs::metadata(sysroot.join(PRIMARY_LIB_DIR).join(RUST_LIB_DIR)).is_ok() {
+            if fs::exists(sysroot.join(PRIMARY_LIB_DIR).join(RUST_LIB_DIR)) {
                 PRIMARY_LIB_DIR.into()
             } else {
                 SECONDARY_LIB_DIR.into()

compiler/rustc_session/src/session.rs

@@ -1485,7 +1485,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
     // Make sure that any given profiling data actually exists so LLVM can't
     // decide to silently skip PGO.
     if let Some(ref path) = sess.opts.cg.profile_use {
-        if fs::metadata(path).is_err() {
+        if !fs::exists(path) {
             sess.err(&format!(
                 "File `{}` passed to `-C profile-use` does not exist.",
                 path.display()

compiler/rustc_span/src/source_map.rs

@@ -109,7 +109,7 @@ pub struct RealFileLoader;
 
 impl FileLoader for RealFileLoader {
     fn file_exists(&self, path: &Path) -> bool {
-        fs::metadata(path).is_ok()
+        fs::exists(path)
     }
 
     fn read_file(&self, path: &Path) -> io::Result<String> {

compiler/rustc_target/src/spec/mod.rs

@@ -1600,14 +1600,14 @@ impl Target {
 
                 for dir in env::split_paths(&target_path) {
                     let p = dir.join(&path);
-                    if fs::metadata(&p).map(|m| m.is_file()).unwrap_or(false) {
+                    if fs::is_file(&p) {
                         return load_file(&p);
                     }
                 }
                 Err(format!("Could not find specification for target {:?}", target_triple))
             }
             TargetTriple::TargetPath(ref target_path) => {
-                if fs::metadata(target_path).map(|m| m.is_file()).unwrap_or(false) {
+                if fs::is_file(target_path) {
                     return load_file(&target_path);
                 }
                 Err(format!("Target path {:?} is not a valid file", target_path))

library/std/src/fs.rs

@@ -2108,6 +2108,92 @@ pub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) -> io::Result
     fs_imp::set_perm(path.as_ref(), perm.0)
 }
 
+/// Returns `true` if the path points at an existing entity.
+///
+/// This function will traverse symbolic links to query information about the
+/// destination file. In case of broken symbolic links this will return `false`.
+///
+/// If you cannot access the directory containing the file, e.g., because of a
+/// permission error, this will return `false`.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::path::Path;
+/// assert!(!Path::new("does_not_exist.txt").exists());
+/// ```
+///
+/// # See Also
+///
+/// This is a convenience function that coerces errors to false. If you want to
+/// check errors, call [`metadata`].
+#[stable(feature = "fs_path_convenience", since = "1.51.0")]
+pub fn exists<P: AsRef<Path>>(path: P) -> bool {
+    metadata(path).is_ok()
+}
+
+/// Returns `true` if the path exists on disk and is pointing at a regular file.
+///
+/// This function will traverse symbolic links to query information about the
+/// destination file. In case of broken symbolic links this will return `false`.
+///
+/// If you cannot access the directory containing the file, e.g., because of a
+/// permission error, this will return `false`.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::path::Path;
+/// assert_eq!(Path::new("./is_a_directory/").is_file(), false);
+/// assert_eq!(Path::new("a_file.txt").is_file(), true);
+/// ```
+///
+/// # See Also
+///
+/// This is a convenience function that coerces errors to false. If you want to
+/// check errors, call [`metadata`] and handle its [`Result`]. Then call
+/// [`Metadata::is_file`] if it was [`Ok`].
+///
+/// When the goal is simply to read from (or write to) the source, the most
+/// reliable way to test the source can be read (or written to) is to open
+/// it. Only using `is_file` can break workflows like `diff <( prog_a )` on
+/// a Unix-like system for example. See [`File::open`] or
+/// [`OpenOptions::open`] for more information.
+#[stable(feature = "fs_path_convenience", since = "1.51.0")]
+pub fn is_file<P: AsRef<Path>>(path: P) -> bool {
+    metadata(path).map(|m| m.is_file()).unwrap_or(false)
+}
+
+/// Returns `true` if the path exists on disk and is pointing at a directory.
+///
+/// This function will traverse symbolic links to query information about the
+/// destination file. In case of broken symbolic links this will return `false`.
+///
+/// If you cannot access the directory containing the file, e.g., because of a
+/// permission error, this will return `false`.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::path::Path;
+/// assert_eq!(Path::new("./is_a_directory/").is_dir(), true);
+/// assert_eq!(Path::new("a_file.txt").is_dir(), false);
+/// ```
+///
+/// # See Also
+///
+/// This is a convenience function that coerces errors to false. If you want to
+/// check errors, call [`metadata`] and handle its [`Result`]. Then call
+/// [`Metadata::is_dir`] if it was [`Ok`].
+///
+/// When the goal is simply to read from the source, the most reliable way to
+/// test the source can be read is to open it. See [`read_dir`] for more
+/// information.
+#[stable(feature = "fs_path_convenience", since = "1.51.0")]
+pub fn is_dir<P: AsRef<Path>>(path: P) -> bool {
+    metadata(path).map(|m| m.is_dir()).unwrap_or(false)
+}
+
 impl DirBuilder {
     /// Creates a new set of options with default mode/security settings for all
     /// platforms and also non-recursive.
@@ -2160,7 +2246,7 @@ impl DirBuilder {
     ///     .recursive(true)
     ///     .create(path).unwrap();
     ///
-    /// assert!(fs::metadata(path).unwrap().is_dir());
+    /// assert!(fs::is_dir(path));
     /// ```
     #[stable(feature = "dir_builder", since = "1.6.0")]
     pub fn create<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
@@ -2179,7 +2265,7 @@ impl DirBuilder {
         match self.inner.mkdir(path) {
             Ok(()) => return Ok(()),
             Err(ref e) if e.kind() == io::ErrorKind::NotFound => {}
-            Err(_) if metadata(path).map(|m| m.is_dir()).unwrap_or(false) => return Ok(()),
+            Err(_) if is_dir(path) => return Ok(()),
             Err(e) => return Err(e),
         }
         match path.parent() {
@@ -2190,7 +2276,7 @@ impl DirBuilder {
         }
         match self.inner.mkdir(path) {
             Ok(()) => Ok(()),
-            Err(_) if metadata(path).map(|m| m.is_dir()).unwrap_or(false) => Ok(()),
+            Err(_) if is_dir(path) => Ok(()),
             Err(e) => Err(e),
         }
     }