Revert "fs: Replace a bunch of uses of smol::fs with manual impls" (#40406)

Reverts #40172

Author: osiewicz

Cargo.lock

@@ -222,7 +222,7 @@ members = [
 
     "tooling/perf",
     "tooling/workspace-hack",
-    "tooling/xtask", "crates/fs_benchmarks", "crates/worktree_benchmarks",
+    "tooling/xtask",
 ]
 default-members = ["crates/zed"]
 
@@ -455,7 +455,6 @@ async-compat = "0.2.1"
 async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
 async-dispatcher = "0.1"
 async-fs = "2.1"
-async-lock = "2.1"
 async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "82d00a04211cf4e1236029aa03e6b6ce2a74c553" }
 async-recursion = "1.0.0"
 async-tar = "0.5.0"

Cargo.toml

@@ -12509,7 +12509,6 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut TestAppContext) {
     )
     .await;
 
-    cx.run_until_parked();
     // Set up a buffer white some trailing whitespace and no trailing newline.
     cx.set_state(
         &[

crates/editor/src/editor_tests.rs

@@ -7,7 +7,6 @@ pub mod fs_watcher;
 use anyhow::{Context as _, Result, anyhow};
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
 use ashpd::desktop::trash;
-use futures::stream::iter;
 use gpui::App;
 use gpui::BackgroundExecutor;
 use gpui::Global;
@@ -563,17 +562,12 @@ impl Fs for RealFs {
 
     async fn load(&self, path: &Path) -> Result<String> {
         let path = path.to_path_buf();
-        self.executor
-            .spawn(async move { Ok(std::fs::read_to_string(path)?) })
-            .await
+        let text = smol::unblock(|| std::fs::read_to_string(path)).await?;
+        Ok(text)
     }
-
     async fn load_bytes(&self, path: &Path) -> Result<Vec<u8>> {
         let path = path.to_path_buf();
-        let bytes = self
-            .executor
-            .spawn(async move { std::fs::read(path) })
-            .await?;
+        let bytes = smol::unblock(|| std::fs::read(path)).await?;
         Ok(bytes)
     }
 
@@ -641,46 +635,30 @@ impl Fs for RealFs {
         if let Some(path) = path.parent() {
             self.create_dir(path).await?;
         }
-        let path = path.to_owned();
-        let contents = content.to_owned();
-        self.executor
-            .spawn(async move {
-                std::fs::write(path, contents)?;
-                Ok(())
-            })
-            .await
+        smol::fs::write(path, content).await?;
+        Ok(())
     }
 
     async fn canonicalize(&self, path: &Path) -> Result<PathBuf> {
-        let path = path.to_owned();
-        self.executor
-            .spawn(async move {
-                std::fs::canonicalize(&path).with_context(|| format!("canonicalizing {path:?}"))
-            })
+        Ok(smol::fs::canonicalize(path)
             .await
+            .with_context(|| format!("canonicalizing {path:?}"))?)
     }
 
     async fn is_file(&self, path: &Path) -> bool {
-        let path = path.to_owned();
-        self.executor
-            .spawn(async move { std::fs::metadata(path).is_ok_and(|metadata| metadata.is_file()) })
+        smol::fs::metadata(path)
             .await
+            .is_ok_and(|metadata| metadata.is_file())
     }
 
     async fn is_dir(&self, path: &Path) -> bool {
-        let path = path.to_owned();
-        self.executor
-            .spawn(async move { std::fs::metadata(path).is_ok_and(|metadata| metadata.is_dir()) })
+        smol::fs::metadata(path)
             .await
+            .is_ok_and(|metadata| metadata.is_dir())
     }
 
     async fn metadata(&self, path: &Path) -> Result<Option<Metadata>> {
-        let path_buf = path.to_owned();
-        let symlink_metadata = match self
-            .executor
-            .spawn(async move { std::fs::symlink_metadata(&path_buf) })
-            .await
-        {
+        let symlink_metadata = match smol::fs::symlink_metadata(path).await {
             Ok(metadata) => metadata,
             Err(err) => {
                 return match (err.kind(), err.raw_os_error()) {
@@ -691,28 +669,19 @@ impl Fs for RealFs {
             }
         };
 
+        let path_buf = path.to_path_buf();
+        let path_exists = smol::unblock(move || {
+            path_buf
+                .try_exists()
+                .with_context(|| format!("checking existence for path {path_buf:?}"))
+        })
+        .await?;
         let is_symlink = symlink_metadata.file_type().is_symlink();
-        let metadata = if is_symlink {
-            let path_buf = path.to_path_buf();
-            let path_exists = self
-                .executor
-                .spawn(async move {
-                    path_buf
-                        .try_exists()
-                        .with_context(|| format!("checking existence for path {path_buf:?}"))
-                })
-                .await?;
-            if path_exists {
-                let path_buf = path.to_path_buf();
-                self.executor
-                    .spawn(async move { std::fs::metadata(path_buf) })
-                    .await
-                    .with_context(|| "accessing symlink for path {path}")?
-            } else {
-                symlink_metadata
-            }
-        } else {
-            symlink_metadata
+        let metadata = match (is_symlink, path_exists) {
+            (true, true) => smol::fs::metadata(path)
+                .await
+                .with_context(|| "accessing symlink for path {path}")?,
+            _ => symlink_metadata,
         };
 
         #[cfg(unix)]
@@ -738,25 +707,15 @@ impl Fs for RealFs {
     }
 
     async fn read_link(&self, path: &Path) -> Result<PathBuf> {
-        let path = path.to_owned();
-        let path = self
-            .executor
-            .spawn(async move { std::fs::read_link(&path) })
-            .await?;
+        let path = smol::fs::read_link(path).await?;
         Ok(path)
     }
 
     async fn read_dir(
         &self,
         path: &Path,
     ) -> Result<Pin<Box<dyn Send + Stream<Item = Result<PathBuf>>>>> {
-        let path = path.to_owned();
-        let result = iter(
-            self.executor
-                .spawn(async move { std::fs::read_dir(path) })
-                .await?,
-        )
-        .map(|entry| match entry {
+        let result = smol::fs::read_dir(path).await?.map(|entry| match entry {
             Ok(entry) => Ok(entry.path()),
             Err(error) => Err(anyhow!("failed to read dir entry {error:?}")),
         });

crates/fs/src/fs.rs

@@ -24,7 +24,6 @@ test-support = [
 
 [dependencies]
 anyhow.workspace = true
-async-lock.workspace = true
 clock.workspace = true
 collections.workspace = true
 fs.workspace = true