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

sunfishcode · sunfishcode · commit b7aae1b68e05 · 2021-01-06T03:11:51.000-08:00
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/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 {
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/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;
             }
         }
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/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),
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/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);
         }
     }
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/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 {
diff --git a/compiler/rustc_incremental/src/persist/save.rs b/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))
     });
 }
 
diff --git a/compiler/rustc_interface/src/passes.rs b/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)
 }
 
diff --git a/compiler/rustc_interface/src/util.rs b/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
diff --git a/compiler/rustc_llvm/build.rs b/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();
diff --git a/compiler/rustc_metadata/src/locator.rs b/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 {
diff --git a/compiler/rustc_session/src/filesearch.rs b/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()
diff --git a/compiler/rustc_session/src/session.rs b/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()
diff --git a/compiler/rustc_span/src/source_map.rs b/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> {
diff --git a/compiler/rustc_target/src/spec/mod.rs b/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))
diff --git a/library/std/src/fs.rs b/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),
         }
     }
diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
diff --git a/library/std/src/sys/windows/process.rs b/library/std/src/sys/windows/process.rs
diff --git a/library/term/src/terminfo/searcher.rs b/library/term/src/terminfo/searcher.rs
diff --git a/src/test/ui-fulldeps/rename-directory.rs b/src/test/ui-fulldeps/rename-directory.rs

Original file line number	Diff line number	Diff line change
`@@ -15,12 +15,12 @@ pub fn find_library(name: Symbol, search_paths: &[PathBuf], sess: &Session) -> P`
`15`	`15`	`for path in search_paths {`
`16`	`16`	`debug!("looking for {} inside {:?}", name, path);`
`17`	`17`	`let test = path.join(&oslibname);`
`18`		`- if fs::metadata(&test).is_ok() {`
	`18`	`+ if fs::exists(&test) {`
`19`	`19`	`return test;`
`20`	`20`	`}`
`21`	`21`	`if oslibname != unixlibname {`
`22`	`22`	`let test = path.join(&unixlibname);`
`23`		`- if fs::metadata(&test).is_ok() {`
	`23`	`+ if fs::exists(&test) {`
`24`	`24`	`return test;`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1110,19 +1110,19 @@ fn print_native_static_libs(sess: &Session, all_native_libs: &[NativeLib]) {`
`1110`	`1110`	`fn get_object_file_path(sess: &Session, name: &str, self_contained: bool) -> PathBuf {`
`1111`	`1111`	`let fs = sess.target_filesearch(PathKind::Native);`
`1112`	`1112`	`let file_path = fs.get_lib_path().join(name);`
`1113`		`- if fs::metadata(&file_path).is_ok() {`
	`1113`	`+ if fs::exists(&file_path) {`
`1114`	`1114`	`return file_path;`
`1115`	`1115`	`}`
`1116`	`1116`	`// Special directory with objects used only in self-contained linkage mode`
`1117`	`1117`	`if self_contained {`
`1118`	`1118`	`let file_path = fs.get_self_contained_lib_path().join(name);`
`1119`		`- if fs::metadata(&file_path).is_ok() {`
	`1119`	`+ if fs::exists(&file_path) {`
`1120`	`1120`	`return file_path;`
`1121`	`1121`	`}`
`1122`	`1122`	`}`
`1123`	`1123`	`for search_path in fs.search_paths() {`
`1124`	`1124`	`let file_path = search_path.dir.join(name);`
`1125`		`- if fs::metadata(&file_path).is_ok() {`
	`1125`	`+ if fs::exists(&file_path) {`
`1126`	`1126`	`return file_path;`
`1127`	`1127`	`}`
`1128`	`1128`	`}`
`@@ -1312,9 +1312,7 @@ fn detect_self_contained_mingw(sess: &Session) -> bool {`
`1312`	`1312`	`for dir in env::split_paths(&env::var_os("PATH").unwrap_or_default()) {`
`1313`	`1313`	`let full_path = dir.join(&linker_with_extension);`
`1314`	`1314`	`// If linker comes from sysroot assume self-contained mode`
`1315`		`- if fs::metadata(&full_path).map(\|m\| m.is_file()).unwrap_or(false)`
`1316`		`- && !full_path.starts_with(&sess.sysroot)`
`1317`		`- {`
	`1315`	`+ if fs::is_file(&full_path) && !full_path.starts_with(&sess.sysroot) {`
`1318`	`1316`	`return false;`
`1319`	`1317`	`}`
`1320`	`1318`	`}`
`@@ -2230,7 +2228,7 @@ fn get_apple_sdk_root(sdk_name: &str) -> Result<String, String> {`
`2230`	`2228`	`if sdkroot.contains("iPhoneOS.platform")`
`2231`	`2229`	`\|\| sdkroot.contains("iPhoneSimulator.platform") => {}`
`2232`	`2230`	// Ignore `SDKROOT` if it's not a valid path.
`2233`		`- _ if !p.is_absolute() \|\| p == Path::new("/") \|\| fs::metadata(p).is_err() => {}`
	`2231`	`+ _ if !p.is_absolute() \|\| p == Path::new("/") \|\| !fs::exists(p) => {}`
`2234`	`2232`	`_ => return Ok(sdkroot),`
`2235`	`2233`	`}`
`2236`	`2234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -695,7 +695,7 @@ impl<'a> Linker for MsvcLinker<'a> {`
`695`	`695`	`// check to see if the file is there and just omit linking to it if it's`
`696`	`696`	`// not present.`
`697`	`697`	`let name = format!("{}.dll.lib", lib);`
`698`		`- if fs::metadata(&path.join(&name)).is_ok() {`
	`698`	`+ if fs::exists(&path.join(&name)) {`
`699`	`699`	`self.cmd.arg(name);`
`700`	`700`	`}`
`701`	`701`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ pub fn save_work_product_index(`
`74`	`74`	`if !new_work_products.contains_key(id) {`
`75`	`75`	`work_product::delete_workproduct_files(sess, wp);`
`76`	`76`	`debug_assert!(wp.saved_file.as_ref().map_or(true, \|file_name\| {`
`77`		`- fs::metadata(in_incr_comp_dir_sess(sess, &file_name)).is_err()`
	`77`	`+ !fs::exists(in_incr_comp_dir_sess(sess, &file_name))`
`78`	`78`	`}));`
`79`	`79`	`}`
`80`	`80`	`}`
`@@ -85,7 +85,7 @@ pub fn save_work_product_index(`
`85`	`85`	`.iter()`
`86`	`86`	`.flat_map(\|(_, wp)\| wp.saved_file.iter())`
`87`	`87`	`.map(\|name\| in_incr_comp_dir_sess(sess, name))`
`88`		`- .all(\|path\| fs::metadata(path).is_ok())`
	`88`	`+ .all(\|path\| fs::exists(path))`
`89`	`89`	`});`
`90`	`90`	`}`
`91`	`91`
Original file line number	Diff line number	Diff line change
`@@ -517,9 +517,7 @@ fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool`
`517`	`517`	`}`
`518`	`518`
`519`	`519`	`fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {`
`520`		`- let check = \|output_path: &PathBuf\| {`
`521`		`- fs::metadata(output_path).map(\|m\| m.is_dir()).unwrap_or(false).then(\|\| output_path.clone())`
`522`		`- };`
	`520`	`+ let check = \|output_path: &PathBuf\| fs::is_dir(output_path).then(\|\| output_path.clone());`
`523`	`521`	`check_output(output_paths, check)`
`524`	`522`	`}`
`525`	`523`