The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(plugins): list project files from the index instead of walking the disk (#1604)
l0ng-ai4002eaa8e9bf
diff --git a/crates/ide-host/src/plugins/api.rs b/crates/ide-host/src/plugins/api.rsindex 7c3d2b45a..ad05517be 100644--- a/crates/ide-host/src/plugins/api.rs+++ b/crates/ide-host/src/plugins/api.rs@@ -30,6 +30,11 @@ pub trait PluginWorkspace: Send + Sync {fn projects(&self) -> Vec<PathBuf>;/// Unsaved text of the open document at `path`.fn buffer_text(&self, path: &Path) -> Option<String>;+ /// Up to `limit` files of the project index below `root` whose root-relative path satisfies+ /// `matches`; `None` when no index covers `root` yet (the caller walks the disk instead).+ fn indexed_files(&self, _root: &Path, _matches: &dyn Fn(&Path) -> bool, _limit: usize) -> Option<Vec<PathBuf>> {+ None+ }/// Version and text of the open document at `path`.fn document(&self, path: &Path) -> Option<(u64, String)>;/// Applies `edits` to the open document at `path` if it is still at@@ -459,6 +464,19 @@ impl HostApi for PluginApi {.build().map_err(|e| HostError::Invalid(format!("{glob:?}: {e}")))?.compile_matcher();+ // Hidden files and folders are left out, as in the walk below.+ let visible = |rel: &Path| !rel.iter().any(|c| c.to_str().is_some_and(|c| c.starts_with('.')));+ // The project index already lists the files: walking a large tree on every call can take+ // longer than an editor provider's deadline (the plugin is then stopped as crashed).+ if let Some(files) = self+ .shared+ .workspace()+ .and_then(|w| w.indexed_files(root, &|rel| visible(rel) && matcher.is_match(rel), limit))+ {+ let mut out: Vec<String> = files.iter().map(|p| to_ipc(p)).collect();+ out.sort();+ return Ok(out);+ }let mut out = Vec::new();for (n, entry) in ignore::WalkBuilder::new(root).hidden(true).build().flatten().enumerate() {if n >= MAX_WALK || out.len() >= limit {@@ -738,6 +756,12 @@ impl PluginWorkspace for HostWorkspace {HostWorkspace::projects(self).iter().find_map(|p| p.documents.text_of(path))}+ fn indexed_files(&self, root: &Path, matches: &dyn Fn(&Path) -> bool, limit: usize) -> Option<Vec<PathBuf>> {+ // The index of the project rooted at `root` (a workspace member's files are in its own).+ let project = HostWorkspace::projects(self).into_iter().find(|p| p.root == root)?;+ project.index.files_matching(root, matches, limit)+ }+fn document(&self, path: &Path) -> Option<(u64, String)> {let (project, doc) = self.open_document(path)?;let snap = project.documents.snapshot(doc).ok()?;@@ -821,6 +845,60 @@ mod tests {assert_eq!(api.vcs_status(&root).unwrap().unwrap().root, to_ipc(&root));}+ /// A project index that lists `files` (root-relative), whatever is on disk.+ struct Indexed(PathBuf, Vec<&'static str>);+ impl PluginWorkspace for Indexed {+ fn projects(&self) -> Vec<PathBuf> {+ vec![self.0.clone()]+ }+ fn buffer_text(&self, _: &Path) -> Option<String> {+ None+ }+ fn document(&self, _: &Path) -> Option<(u64, String)> {+ None+ }+ fn apply_edits(&self, _: &Path, _: u64, _: &[TextEdit]) -> Result<u64, HostError> {+ Err(HostError::Stale)+ }+ fn trusted(&self, _: &Path) -> bool {+ true+ }+ fn project_of(&self, _: &str) -> Option<PathBuf> {+ None+ }+ fn publish_diagnostics(&self, _: &str, _: &Path, _: Vec<ide_core::Diagnostic>) -> Result<(), HostError> {+ Ok(())+ }+ fn indexed_files(&self, root: &Path, matches: &dyn Fn(&Path) -> bool, limit: usize) -> Option<Vec<PathBuf>> {+ (root == self.0).then(|| {+ self.1.iter().map(Path::new).filter(|rel| matches(rel)).take(limit).map(|rel| root.join(rel)).collect()+ })+ }+ }++ #[test]+ fn find_files_uses_the_project_index_when_there_is_one() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path().canonicalize().unwrap();+ let api = api(&root, Arc::default());+ *api.shared.workspace.write() = Some(Arc::new(Indexed(+ root.clone(),+ vec!["src/b/UserMapper.xml", "src/a/OrderMapper.xml", ".idea/workspace.xml", "pom.xml"],+ )));+ // Listed by the index, not walked: none of these exist on disk.+ assert_eq!(+ api.find_files(&root, "**/*Mapper.xml", 10).unwrap(),+ [to_ipc(&root.join("src/a/OrderMapper.xml")), to_ipc(&root.join("src/b/UserMapper.xml"))]+ );+ assert_eq!(api.find_files(&root, "**/*.xml", 10).unwrap().len(), 3, "hidden folders are left out");+ assert_eq!(api.find_files(&root, "**/*.xml", 1).unwrap().len(), 1);+ // Another root: no index covers it, so the disk is walked.+ let other = root.join("other");+ std::fs::create_dir_all(&other).unwrap();+ std::fs::write(other.join("a.xml"), "").unwrap();+ assert_eq!(api.find_files(&other, "*.xml", 10).unwrap(), [to_ipc(&other.join("a.xml"))]);+ }+#[test]fn programs_run_only_as_approved() {let tmp = tempfile::tempdir().unwrap();diff --git a/crates/ide-host/tests/unity.rs b/crates/ide-host/tests/unity.rsindex f38fdbdd7..148d0f407 100644--- a/crates/ide-host/tests/unity.rs+++ b/crates/ide-host/tests/unity.rs@@ -35,6 +35,8 @@ async fn opens_unity_without_generated_solutions_and_excludes_caches_from_the_inassert!(unity.projects.is_empty() && unity.solutions.is_empty());assert!(project.index.wait_idle(Duration::from_secs(20)));assert_eq!(project.index.find_files("Player.cs", 100).len(), 1);+ let listed = project.index.files_matching(&project.root, |rel| rel.ends_with("Player.cs"), 10).unwrap();+ assert_eq!(listed.len(), 1);for name in ["Cached.cs", "Temporary.cs", "Editor.log"] {assert!(project.index.find_files(name, 100).is_empty(), "indexed generated file {name}");}diff --git a/crates/ide-index/src/lib.rs b/crates/ide-index/src/lib.rsindex 711373fe4..be02babc2 100644--- a/crates/ide-index/src/lib.rs+++ b/crates/ide-index/src/lib.rs@@ -197,6 +197,28 @@ impl ProjectIndex {matching::find_files(&d, &matching::Recents { paths: &recent }, query, limit)}+ /// Up to `limit` indexed files below `dir` (VCS-ignored ones left out) whose path relative to+ /// `dir` satisfies `matches`: a file list without walking the disk. `None` while nothing is+ /// indexed yet (first scan without a cache).+ pub fn files_matching(&self, dir: &Path, matches: impl Fn(&Path) -> bool, limit: usize) -> Option<Vec<PathBuf>> {+ let d = self.shared.data.read();+ if d.file_count == 0 {+ return None;+ }+ let mut out = Vec::new();+ for file in d.files.iter().flatten().filter(|f| !f.ignored) {+ if out.len() >= limit {+ break;+ }+ if let Ok(rel) = file.path.strip_prefix(dir)+ && matches(rel)+ {+ out.push(file.path.clone());+ }+ }+ Some(out)+ }+/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {matching::find_dirs(&self.shared.data.read(), query, limit)