From b46a4b56808f7c3521250bef6ee9e4f4389b6973 Mon Sep 17 00:00:00 2001
From: Kirill Bulatov <kirill@zed.dev>
Date: Mon, 30 Oct 2023 12:07:11 +0200
Subject: [PATCH] Be more lenient when searching for prettier instance

Do not check FS for existence (we'll error when start running prettier),
simplify the code for looking it up
---
 crates/prettier/src/prettier.rs | 62 ++++++---------------------------
 1 file changed, 10 insertions(+), 52 deletions(-)

diff --git a/crates/prettier/src/prettier.rs b/crates/prettier/src/prettier.rs
index 6784dba7dc..7517b4ee43 100644
--- a/crates/prettier/src/prettier.rs
+++ b/crates/prettier/src/prettier.rs
@@ -67,80 +67,38 @@ impl Prettier {
         starting_path: Option<LocateStart>,
         fs: Arc<dyn Fs>,
     ) -> anyhow::Result<PathBuf> {
+        fn is_node_modules(path_component: &std::path::Component<'_>) -> bool {
+            path_component.as_os_str().to_string_lossy() == "node_modules"
+        }
+
         let paths_to_check = match starting_path.as_ref() {
             Some(starting_path) => {
                 let worktree_root = starting_path
                     .worktree_root_path
                     .components()
                     .into_iter()
-                    .take_while(|path_component| {
-                        path_component.as_os_str().to_string_lossy() != "node_modules"
-                    })
+                    .take_while(|path_component| !is_node_modules(path_component))
                     .collect::<PathBuf>();
-
                 if worktree_root != starting_path.worktree_root_path.as_ref() {
                     vec![worktree_root]
                 } else {
-                    let worktree_root_metadata = fs
-                        .metadata(&worktree_root)
-                        .await
-                        .with_context(|| {
-                            format!("FS metadata fetch for worktree root path {worktree_root:?}",)
-                        })?
-                        .with_context(|| {
-                            format!("empty FS metadata for worktree root at {worktree_root:?}")
-                        })?;
                     if starting_path.starting_path.as_ref() == Path::new("") {
-                        anyhow::ensure!(
-                            !worktree_root_metadata.is_dir,
-                            "For empty start path, worktree root should not be a directory {starting_path:?}"
-                        );
-                        anyhow::ensure!(
-                            !worktree_root_metadata.is_symlink,
-                            "For empty start path, worktree root should not be a symlink {starting_path:?}"
-                        );
                         worktree_root
                             .parent()
                             .map(|path| vec![path.to_path_buf()])
                             .unwrap_or_default()
                     } else {
-                        let full_starting_path = worktree_root.join(&starting_path.starting_path);
-                        let start_path_metadata = fs
-                            .metadata(&full_starting_path)
-                            .await
-                            .with_context(|| {
-                                format!(
-                                    "FS metadata fetch for starting path {full_starting_path:?}"
-                                )
-                            })?
-                            .with_context(|| {
-                                format!(
-                                    "empty FS metadata for starting path {full_starting_path:?}"
-                                )
-                            })?;
-
-                        anyhow::ensure!(worktree_root_metadata.is_dir,
-                            "For non-empty start path, worktree root {starting_path:?} should be a directory");
-                        anyhow::ensure!(
-                            !start_path_metadata.is_dir,
-                            "For non-empty start path, it should not be a directory {starting_path:?}"
-                        );
-                        anyhow::ensure!(
-                            !start_path_metadata.is_symlink,
-                            "For non-empty start path, it should not be a symlink {starting_path:?}"
-                        );
-
                         let file_to_format = starting_path.starting_path.as_ref();
-                        let mut paths_to_check = VecDeque::from(vec![worktree_root.clone()]);
+                        let mut paths_to_check = VecDeque::new();
                         let mut current_path = worktree_root;
                         for path_component in file_to_format.components().into_iter() {
-                            current_path = current_path.join(path_component);
-                            paths_to_check.push_front(current_path.clone());
-                            if path_component.as_os_str().to_string_lossy() == "node_modules" {
+                            let new_path = current_path.join(path_component);
+                            let old_path = std::mem::replace(&mut current_path, new_path);
+                            paths_to_check.push_front(old_path);
+                            if is_node_modules(&path_component) {
                                 break;
                             }
                         }
-                        paths_to_check.pop_front(); // last one is the file itself or node_modules, skip it
                         Vec::from(paths_to_check)
                     }
                 }