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(lsp): let language servers register the files they watch (#1223)
l0ng-ai2cd16a723def
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex e63e8db8b..e45d346a0 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -56,6 +56,9 @@ pub struct Project {pub(crate) watcher: Watcher,/// Watchers of the Project Structure content roots outside the project folder.pub(crate) content_watchers: Mutex<Vec<(PathBuf, Watcher)>>,+ /// Watchers of folders outside the project that language servers registered file+ /// watchers for (a virtualenv elsewhere, a path dependency).+ lsp_watchers: Mutex<Vec<(PathBuf, Watcher)>>,pub(crate) _scratch_watcher: Option<Watcher>,/// A LightEdit window's loose files ([`Host::open_light`]): global settings only,/// nothing indexed, no language servers, repositories or project services.@@ -305,7 +308,7 @@ impl Host {index.update(&changed, &batch.removed);kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));lsp.project_files_changed(batch.created.iter().chain(&batch.removed));- lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed);+ lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);// Atomic saves by external tools surface as `created`.documents.on_disk_changed(&changed);// A framework's root marker (`angular.json`) created or deleted: its@@ -458,6 +461,7 @@ impl Host {kotlin_bridge: Some(kotlin_bridge),watcher,content_watchers: Mutex::new(content_watchers),+ lsp_watchers: Mutex::new(Vec::new()),_scratch_watcher: scratch_watcher,light: false,});@@ -467,6 +471,14 @@ impl Host {weak.upgrade().map(|p| p.reference_candidates(q, cancel)).unwrap_or_default()}));}+ {+ let weak = Arc::downgrade(&project);+ project.lsp.set_file_watch_roots_hook(Box::new(move |roots| {+ if let Some(p) = weak.upgrade() {+ p.watch_for_language_servers(roots);+ }+ }));+ }{let weak = Arc::downgrade(&project);project.lsp.set_project_excludes_hook(Box::new(move || {@@ -582,6 +594,7 @@ impl Host {kotlin_bridge: None,watcher,content_watchers: Mutex::new(Vec::new()),+ lsp_watchers: Mutex::new(Vec::new()),_scratch_watcher: None,light: true,root: dir,@@ -991,6 +1004,30 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac/// Watches a content root outside the project: the index, open documents and/// Local History follow its changes like the project folder's.+impl Project {+ /// Watches `roots` (outside the project) for the language servers that asked to.+ fn watch_for_language_servers(&self, roots: Vec<PathBuf>) {+ let mut watchers = self.lsp_watchers.lock();+ watchers.retain(|(r, _)| roots.contains(r));+ for root in roots {+ if watchers.iter().any(|(r, _)| *r == root) || !root.is_dir() {+ continue;+ }+ let lsp = Arc::downgrade(&self.lsp);+ let on_change = Box::new(move |batch: &ide_vfs::FsBatch| {+ if let Some(lsp) = lsp.upgrade() {+ lsp.watched_files_changed(&batch.created, &batch.modified, &batch.removed, &batch.excluded_dirs);+ }+ });+ // Not project files: nothing else hears of them.+ match Watcher::start(&root, Vec::new(), Arc::new(ide_core::NullSink), on_change) {+ Ok(w) => watchers.push((root, w)),+ Err(e) => tracing::warn!("language server watcher {}: {e}", root.display()),+ }+ }+ }+}+fn content_root_watcher(dir: &Path,excludes: &[String],diff --git a/crates/ide-lsp/src/caps.rs b/crates/ide-lsp/src/caps.rsindex a20296ef6..550736c6e 100644--- a/crates/ide-lsp/src/caps.rs+++ b/crates/ide-lsp/src/caps.rs@@ -37,7 +37,7 @@ pub fn client_capabilities() -> Value {"fileOperations": { "dynamicRegistration": true, "willRename": true, "didRename": true },"configuration": true,"didChangeConfiguration": { "dynamicRegistration": false },- "didChangeWatchedFiles": { "dynamicRegistration": false, "relativePatternSupport": false },+ "didChangeWatchedFiles": { "dynamicRegistration": true, "relativePatternSupport": true },"symbol": {"dynamicRegistration": false,"symbolKind": { "valueSet": symbol_kinds },diff --git a/crates/ide-lsp/src/file_watch.rs b/crates/ide-lsp/src/file_watch.rsnew file mode 100644index 000000000..6ec5290ef--- /dev/null+++ b/crates/ide-lsp/src/file_watch.rs@@ -0,0 +1,150 @@+//! `workspace/didChangeWatchedFiles` registrations: which changes on disk a+//! server asked to hear of (its globs, relative patterns and change kinds).++use crate::uri;+use globset::{GlobBuilder, GlobMatcher};+use serde_json::Value;+use std::collections::BTreeMap;+use std::path::{Path, PathBuf};++/// `FileChangeType`.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Change {+ Created = 1,+ Changed = 2,+ Deleted = 3,+}++impl Change {+ /// The `WatchKind` bit.+ fn kind_bit(self) -> u64 {+ match self {+ Self::Created => 1,+ Self::Changed => 2,+ Self::Deleted => 4,+ }+ }+}++struct Watcher {+ /// Relative pattern's base; `None` for a plain glob, matched below the server's root.+ base: Option<PathBuf>,+ /// A plain glob that is an absolute path pattern.+ absolute: bool,+ glob: GlobMatcher,+ kind: u64,+}++/// A server's registrations, by registration id.+#[derive(Default)]+pub struct FileWatchers(BTreeMap<String, Vec<Watcher>>);++impl FileWatchers {+ pub fn register(&mut self, id: &str, options: Option<&Value>) {+ let watchers = options+ .and_then(|o| o.get("watchers"))+ .and_then(Value::as_array)+ .into_iter()+ .flatten()+ .filter_map(parse)+ .collect();+ self.0.insert(id.to_owned(), watchers);+ }++ pub fn unregister(&mut self, id: &str) {+ self.0.remove(id);+ }++ pub fn is_empty(&self) -> bool {+ self.0.is_empty()+ }++ /// Whether a server rooted at `root` wants to hear of `change` to `path`.+ pub fn wants(&self, root: &Path, path: &Path, change: Change) -> bool {+ self.0.values().flatten().any(|w| {+ if w.kind & change.kind_bit() == 0 {+ return false;+ }+ match &w.base {+ Some(base) => path.strip_prefix(base).is_ok_and(|rel| w.glob.is_match(rel)),+ None if w.absolute => w.glob.is_match(path),+ None => path.strip_prefix(root).is_ok_and(|rel| w.glob.is_match(rel)),+ }+ })+ }++ /// Bases of relative patterns, which may lie outside the project (a virtualenv's+ /// `site-packages`, a path dependency): the client watches them for the server.+ pub fn bases(&self) -> impl Iterator<Item = &Path> {+ self.0.values().flatten().filter_map(|w| w.base.as_deref())+ }+}++fn parse(watcher: &Value) -> Option<Watcher> {+ let kind = watcher.get("kind").and_then(Value::as_u64).unwrap_or(7);+ let (base, pattern) = match watcher.get("globPattern")? {+ Value::String(p) => (None, p.as_str()),+ relative => {+ let base = relative.get("baseUri")?;+ // A `WorkspaceFolder` or a URI.+ let base = base.get("uri").unwrap_or(base).as_str()?;+ let base = uri::uri_to_path(base)?;+ // Changes are reported for canonical paths (`/tmp` is `/private/tmp` on macOS).+ (Some(dunce::canonicalize(&base).unwrap_or(base)), relative.get("pattern")?.as_str()?)+ }+ };+ let glob = GlobBuilder::new(pattern).literal_separator(true).build().ok()?.compile_matcher();+ let absolute = base.is_none() && Path::new(pattern).is_absolute();+ Some(Watcher { base, absolute, glob, kind })+}++#[cfg(test)]+mod tests {+ use super::*;+ use serde_json::json;++ fn watchers(list: Value) -> FileWatchers {+ let mut w = FileWatchers::default();+ w.register("1", Some(&json!({ "watchers": list })));+ w+ }++ #[test]+ fn matches_globs_relative_patterns_and_kinds() {+ let root = Path::new("/p");+ let venv = uri::path_to_uri(Path::new("/opt/venv/lib/site-packages"));+ let w = watchers(json!([+ { "globPattern": "**/*.{go,mod,sum}" },+ { "globPattern": "**/pyrightconfig.json", "kind": 2 },+ { "globPattern": { "baseUri": venv, "pattern": "**" } },+ { "globPattern": { "baseUri": { "uri": uri::path_to_uri(Path::new("/shared")), "name": "s" }, "pattern": "*.toml" } },+ ]));+ let cases = [+ ("/p/go.mod", Change::Changed, true),+ ("/p/sub/main.go", Change::Created, true),+ ("/elsewhere/main.go", Change::Created, false),+ ("/p/pyrightconfig.json", Change::Changed, true),+ ("/p/pyrightconfig.json", Change::Created, false),+ ("/opt/venv/lib/site-packages/idna/__init__.py", Change::Created, true),+ ("/opt/venv/lib/site-packages", Change::Deleted, true),+ ("/shared/Cargo.toml", Change::Changed, true),+ ("/shared/nested/Cargo.toml", Change::Changed, false),+ ("/p/readme.md", Change::Changed, false),+ ];+ for (path, change, expected) in cases {+ assert_eq!(w.wants(root, Path::new(path), change), expected, "{path} {change:?}");+ }+ let mut bases: Vec<_> = w.bases().collect();+ bases.sort();+ assert_eq!(bases, [Path::new("/opt/venv/lib/site-packages"), Path::new("/shared")]);+ }++ #[test]+ fn unregistering_drops_the_watchers() {+ let mut w = watchers(json!([{ "globPattern": "**" }]));+ assert!(w.wants(Path::new("/p"), Path::new("/p/a"), Change::Created));+ w.unregister("1");+ assert!(w.is_empty());+ assert!(!w.wants(Path::new("/p"), Path::new("/p/a"), Change::Created));+ }+}diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rsindex 006e4d090..55130d689 100644--- a/crates/ide-lsp/src/handler.rs+++ b/crates/ide-lsp/src/handler.rs@@ -206,19 +206,33 @@ impl ClientHandler {Ok(reply)}- fn registration(&self, params: &Value, register: bool) {- let Some(run) = self.server.running_gen(self.generation) else { return };+ fn registration(&self, mgr: &LspManager, params: &Value, register: bool) {+ let Some(run) = self.server.initialized_gen(self.generation) else { return };let key = if register { "registrations" } else { "unregisterations" };let list = params.get(key).or_else(|| params.get("unregistrations")).and_then(Value::as_array);let mut caps = run.caps.write();+ let mut watchers_changed = false;for reg in list.into_iter().flatten() {let Some(method) = reg.get("method").and_then(Value::as_str) else { continue };- if register {+ if method == "workspace/didChangeWatchedFiles" {+ let id = reg.get("id").and_then(Value::as_str).unwrap_or_default();+ let mut watchers = run.watchers.write();+ if register {+ watchers.register(id, reg.get("registerOptions"));+ } else {+ watchers.unregister(id);+ }+ watchers_changed = true;+ } else if register {caps.register(method, reg.get("registerOptions"));} else {caps.unregister(method);}}+ drop(caps);+ if watchers_changed {+ mgr.file_watch_roots_changed();+ }}}@@ -278,11 +292,11 @@ impl Handler for ClientHandler {"workspace/configuration" => Ok(self.configuration(¶ms)),"workspace/workspaceFolders" => Ok(mgr.workspace_folders(&self.server)),"client/registerCapability" => {- self.registration(¶ms, true);+ self.registration(&mgr, ¶ms, true);Ok(Value::Null)}"client/unregisterCapability" => {- self.registration(¶ms, false);+ self.registration(&mgr, ¶ms, false);Ok(Value::Null)}"workspace/applyEdit" => self.apply_edit(&mgr, params),diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex 252b66bf3..40665fc34 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -12,6 +12,7 @@ mod clang_tidy;mod convert;mod external_project;mod file_ops;+mod file_watch;mod handler;mod inspect;pub mod jdtls;@@ -160,6 +161,9 @@ impl DocSnap {}}+/// Receives the folders outside the project that servers want watched.+pub type WatchRootsFn = dyn Fn(Vec<PathBuf>) + Send + Sync;+pub struct LspManager {me: Weak<LspManager>,project_root: PathBuf,@@ -177,6 +181,7 @@ pub struct LspManager {servers_hook: RwLock<Option<Arc<ServersFn>>>,candidates_hook: RwLock<Option<Arc<CandidateFn>>>,excludes_hook: RwLock<Option<Arc<external_project::ExcludesFn>>>,+ watch_roots_hook: RwLock<Option<Arc<WatchRootsFn>>>,shutting_down: AtomicBool,execution_allowed: AtomicBool,java_usages_warned: AtomicBool,@@ -336,6 +341,7 @@ impl LspManager {servers_hook: RwLock::new(None),candidates_hook: RwLock::new(None),excludes_hook: RwLock::new(None),+ watch_roots_hook: RwLock::new(None),shutting_down: AtomicBool::new(false),execution_allowed: AtomicBool::new(true),java_usages_warned: AtomicBool::new(false),@@ -587,6 +593,9 @@ impl LspManager {return;}};+ let run =+ Running { generation, peer: peer.clone(), caps: Arc::new(RwLock::new(caps)), watchers: Default::default() };+ server.set_initializing(Some(run.clone()));if let Err(e) = peer.notify("initialized", json!({})) {tracing::warn!("{}: {e}", server.name);}@@ -598,7 +607,6 @@ impl LspManager {{tracing::debug!("{}: didChangeConfiguration: {e}", server.name);}- let run = Running { generation, peer: peer.clone(), caps: Arc::new(RwLock::new(caps)) };self.refresh_external_project(&server, &run).await;@@ -607,6 +615,7 @@ impl LspManager {let mut docs = self.docs.lock();if !server.mark_ready(generation, run.clone()) {drop(docs);+ server.set_initializing(None);peer.kill();return;}@@ -644,6 +653,7 @@ impl LspManager {None => return, // superseded instance};self.clear_server_state(&server);+ self.file_watch_roots_changed();if intentional {server.announce_down();return;@@ -1973,29 +1983,78 @@ impl LspManager {}}- /// Files that changed on disk, outside the editor too (a checkout, another tool): each running- /// server hears of those of its languages under its root through `workspace/didChangeWatchedFiles`.- /// Without it jdtls's incremental build never sees them, so a launch runs stale classes.- pub fn watched_files_changed(&self, created: &[PathBuf], modified: &[PathBuf], removed: &[PathBuf]) {+ /// Files that changed on disk, outside the editor too (a checkout, another tool), sent to+ /// running servers through `workspace/didChangeWatchedFiles`. A server that registered file+ /// watchers hears of what they match, including `excluded_dirs` (folders in excluded or+ /// ignored trees whose entries came or went, reported as created): a package installed+ /// into `.venv` or a `go.mod` rewritten by `go get` is picked up without a restart. Other+ /// servers hear of their languages' files under their root; without it jdtls's incremental+ /// build never sees them, so a launch runs stale classes.+ pub fn watched_files_changed(+ &self,+ created: &[PathBuf],+ modified: &[PathBuf],+ removed: &[PathBuf],+ excluded_dirs: &[PathBuf],+ ) {+ use file_watch::Change;let servers: Vec<Arc<Server>> = self.servers.lock().clone();for s in servers {let Some(run) = s.running() else { continue };- let languages = s.languages();- let changes: Vec<Value> = [(created, 1), (modified, 2), (removed, 3)]+ let all = [(created, Change::Created), (modified, Change::Changed), (removed, Change::Deleted)].into_iter()- .flat_map(|(paths, kind)| paths.iter().map(move |p| (p, kind)))- .filter(|(p, _)| p.starts_with(&s.root) && languages.contains(&self.languages.detect(p, None)))- .map(|(p, kind)| json!({ "uri": uri::path_to_uri(p), "type": kind }))- .collect();+ .flat_map(|(paths, change)| paths.iter().map(move |p| (p, change)));+ let watchers = run.watchers.read();+ let changes: Vec<(&PathBuf, Change)> = if watchers.is_empty() {+ let languages = s.languages();+ all.filter(|(p, _)| p.starts_with(&s.root) && languages.contains(&self.languages.detect(p, None)))+ .collect()+ } else {+ all.chain(excluded_dirs.iter().map(|p| (p, Change::Created)))+ .filter(|(p, change)| watchers.wants(&s.root, p, *change))+ .collect()+ };+ drop(watchers);if changes.is_empty() {continue;}+ let changes: Vec<Value> =+ changes.iter().map(|(p, c)| json!({ "uri": uri::path_to_uri(p), "type": *c as u8 })).collect();if let Err(e) = run.peer.notify("workspace/didChangeWatchedFiles", json!({ "changes": changes })) {tracing::debug!("{}: didChangeWatchedFiles: {e}", s.name);}}}+ /// Called with the folders outside the project that servers registered file watchers+ /// for (a virtualenv elsewhere, a path dependency), whenever they change. Changes+ /// below them go to [`Self::watched_files_changed`].+ pub fn set_file_watch_roots_hook(&self, hook: Box<WatchRootsFn>) {+ *self.watch_roots_hook.write() = Some(Arc::from(hook));+ self.file_watch_roots_changed();+ }++ pub(crate) fn file_watch_roots_changed(&self) {+ let Some(hook) = self.watch_roots_hook.read().clone() else { return };+ let servers: Vec<Arc<Server>> = self.servers.lock().clone();+ let mut roots: Vec<PathBuf> = Vec::new();+ for run in servers.iter().filter_map(|s| s.instance()) {+ roots.extend(+ run.watchers.read().bases().filter(|b| !b.starts_with(&self.project_root)).map(Path::to_path_buf),+ );+ }+ roots.sort();+ roots.dedup();+ // Sorted, so a folder's subfolders follow it.+ let mut outer: Vec<PathBuf> = Vec::new();+ for r in roots {+ if !outer.last().is_some_and(|o| r.starts_with(o)) {+ outer.push(r);+ }+ }+ hook(outer);+ }+/// Checks initialized capabilities, including dynamic registrations, before choosing a formatter.pub async fn can_format(&self, doc: DocId) -> IdeResult<bool> {let snap = self.snapshot(doc)?;diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rsindex f15a893e6..76f08cc67 100644--- a/crates/ide-lsp/src/server.rs+++ b/crates/ide-lsp/src/server.rs@@ -27,6 +27,8 @@ pub struct Running {pub generation: u64,pub peer: Peer,pub caps: Arc<RwLock<ServerCaps>>,+ /// `workspace/didChangeWatchedFiles` registrations.+ pub watchers: Arc<RwLock<crate::file_watch::FileWatchers>>,}pub enum Conn {@@ -82,6 +84,9 @@ pub struct Server {pub resolved_binary: RwLock<Option<PathBuf>>,languages: Mutex<Vec<LanguageId>>,state: Mutex<State>,+ /// The instance being initialized, from `initialized` until ready: registrations+ /// sent right after `initialized` must not be lost.+ initializing: Mutex<Option<Running>>,/// Fired when the instance being started is abandoned (stop / restart while starting).start_cancel: Mutex<CancellationToken>,phase: watch::Sender<Phase>,@@ -118,6 +123,7 @@ impl Server {resolved_binary: RwLock::new(None),languages: Mutex::new(vec![language]),state: Mutex::new(State { generation: 0, conn: Conn::Idle }),+ initializing: Mutex::new(None),start_cancel: Mutex::new(CancellationToken::new()),phase: watch::channel(Phase::Down).0,status: Mutex::new((ServerStatus::Stopped, None)),@@ -210,6 +216,8 @@ impl Server {return false;}st.conn = Conn::Ready(run);+ drop(st);+ self.set_initializing(None);true}@@ -234,6 +242,20 @@ impl Server {}}+ /// The instance told `initialized`, ready or not.+ pub fn instance(&self) -> Option<Running> {+ self.running().or_else(|| self.initializing.lock().clone())+ }++ /// Generation `generation` once it was told `initialized`, ready or not.+ pub fn initialized_gen(&self, generation: u64) -> Option<Running> {+ self.instance().filter(|r| r.generation == generation)+ }++ pub fn set_initializing(&self, run: Option<Running>) {+ *self.initializing.lock() = run;+ }+/// The running instance if it is still generation `generation`.pub fn running_gen(&self, generation: u64) -> Option<Running> {self.running().filter(|r| r.generation == generation)diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex 485fae03c..324876666 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -419,6 +419,7 @@ async fn files_changed_on_disk_reach_the_servers_of_their_language() {&[created.clone(), other],&[modified.clone(), outside],std::slice::from_ref(&removed),+ &[h.root.join(".venv/lib/site-packages")],);eventually(|| !s.notified("workspace/didChangeWatchedFiles").is_empty()).await;assert_eq!(@@ -430,12 +431,81 @@ async fn files_changed_on_disk_reach_the_servers_of_their_language() {]));// Nothing of its languages: no notification.- h.mgr.watched_files_changed(&[h.root.join("b.txt")], &[], &[]);+ h.mgr.watched_files_changed(&[h.root.join("b.txt")], &[], &[], &[]);tokio::time::sleep(std::time::Duration::from_millis(100)).await;assert_eq!(s.notified("workspace/didChangeWatchedFiles").len(), 1);h.mgr.shutdown_all().await;}+/// A server that registers file watchers hears of what they match, inside excluded folders+/// too (`uv add` into `.venv`, `go get` rewriting `go.mod`); folders outside the project+/// that relative patterns name are reported for watching; unregistered, it falls back to+/// its languages' files.+#[tokio::test(flavor = "multi_thread")]+async fn registered_file_watchers_choose_the_changes_a_server_hears_of() {+ let h = harness(&[("mock", incremental_caps())]);+ let roots = Arc::new(Mutex::new(Vec::<Vec<PathBuf>>::new()));+ {+ let roots = roots.clone();+ h.mgr.set_file_watch_roots_hook(Box::new(move |r| roots.lock().push(r)));+ }+ h.open("a.mk", "x");+ h.wait_status("mock", ServerStatus::Ready).await;+ let s = h.launcher.state("mock");+ let outside = tempfile::tempdir().unwrap();+ let outside = dunce::canonicalize(outside.path()).unwrap();+ let external = outside.join("venv/lib/site-packages");+ s.peer()+ .request::<_, Value>(+ "client/registerCapability",+ json!({ "registrations": [{ "id": "w", "method": "workspace/didChangeWatchedFiles", "registerOptions": { "watchers": [+ { "globPattern": "**/*.{mk,mod}" },+ { "globPattern": "**/pyrightconfig.json", "kind": 2 },+ { "globPattern": "**/site-packages/**" },+ { "globPattern": { "baseUri": uri_of(&external), "pattern": "**" } },+ { "globPattern": { "baseUri": uri_of(&h.root.join("sub")), "pattern": "**" } },+ ] } }] }),+ None,+ )+ .await+ .unwrap();+ assert_eq!(roots.lock().last(), Some(&vec![external.clone()]), "only folders outside the project");++ let sp = h.root.join(".venv/lib/python3.14/site-packages");+ let notified = || s.notified("workspace/didChangeWatchedFiles");+ h.mgr.watched_files_changed(+ &[h.root.join("go.mod"), h.root.join("notes.txt"), h.root.join("pyrightconfig.json")],+ &[h.root.join("pyrightconfig.json"), external.join("idna/core.py")],+ &[h.root.join("old.mk")],+ &[sp.join("idna"), h.root.join("node_modules/x")],+ );+ eventually(|| !notified().is_empty()).await;+ assert_eq!(+ notified()[0]["changes"],+ json!([+ { "uri": uri_of(&h.root.join("go.mod")), "type": 1 },+ { "uri": uri_of(&h.root.join("pyrightconfig.json")), "type": 2 },+ { "uri": uri_of(&external.join("idna/core.py")), "type": 2 },+ { "uri": uri_of(&h.root.join("old.mk")), "type": 3 },+ { "uri": uri_of(&sp.join("idna")), "type": 1 },+ ])+ );++ s.peer()+ .request::<_, Value>(+ "client/unregisterCapability",+ json!({ "unregisterations": [{ "id": "w", "method": "workspace/didChangeWatchedFiles" }] }),+ None,+ )+ .await+ .unwrap();+ assert_eq!(roots.lock().last(), Some(&vec![]));+ h.mgr.watched_files_changed(&[h.root.join("go.mod"), h.root.join("b.mk")], &[], &[], &[sp.join("idna")]);+ eventually(|| notified().len() == 2).await;+ assert_eq!(notified()[1]["changes"], json!([{ "uri": uri_of(&h.root.join("b.mk")), "type": 1 }]));+ h.mgr.shutdown_all().await;+}+#[tokio::test(flavor = "multi_thread")]async fn initialize_and_incremental_sync() {let h = harness(&[("mock", incremental_caps())]);