Skip to content

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.

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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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(&params)),
"workspace/workspaceFolders" => Ok(mgr.workspace_folders(&self.server)),
"client/registerCapability" => {
- self.registration(&params, true);
+ self.registration(&mgr, &params, true);
Ok(Value::Null)
}
"client/unregisterCapability" => {
- self.registration(&params, false);
+ self.registration(&mgr, &params, 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.rs
index 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.rs
index 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.rs
index 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())]);