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

hphp/hack/src/utils/hh_slog/locked_file_drain.rs

@@ -3,7 +3,6 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the "hack" directory of this source tree.
 
-use fs2::FileExt;
 use slog::Drain;
 
 /// Locks the file when logging. Prevents multi-process writes from mangling if
@@ -48,7 +47,7 @@ impl Drain for LockedFileDrain {
         };
 
         // Acquiring exclusive lock
-        while let Err(err) = file.lock_exclusive() {
+        while let Err(err) = fs2::FileExt::lock_exclusive(&file) {
             match err.kind() {
                 // This shouldn't happen often, but if it's just an
                 // interruption, retry.
@@ -69,7 +68,7 @@ impl Drain for LockedFileDrain {
         }
 
         // Releasing lock
-        while let Err(err) = file.unlock() {
+        while let Err(err) = fs2::FileExt::unlock(&file) {
             match err.kind() {
                 std::io::ErrorKind::Interrupted => continue,
                 _ => {

hphp/hack/src/utils/rust/file_rwlock.rs

@@ -155,9 +155,7 @@ impl<T: serde::Serialize + for<'de> serde::Deserialize<'de>> FileRwLock<T> {
             tempfile::NamedTempFile::new_in(parent).path_context(&self.path, "open(O_TMPFILE)")?;
         #[cfg(not(target_os = "linux"))]
         let file = nfile.as_file_mut();
-        use fs2::FileExt;
-        file.lock_exclusive()
-            .path_context(&self.path, "flock(LOCK_EX)")?;
+        fs2::FileExt::lock_exclusive(&file).path_context(&self.path, "flock(LOCK_EX)")?;
 
         // Initialize the file. The file will initially be in "state" provided as a parameter,
         // either present or poisoned, with different behaviors should we crash.
@@ -270,13 +268,10 @@ impl<T: serde::Serialize + for<'de> serde::Deserialize<'de>> FileRwLock<T> {
         };
 
         // Our sequence point will be the moment we acquire the lock.
-        use fs2::FileExt;
         if write {
-            file.lock_exclusive()
-                .path_context(&self.path, "flock(LOCK_EX)")?;
+            fs2::FileExt::lock_exclusive(&file).path_context(&self.path, "flock(LOCK_EX)")?;
         } else {
-            file.lock_shared()
-                .path_context(&self.path, "flock(LOCKS_SH)")?;
+            fs2::FileExt::lock_shared(&file).path_context(&self.path, "flock(LOCKS_SH)")?;
         }
 
         // Now we have the lock, we can examine what we have in hand...
@@ -348,9 +343,7 @@ impl<T: serde::Serialize + for<'de> serde::Deserialize<'de>> FileRwLock<T> {
             Err(e) => Err(e).path_context(&self.path, "open(WR)"),
             Ok(file) => {
                 // Our sequence point will be the moment we acquire the lock.
-                use fs2::FileExt;
-                file.lock_exclusive()
-                    .path_context(&self.path, "flock(LOCK_EX)")?;
+                fs2::FileExt::lock_exclusive(&file).path_context(&self.path, "flock(LOCK_EX)")?;
 
                 // A stopped lockfile is represented by an empty file -- either
                 // empty from the create(true).open() statement above at the start