Disambiguate fs2 extension-trait locking calls

Summary:
Some `fs2::FileExt` extension-trait methods overlap with new file locking API on `std::fs::File` in Rust 1.84 (D70601924).

```lang=text,counterexample
error: a method with this name may be added to the standard library in the future
   --> fbcode/clifoundation/cli_target/validator/src/main.rs:279:20
    |
279 |         cache_file.lock_shared()?;
    |                    ^^^^^^^^^^^
    |
    = warning: once this associated item is added to the standard library, the ambiguity may cause an error or change in behavior!
    = note: for more information, see issue #48919 <rust-lang/rust#48919>
    = help: call with fully qualified syntax `fs4::FileExt::lock_shared(...)` to keep using the current method
    = note: requested on the command line with `-D unstable-name-collisions`
help: add `#![feature(file_lock)]` to the crate attributes to enable `std::fs::File::lock_shared`
    |
1   + #![feature(file_lock)]
    |
```

This diff (still on Rust 1.83) qualifies all the extension-trait calls so that these do not become a factor in the Rust 1.84 diff.

After D70601924, it would be reasonable to drop `fs2` and `fs4` dependencies and use the standard library APIs instead.

Reviewed By: diliop

Differential Revision: D70676686

fbshipit-source-id: ed9dc8fa139c56e1a6f8e2fc39b923a81e8711b3

Author: David Tolnay

eden/scm/lib/commandserver/src/spawn.rs

@@ -10,7 +10,6 @@ use std::io;
 use std::process::Child;
 use std::process::Command;
 
-use fs2::FileExt;
 use spawn_ext::CommandExt;
 
 use crate::util;
@@ -24,7 +23,7 @@ pub fn spawn_pool(pool_size: usize) -> anyhow::Result<()> {
         .create(true)
         .write(true)
         .open(dir.join("spawn.lock"))?;
-    spawn_lock.lock_exclusive()?;
+    fs2::FileExt::lock_exclusive(&spawn_lock)?;
 
     let existing = udsipc::pool::list_uds_paths(&dir, prefix)
         .take(pool_size)

eden/scm/lib/dag/src/iddagstore/indexedlog_store.rs

@@ -21,7 +21,6 @@ use std::sync::Mutex;
 use byteorder::BigEndian;
 use byteorder::ReadBytesExt;
 use byteorder::WriteBytesExt;
-use fs2::FileExt;
 use indexedlog::log;
 use indexedlog::log::Fold;
 use minibytes::Bytes;
@@ -500,7 +499,7 @@ impl Persist for IndexedLogStore {
                 .create(true)
                 .open(&path)?
         };
-        lock_file.lock_exclusive()?;
+        fs2::FileExt::lock_exclusive(&lock_file)?;
         Ok(lock_file)
     }
 

eden/scm/lib/dag/src/idmap/indexedlog_idmap.rs

@@ -13,7 +13,6 @@ use std::path::PathBuf;
 
 use byteorder::BigEndian;
 use byteorder::ReadBytesExt;
-use fs2::FileExt;
 use indexedlog::log;
 use vlqencoding::VLQDecode;
 use vlqencoding::VLQEncode;
@@ -520,7 +519,7 @@ impl Persist for IdMap {
                 .create(true)
                 .open(&path)?
         };
-        lock_file.lock_exclusive()?;
+        fs2::FileExt::lock_exclusive(&lock_file)?;
         Ok(lock_file)
     }
 

eden/scm/lib/indexedlog/src/index.rs

@@ -89,7 +89,7 @@ use byteorder::ByteOrder;
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 use byteorder::WriteBytesExt;
-use fs2::FileExt;
+use fs2::FileExt as _;
 use minibytes::Bytes;
 use tracing::debug_span;
 use twox_hash::XxHash;

eden/scm/lib/indexedlog/src/lock.rs

@@ -11,7 +11,6 @@ use std::io;
 use std::path::Path;
 use std::path::PathBuf;
 
-use fs2::FileExt;
 use memmap2::MmapMut;
 use memmap2::MmapOptions;
 
@@ -27,9 +26,9 @@ pub struct ScopedFileLock<'a> {
 impl<'a> ScopedFileLock<'a> {
     pub fn new(file: &'a mut File, exclusive: bool) -> io::Result<Self> {
         if exclusive {
-            file.lock_exclusive()?;
+            fs2::FileExt::lock_exclusive(file)?;
         } else {
-            file.lock_shared()?;
+            fs2::FileExt::lock_shared(file)?;
         }
         Ok(ScopedFileLock { file })
     }
@@ -49,7 +48,7 @@ impl<'a> AsMut<File> for ScopedFileLock<'a> {
 
 impl<'a> Drop for ScopedFileLock<'a> {
     fn drop(&mut self) {
-        self.file.unlock().expect("unlock");
+        fs2::FileExt::unlock(self.file).expect("unlock");
     }
 }
 
@@ -241,10 +240,10 @@ fn lock_file(file: &File, exclusive: bool, non_blocking: bool) -> io::Result<()>
     }
     #[cfg(not(windows))]
     match (exclusive, non_blocking) {
-        (true, false) => file.lock_exclusive()?,
-        (true, true) => file.try_lock_exclusive()?,
-        (false, false) => file.lock_shared()?,
-        (false, true) => file.try_lock_shared()?,
+        (true, false) => fs2::FileExt::lock_exclusive(file)?,
+        (true, true) => fs2::FileExt::try_lock_exclusive(file)?,
+        (false, false) => fs2::FileExt::lock_shared(file)?,
+        (false, true) => fs2::FileExt::try_lock_shared(file)?,
     }
     Ok(())
 }
@@ -264,7 +263,7 @@ fn unlock_file(file: &File) -> io::Result<()> {
     }
     #[cfg(not(windows))]
     {
-        file.unlock()?;
+        fs2::FileExt::unlock(file)?;
     }
     Ok(())
 }

eden/scm/lib/indexedlog/src/log/repair.rs

@@ -106,7 +106,7 @@ impl OpenOptions {
                     Ok(meta) => {
                         // If metadata can be read, trust it.
                         if meta.primary_len > primary_len {
-                            use fs2::FileExt;
+                            use fs2::FileExt as _;
                             // Log was truncated for some reason...
                             // (This should be relatively rare)
                             // Fill Log with 0s.

eden/scm/lib/repolock/src/lib.rs

@@ -25,7 +25,6 @@ use std::time::Instant;
 
 use configmodel::Config;
 use configmodel::ConfigExt;
-use fs2::FileExt;
 use parking_lot::Mutex;
 use progress_model::ProgressBar;
 use sysutil::hostname;
@@ -438,8 +437,8 @@ pub fn try_lock(dir: &Path, name: &str, contents: &[u8]) -> Result<LockHandle, L
     #[cfg(unix)]
     let _ = lock_file.set_permissions(Permissions::from_mode(0o666));
 
-    match lock_file.try_lock_exclusive() {
-        Ok(_) => {}
+    match fs2::FileExt::try_lock_exclusive(&lock_file) {
+        Ok(()) => {}
         Err(err) if err.kind() == fs2::lock_contended_error().kind() => {
             let contents = fs_err::read(&lock_paths.data)?;
             return Err(LockContendedError {
@@ -493,9 +492,7 @@ pub struct LockHandle {
 impl LockHandle {
     pub fn unlock(&mut self) -> io::Result<()> {
         self.unlink_legacy();
-        self.lock
-            .unlock()
-            .path_context("error unlocking lock file", &self.path)
+        fs2::FileExt::unlock(&self.lock).path_context("error unlocking lock file", &self.path)
     }
 
     fn unlink_legacy(&mut self) {

eden/scm/lib/runlog/src/filestore.rs

@@ -15,7 +15,6 @@ use std::time::SystemTime;
 
 use anyhow::Error;
 use anyhow::Result;
-use fs2::FileExt;
 use util::lock::PathLock;
 use util::path::create_shared_dir;
 
@@ -168,7 +167,7 @@ fn remove_file_ignore_missing<P: AsRef<Path>>(path: P) -> io::Result<()> {
 // locked (by running command). Return false if lock file doesn't exist.
 fn is_locked<P: AsRef<Path>>(path: P) -> Result<bool> {
     match fs::File::open(path.as_ref().with_extension(LOCK_EXT)) {
-        Ok(f) => Ok(f.try_lock_shared().is_err()),
+        Ok(f) => Ok(fs2::FileExt::try_lock_shared(&f).is_err()),
         Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
         Err(err) => Err(Error::new(err)),
     }

eden/scm/lib/treestate/src/filereadwrite.rs

@@ -15,8 +15,6 @@ use std::io::SeekFrom;
 use std::io::Write;
 use std::path::Path;
 
-use fs2::FileExt; // fs2 requires StdFile
-
 pub trait FileSync {
     fn sync_all(&mut self) -> io::Result<()>;
 }
@@ -111,8 +109,8 @@ impl FileLock for FileReaderWriter {
     fn lock_exclusive(&mut self) -> io::Result<()> {
         if self.locked == 0 {
             match self.lock_file.as_mut() {
-                Some(file) => file.lock_exclusive()?,
-                None => self.writer.get_mut().lock_exclusive()?,
+                Some(file) => fs2::FileExt::lock_exclusive(file)?,
+                None => fs2::FileExt::lock_exclusive(self.writer.get_mut())?,
             }
         }
         self.locked += 1;
@@ -122,8 +120,8 @@ impl FileLock for FileReaderWriter {
     fn unlock(&mut self) -> io::Result<()> {
         if self.locked == 1 {
             match self.lock_file.as_mut() {
-                Some(file) => file.unlock()?,
-                None => self.writer.get_mut().unlock()?,
+                Some(file) => fs2::FileExt::unlock(file)?,
+                None => fs2::FileExt::unlock(self.writer.get_mut())?,
             }
         }
         if self.locked > 0 {
@@ -195,15 +193,15 @@ impl FileSync for MemReaderWriter {
 impl FileLock for MemReaderWriter {
     fn lock_exclusive(&mut self) -> io::Result<()> {
         if self.locked == 0 {
-            self.lock_file.lock_exclusive()?;
+            fs2::FileExt::lock_exclusive(&self.lock_file)?;
         }
         self.locked += 1;
         Ok(())
     }
 
     fn unlock(&mut self) -> io::Result<()> {
         if self.locked == 1 {
-            self.lock_file.unlock()?;
+            fs2::FileExt::unlock(&self.lock_file)?;
         }
         if self.locked > 0 {
             self.locked -= 1;

eden/scm/lib/util/src/lock.rs

@@ -9,8 +9,6 @@ use std::fs::File;
 use std::io;
 use std::path::Path;
 
-use fs2::FileExt;
-
 use crate::errors::IOContext;
 use crate::file::open;
 
@@ -25,8 +23,7 @@ impl PathLock {
     /// demand.
     pub fn exclusive<P: AsRef<Path>>(path: P) -> io::Result<Self> {
         let file = open(path.as_ref(), "wc").io_context("lock file")?;
-        file.lock_exclusive()
-            .path_context("error locking file", path.as_ref())?;
+        fs2::FileExt::lock_exclusive(&file).path_context("error locking file", path.as_ref())?;
         Ok(PathLock { file })
     }
 
@@ -37,7 +34,7 @@ impl PathLock {
 
 impl Drop for PathLock {
     fn drop(&mut self) {
-        self.file.unlock().expect("unlock");
+        fs2::FileExt::unlock(&self.file).expect("unlock");
     }
 }