Fix nested workspaces independent of order, fixes #301

Author: davidhalter

crates/vfs/src/lib.rs

@@ -69,8 +69,6 @@ pub trait VfsHandler: Sync + Send {
         result
     }
 
-    fn split_off_folder<'a>(&self, path: &'a str) -> (&'a str, Option<&'a str>);
-
     fn normalize_path<'s>(&self, path: &'s AbsPath) -> Cow<'s, NormalizedPath> {
         NormalizedPath::normalize(path)
     }
@@ -133,6 +131,40 @@ pub trait VfsHandler: Sync + Send {
     fn path_relative_to(&self, from: &AbsPath, to: &Path) -> Option<String> {
         path_relative_to(from, to, self.separator())
     }
+
+    fn split_off_first_item<'a>(&self, path: &'a str) -> (&'a str, Option<&'a str>) {
+        let mut found = path.find(self.separator());
+        if cfg!(target_os = "windows") {
+            // Windows allows path with mixed separators
+            if let Some(found_slash) = path.find('/')
+                && found.is_none_or(|found| found <= found_slash)
+            {
+                found = Some(found_slash)
+            }
+        }
+        if let Some(pos) = found {
+            (&path[..pos], Some(&path[pos + 1..]))
+        } else {
+            (path, None)
+        }
+    }
+
+    fn split_off_last_item<'a>(&self, path: &'a str) -> (Option<&'a str>, &'a str) {
+        let mut found = path.rfind(self.separator());
+        if cfg!(target_os = "windows") {
+            // Windows allows path with mixed separators
+            if let Some(found_slash) = path.rfind('/')
+                && found.is_none_or(|found| found >= found_slash)
+            {
+                found = Some(found_slash)
+            }
+        }
+        if let Some(pos) = found {
+            (Some(&path[..pos]), &path[pos + 1..])
+        } else {
+            (None, path)
+        }
+    }
 }
 
 fn path_relative_to(from: &AbsPath, to: &Path, separator: char) -> Option<String> {

crates/vfs/src/local_fs.rs

@@ -164,23 +164,6 @@ impl<T: Fn(PathWithScheme) + Sync + Send> VfsHandler for LocalFS<T> {
         self.watcher.as_ref().map(|(_, r)| r)
     }
 
-    fn split_off_folder<'a>(&self, path: &'a str) -> (&'a str, Option<&'a str>) {
-        let mut found = path.find(self.separator());
-        if cfg!(target_os = "windows") {
-            // Windows allows path with mixed separators
-            if let Some(found_slash) = path.find('/')
-                && found.is_none_or(|found| found <= found_slash)
-            {
-                found = Some(found_slash)
-            }
-        }
-        if let Some(pos) = found {
-            (&path[..pos], Some(&path[pos + 1..]))
-        } else {
-            (path, None)
-        }
-    }
-
     fn on_invalidated_in_memory_file(&self, path: PathWithScheme) {
         if let Some(callback) = self.on_invalidated_in_memory_file.as_ref() {
             callback(path)

crates/vfs/src/tree.rs

@@ -324,7 +324,7 @@ impl Entries {
         workspaces: &Workspaces,
         path: &str,
     ) -> Option<DirOrFile> {
-        let (name, rest) = vfs.split_off_folder(path);
+        let (name, rest) = vfs.split_off_first_item(path);
         if let Some(entry) = self.search(name) {
             if let Some(rest) = rest {
                 if let DirectoryEntry::Directory(dir) = &*entry {
@@ -416,7 +416,7 @@ impl Entries {
     }
 
     pub(crate) fn unload_file(&self, vfs: &dyn VfsHandler, path: &str) {
-        let (name, rest) = vfs.split_off_folder(path);
+        let (name, rest) = vfs.split_off_first_item(path);
         if let Some(entry) = self.search(name) {
             if let Some(rest) = rest {
                 if let DirectoryEntry::Directory(dir) = &*entry
@@ -467,7 +467,7 @@ impl Entries {
     }
 
     pub(crate) fn delete_directory(&self, vfs: &dyn VfsHandler, path: &str) -> Result<(), String> {
-        let (name, rest) = vfs.split_off_folder(path);
+        let (name, rest) = vfs.split_off_first_item(path);
         if let Some(inner) = self.search(name) {
             match &*inner {
                 DirectoryEntry::Directory(dir) => {

crates/vfs/src/workspaces.rs

@@ -8,7 +8,7 @@ use utils::{OwnedMappedReadGuard, match_case};
 use crate::{
     AbsPath, DirOrFile, Directory, DirectoryEntry, NormalizedPath, Parent, PathWithScheme,
     VfsHandler,
-    tree::{AddedFile, Entries},
+    tree::{AddedFile, DirEntries, Entries},
     vfs::Scheme,
 };
 
@@ -145,7 +145,7 @@ impl Workspaces {
             let mut rest = rest?;
             let mut current_dir: Option<Arc<Directory>> = None;
             loop {
-                let (name, new_rest) = vfs.split_off_folder(rest);
+                let (name, new_rest) = vfs.split_off_first_item(rest);
                 if let Some(new_rest) = new_rest {
                     // We generally return None in all cases where the nesting of the path is
                     // deeper than the current VFS. This is fine for invalidation, since
@@ -392,6 +392,25 @@ impl Workspace {
             Parent::Workspace(Arc::downgrade(&workspace)),
         );
         *workspace.entries.borrow_mut() = std::mem::take(&mut new_entries.borrow_mut());
+
+        // Workspaces are added as nested workspaces already for workspaces that are contained
+        // within this one. But this workspace could be contained by another one, check for that
+        // here.
+        if !workspaces.is_empty()
+            && let (Some(folder), name) = vfs.split_off_last_item(&workspace.root_path)
+        {
+            for old in workspaces {
+                if ***old.root_path == *folder
+                    && let Some(dir_entry) = old.entries.search(name)
+                    && let DirectoryEntry::Directory(dir) = &*dir_entry
+                {
+                    let result = dir
+                        .entries
+                        .set(DirEntries::NestedWorkspace(Arc::downgrade(&workspace)));
+                    debug_assert!(result.is_ok());
+                }
+            }
+        }
         workspace
     }
 
@@ -442,7 +461,7 @@ fn ensure_dirs_and_file(
     path: &str,
     code: &str,
 ) -> AddedFile {
-    let (name, rest) = vfs.split_off_folder(path);
+    let (name, rest) = vfs.split_off_first_item(path);
     if let Some(rest) = rest {
         let mut invs = Default::default();
         if let Some(x) = entries.search(name) {
@@ -490,8 +509,8 @@ fn strip_path_prefix<'x>(
 ) -> Option<&'x str> {
     let mut to_strip: &str = to_strip;
     loop {
-        let (folder1, rest) = vfs.split_off_folder(path);
-        let (folder2, rest_to_strip) = vfs.split_off_folder(to_strip);
+        let (folder1, rest) = vfs.split_off_first_item(path);
+        let (folder2, rest_to_strip) = vfs.split_off_first_item(to_strip);
         if !match_case(case_sensitive, folder1, folder2) {
             return None;
         }

crates/zmypy/src/lib.rs

@@ -798,7 +798,7 @@ mod tests {
     #[test]
     fn test_read_file_only_once() {
         logging_config::setup_logging_for_tests();
-        for mypy_path in ["['src/inner', 'src']"] {
+        for mypy_path in ["['src/inner', 'src']", "['src', 'src/inner']"] {
             let fixture = format!(
                 r#"
             [file pyproject.toml]