From cb593458e1d6ed998709ac5257cb48ab147a5b12 Mon Sep 17 00:00:00 2001 From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> Date: Wed, 21 Oct 2026 17:41:09 +0000 Subject: [PATCH] project: Match document filter patterns in dynamic registrations (#65252) ## Summary Follow-up to #59243, which made dynamically registered capabilities honor the `language` and `scheme` of their document selectors, but left `pattern` matching fail-open. A registration such as `{ "language": "toml", "pattern": "**/Project.toml" }` therefore still applied to every TOML document the server had opened, and a pattern-only filter applied to every document. This matches `pattern` against the document's path: - String patterns are matched against the absolute path. As in the LSP glob syntax, `*` and `?` do not match path separators. - Relative patterns are matched against the path relative to their base URI, and Zed now advertises the `textDocument.filters.relativePatternSupport` client capability. - Documents without a file system path never match a `pattern` filter. Contexts that stand for a whole language, like the semantic token legend lookup, and guest buffers whose path is unknown keep not evaluating patterns. - Registrations whose patterns are not valid globs are rejected when they are registered. LSP 3.18 changed `TextDocumentFilter.pattern` from a string to a `GlobPattern`, so that it can also be a relative pattern. ~~This PR depends on zed-industries/lsp-types#16, which updates the type and adds the client capability. I'd like to merge this together with that upstream change: `Cargo.toml` currently points at the commit of zed-industries/lsp-types#16 on my fork, and I will switch it to the `zed-industries/lsp-types` revision once that PR is merged.~~ **Update:** zed-industries/lsp-types#16 has been merged, and `Cargo.toml` now points at its `zed-industries/lsp-types` revision (zed-industries/lsp-types@82d7fc66ebdfabcfeb26ba16bbed9f3d26211fc3). ## Testing - Added unit tests for matching string patterns, wildcards across path separators, and relative patterns. - Added an integration test that a pattern-scoped completion registration only applies to matching buffers, and that a registration with an invalid pattern is rejected. - Updated `test_dynamic_formatting_registration_with_pattern_only_selector`, which asserted the fail-open behavior left by #59243. ## Self-review - [x] I've reviewed my diff for quality, security, reliability, and performance. - [x] UI changes follow the [checklist](https://zed.dev/docs/development/ui-checklist). - [x] Tests cover the new or changed behavior. Release Notes: - Fixed language servers' dynamically registered capabilities applying to files outside of the `pattern` of their document selector. --------- Co-authored-by: Claude Opus 5.5 --- Cargo.lock | 2 +- Cargo.toml | 2 +- .../collab/tests/integration/editor_tests.rs | 7 +- crates/lsp/src/lsp.rs | 3 + crates/project/src/lsp_store.rs | 1323 ++++++++++++++++- .../src/lsp_store/dynamic_registration.rs | 34 +- .../project/src/lsp_store/semantic_tokens.rs | 10 +- .../tests/integration/dynamic_registration.rs | 450 +++++- .../tests/integration/project_tests.rs | 77 +- 9 files changed, 1778 insertions(+), 130 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2456c21c85b..5b2eeb56d4e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10480,7 +10480,7 @@ dependencies = [ [[package]] name = "lsp-types" version = "0.95.1" -source = "git+https://github.com/zed-industries/lsp-types?rev=f1783e63a7f4eb4397bf51d4148b4895a1f7ab16#f1783e63a7f4eb4397bf51d4148b4895a1f7ab16" +source = "git+https://github.com/zed-industries/lsp-types?rev=82d7fc66ebdfabcfeb26ba16bbed9f3d26211fc3#82d7fc66ebdfabcfeb26ba16bbed9f3d26211fc3" dependencies = [ "bitflags 1.3.2", "serde", diff --git a/Cargo.toml b/Cargo.toml index 1b224fec377..055fb7f0f8f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -688,7 +688,7 @@ linkify = "0.10.0" livekit = { version = "0.7.32", features = ["tokio", "rustls-tls-native-roots"] } log = { version = "0.4", default-features = false, features = ["std"] } lru = "0.16" -lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "f1783e63a7f4eb4397bf51d4148b4895a1f7ab16" } +lsp-types = { git = "https://github.com/zed-industries/lsp-types", rev = "82d7fc66ebdfabcfeb26ba16bbed9f3d26211fc3" } mach2 = "0.6" markup5ever_rcdom = "0.39" mdbook = { version = "=0.4.40", default-features = false, features = ["search"] } diff --git a/crates/collab/tests/integration/editor_tests.rs b/crates/collab/tests/integration/editor_tests.rs index c2e8779b153..0dfc147a5b0 100644 --- a/crates/collab/tests/integration/editor_tests.rs +++ b/crates/collab/tests/integration/editor_tests.rs @@ -2126,7 +2126,12 @@ async fn test_collaborating_with_code_lens_resolve( .unwrap() .downcast::() .unwrap(); - let fake_language_server = fake_language_servers.next().await.unwrap(); + let mut fake_language_server = fake_language_servers.next().await.unwrap(); + // Fake servers are handed out before they are initialized, while registrations need a + // running server, which the buffer being opened in it ensures. + fake_language_server + .receive_notification::() + .await; fake_language_server .request::( lsp::RegistrationParams { diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index ce68fa25eac..b3307419c66 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -1134,6 +1134,9 @@ impl LanguageServer { ]), }), }), + filters: Some(TextDocumentFilterClientCapabilities { + relative_pattern_support: Some(true), + }), ..TextDocumentClientCapabilities::default() }), experimental: Some(json!({ diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 06e71a9d44d..9f364e79108 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -308,6 +308,42 @@ struct DocumentSelectorContext { /// `None` for documents without a language, which no `language` filter matches. language_id: Option, scheme: &'static str, + path: DocumentSelectorPath, +} + +#[derive(Clone, Debug)] +enum DocumentSelectorPath { + /// The context stands for every document of a language (e.g. for per-language caches), + /// so `pattern` filters cannot be evaluated and are not considered. + Unknown, + /// The document has no file system path, so no `pattern` filter matches it. + Absent, + /// The absolute path of the document with `/` separators, in the path style of the host it + /// belongs to, which differs from this machine's for remote projects. + Present { path: String, path_style: PathStyle }, +} + +impl DocumentSelectorPath { + fn for_file(file: &File, cx: &App) -> Self { + Self::present( + &file.abs_path(cx).to_string_lossy(), + file.worktree.read(cx).path_style(), + ) + } + + fn present(path: &str, path_style: PathStyle) -> Self { + Self::Present { + path: path_with_slashes(path, path_style), + path_style, + } + } +} + +fn path_with_slashes(path: &str, path_style: PathStyle) -> String { + match path_style { + PathStyle::Windows => path.replace('\\', "/"), + PathStyle::Unix => path.to_string(), + } } pub struct LocalLspStore { @@ -1086,23 +1122,15 @@ impl LocalLspStore { let lsp_store = lsp_store.clone(); let mut cx = cx.clone(); async move { - lsp_store - .update(&mut cx, |lsp_store, cx| { - if lsp_store.as_local().is_some() { - match lsp_store - .register_server_capabilities(server_id, params, cx) - { - Ok(()) => {} - Err(e) => { - log::error!( - "Failed to register server capabilities: {e:#}" - ); - } - }; - } - }) - .ok(); - Ok(()) + lsp_store.update(&mut cx, |lsp_store, cx| { + if lsp_store.as_local().is_some() { + lsp_store + .register_server_capabilities(server_id, params, cx) + .inspect_err(|error| log::error!("{error:#}")) + } else { + Ok(()) + } + })? } } }) @@ -1501,9 +1529,9 @@ impl LocalLspStore { fn language_servers_for_buffer<'a>( &'a self, - buffer: &'a Buffer, - cx: &'a mut App, - ) -> impl Iterator, &'a Arc)> { + buffer: &Buffer, + cx: &mut App, + ) -> impl Iterator, &'a Arc)> + use<'a> { self.language_server_ids_for_buffer(buffer, cx) .into_iter() .filter_map(|server_id| match self.language_servers.get(&server_id)? { @@ -2027,6 +2055,7 @@ impl LocalLspStore { buffer_snapshot, adapter, server, + cx, ) }); if range_formatter.is_some() { @@ -2041,6 +2070,7 @@ impl LocalLspStore { buffer_snapshot, adapter, server, + cx, ) }) } else { @@ -2053,11 +2083,13 @@ impl LocalLspStore { buffer_snapshot, adapter, server, + cx, ) || buffer_supports_lsp_range_formatting( local, buffer_snapshot, adapter, server, + cx, ) }) }; @@ -2548,6 +2580,7 @@ impl LocalLspStore { buffer_handle.read(cx), adapter, language_server, + cx, ) }) })?; @@ -2695,12 +2728,13 @@ impl LocalLspStore { Some(local) => { let buffer = buffer.read(cx); ( - buffer_supports_lsp_formatting(local, buffer, adapter, language_server), + buffer_supports_lsp_formatting(local, buffer, adapter, language_server, cx), buffer_supports_lsp_range_formatting( local, buffer, adapter, language_server, + cx, ), ) } @@ -2988,6 +3022,7 @@ impl LocalLspStore { server.server_id(), &adapter, buffer, + cx, ), cx, ); @@ -3290,6 +3325,7 @@ impl LocalLspStore { server.server_id(), &adapter, buffer, + cx, ), cx, ); @@ -6007,6 +6043,7 @@ impl LspStore { &self, server_id: LanguageServerId, language: Option<&LanguageName>, + path: DocumentSelectorPath, ) -> Option { let language = language?; let server_name = &self.language_server_statuses.get(&server_id)?.name; @@ -6021,6 +6058,7 @@ impl LspStore { Some(DocumentSelectorContext { language_id: Some(language_id), scheme: "file", + path, }) } @@ -6033,8 +6071,12 @@ impl LspStore { cx: &App, ) -> bool { let registration_method = text_document_registration_method(method); - let language = buffer.read(cx).language().map(|language| language.name()); - let context = self.remote_document_selector_context(server_id, language.as_ref()); + let buffer = buffer.read(cx); + let language = buffer.language().map(|language| language.name()); + let path = File::from_dyn(buffer.file()).map_or(DocumentSelectorPath::Unknown, |file| { + DocumentSelectorPath::for_file(file, cx) + }); + let context = self.remote_document_selector_context(server_id, language.as_ref(), path); remote_text_document_capabilities_match( self.lsp_server_initial_capabilities.get(&server_id), self.lsp_server_capabilities.get(&server_id), @@ -6062,7 +6104,7 @@ impl LspStore { else { return false; }; - text_document_capabilities_for_buffer(local, method, buffer, adapter, server) + text_document_capabilities_for_buffer(local, method, buffer, adapter, server, cx) .any(&mut check) }); } @@ -6095,8 +6137,10 @@ impl LspStore { }) .any(|(adapter, server)| { let server_name = server.name(); - text_document_capabilities_for_buffer(local, method, buffer, adapter, server) - .any(|capabilities| check(&server_name, capabilities)) + text_document_capabilities_for_buffer( + local, method, buffer, adapter, server, cx, + ) + .any(|capabilities| check(&server_name, capabilities)) }); } @@ -6241,6 +6285,7 @@ impl LspStore { buffer, adapter, language_server, + cx, ) .peekable(); if applicable_capabilities.peek().is_some() { @@ -7978,7 +8023,7 @@ impl LspStore { local .language_servers_for_buffer(buffer, cx) .filter(|(adapter, server)| { - lsp_command_allowed_for_buffer(local, &request, buffer, adapter, server) + lsp_command_allowed_for_buffer(local, &request, buffer, adapter, server, cx) }) .filter(|(adapter, _)| { scope @@ -8677,6 +8722,7 @@ impl LspStore { registration, buffer.read(cx), &adapter, + cx, ) { continue; } @@ -9622,7 +9668,7 @@ impl LspStore { .language_servers_for_buffer(buffer, cx) .map(|(adapter, server)| { let sync_kind = - text_document_sync_kind_for_buffer(local, buffer, adapter, server); + text_document_sync_kind_for_buffer(local, buffer, adapter, server, cx); (server.clone(), sync_kind) }) .collect(), @@ -9754,7 +9800,7 @@ impl LspStore { return None; }; let include_text = - did_save_include_text_for_buffer(local, buffer.read(cx), adapter, server)?; + did_save_include_text_for_buffer(local, buffer.read(cx), adapter, server, cx)?; Some((server.clone(), include_text)) }) .collect::>(); @@ -10642,7 +10688,7 @@ impl LspStore { local .language_servers_for_buffer(buffer, cx) .filter(|(adapter, server)| { - lsp_command_allowed_for_buffer(local, request, buffer, adapter, server) + lsp_command_allowed_for_buffer(local, request, buffer, adapter, server, cx) }) .map(|(_, server)| server.server_id()) .filter(|server_id| { @@ -10696,7 +10742,7 @@ impl LspStore { local .language_servers_for_buffer(buffer, cx) .filter(|(adapter, server)| { - lsp_command_allowed_for_buffer(local, &request, buffer, adapter, server) + lsp_command_allowed_for_buffer(local, &request, buffer, adapter, server, cx) }) .filter(|(adapter, _)| { scope @@ -14959,13 +15005,17 @@ impl LspStore { fn document_selector_context_for_buffer( buffer: &Buffer, adapter: &CachedLspAdapter, + cx: &App, ) -> DocumentSelectorContext { - match buffer.language() { - Some(language) => document_selector_context_for_language(&language.name(), adapter), - None => DocumentSelectorContext { - language_id: None, - scheme: "file", - }, + let path = File::from_dyn(buffer.file()).map_or(DocumentSelectorPath::Absent, |file| { + DocumentSelectorPath::for_file(file, cx) + }); + DocumentSelectorContext { + language_id: buffer + .language() + .map(|language| adapter.language_id(&language.name())), + scheme: "file", + path, } } @@ -14976,32 +15026,450 @@ fn document_selector_context_for_language( DocumentSelectorContext { language_id: Some(adapter.language_id(language)), scheme: "file", + path: DocumentSelectorPath::Unknown, + } +} + +/// A document selector with the patterns of its filters compiled when it is registered, as +/// documents are matched against it as often as on every edit. +#[derive(Clone, Debug)] +pub(super) struct CompiledDocumentSelector { + filters: Vec, +} + +#[derive(Clone, Debug)] +struct CompiledDocumentFilter { + filter: lsp::DocumentFilter, + pattern: Option, +} + +impl CompiledDocumentSelector { + /// Rejects unusable patterns up front, so that matching never has to decide what they mean. + pub(super) fn new(document_selector: lsp::DocumentSelector) -> Result { + let filters = document_selector + .into_iter() + .map(CompiledDocumentFilter::new) + .collect::>()?; + Ok(Self { filters }) + } +} + +impl CompiledDocumentFilter { + fn new(filter: lsp::DocumentFilter) -> Result { + let pattern = filter + .pattern + .as_ref() + .map(|pattern| { + DocumentFilterPattern::new(pattern) + .with_context(|| format!("invalid document filter pattern {pattern:?}")) + }) + .transpose()?; + Ok(Self { filter, pattern }) + } +} + +impl PartialEq for CompiledDocumentSelector { + fn eq(&self, other: &Self) -> bool { + self.filters + .iter() + .map(|filter| &filter.filter) + .eq(other.filters.iter().map(|filter| &filter.filter)) + } +} + +impl Serialize for CompiledDocumentSelector { + fn serialize(&self, serializer: S) -> Result { + serializer.collect_seq(self.filters.iter().map(|filter| &filter.filter)) + } +} + +impl<'de> serde::Deserialize<'de> for CompiledDocumentSelector { + fn deserialize>(deserializer: D) -> Result { + let document_selector = lsp::DocumentSelector::deserialize(deserializer)?; + // Hosts only share selectors they compiled. Should a guest still fail to compile a + // pattern, dropping its filter leaves it matching no document, while failing here would + // discard the server's other capabilities. + let filters = document_selector + .into_iter() + .filter_map(|filter| CompiledDocumentFilter::new(filter).log_err()) + .collect(); + Ok(Self { filters }) } } fn document_selector_matches( - document_selector: Option<&lsp::DocumentSelector>, + document_selector: Option<&CompiledDocumentSelector>, context: &DocumentSelectorContext, ) -> bool { let Some(document_selector) = document_selector else { return true; }; - document_selector.iter().any(|filter| { - if let Some(language) = &filter.language - && context.language_id.as_ref() != Some(language) - { - return false; + document_selector + .filters + .iter() + .any(|CompiledDocumentFilter { filter, pattern }| { + if let Some(language) = &filter.language + && context.language_id.as_ref() != Some(language) + { + return false; + } + + if let Some(scheme) = &filter.scheme + && !scheme.eq_ignore_ascii_case(context.scheme) + { + return false; + } + + // Checked last, since it runs the glob. + if let Some(pattern) = pattern { + match &context.path { + DocumentSelectorPath::Unknown => {} + DocumentSelectorPath::Absent => return false, + DocumentSelectorPath::Present { path, path_style } => { + if !pattern.matches(path, *path_style) { + return false; + } + } + } + } + + true + }) +} + +fn document_filter_glob(pattern: &lsp::GlobPattern) -> (Option<&lsp::Uri>, &str) { + match pattern { + lsp::GlobPattern::String(pattern) => (None, pattern), + lsp::GlobPattern::Relative(relative_pattern) => { + let base_uri = match &relative_pattern.base_uri { + OneOf::Left(workspace_folder) => &workspace_folder.uri, + OneOf::Right(base_uri) => base_uri, + }; + (Some(base_uri), &relative_pattern.pattern) + } + } +} + +// Bound work on server-supplied patterns before the regex compiler's own limits apply. +const DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES: usize = 256; +const DOCUMENT_FILTER_GLOB_MAX_BYTES: usize = 1024 * 1024; + +/// Compiles an LSP glob pattern into a regular expression matching paths with `/` separators. +/// +/// Uses LSP glob semantics: `*` and `?` match characters (not bytes) within a path segment, +/// a `**` segment matches any number of segments, `{a,b}` matches either sub-pattern, and +/// `[a-z]` or `[!a-z]` matches a character in or out of a range within a path segment. +/// Unlike VS Code's parser, consecutive `**` segments are equivalent to one, and character +/// classes cannot consume `/`, even when a negation or range would otherwise include it. +/// +/// With `normalize_drive_letters`, the drive letters of absolute Windows paths are lowercased +/// in each alternative after brace expansion, as braces can enclose or even produce them. +fn compile_document_filter_glob(glob: &str, normalize_drive_letters: bool) -> Result { + let mut regex = String::from("^(?:"); + // Expand complete paths so `**` inside an alternative can absorb adjacent separators. + for (index, alternative) in expand_glob_braces(glob)?.iter().enumerate() { + let alternative = if normalize_drive_letters { + normalize_document_filter_drive_letter(alternative) + } else { + Cow::Borrowed(alternative.as_str()) + }; + let branch = glob_regex(&alternative)?; + anyhow::ensure!( + regex.len() + branch.len() + 3 <= DOCUMENT_FILTER_GLOB_MAX_BYTES, + "document filter glob exceeds the compiled pattern size limit" + ); + if index > 0 { + regex.push('|'); + } + regex.push_str(&branch); + } + regex.push_str(")$"); + Ok(regex::Regex::new(®ex)?) +} + +fn expand_glob_braces(glob: &str) -> Result> { + let mut remaining_bytes = DOCUMENT_FILTER_GLOB_MAX_BYTES + .checked_sub(glob.len()) + .context("document filter glob exceeds the expansion size limit")?; + let mut pending = vec![glob.to_string()]; + let mut expanded = Vec::new(); + while let Some(pattern) = pending.pop() { + let Some((group, alternatives)) = glob_brace_alternatives(&pattern)? else { + expanded.push(pattern); + continue; + }; + anyhow::ensure!( + expanded.len() + pending.len() + alternatives.len() + <= DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES, + "document filter glob exceeds the alternative count limit" + ); + let prefix = &pattern[..group.start]; + let suffix = &pattern[group.end..]; + for alternative in alternatives.into_iter().rev() { + // Charge intermediate expansions too, so deeply nested single-choice groups + // cannot cause unbounded rescanning and copying even with few final alternatives. + remaining_bytes = remaining_bytes + .checked_sub(prefix.len() + alternative.len() + suffix.len()) + .context("document filter glob exceeds the expansion size limit")?; + pending.push(format!("{prefix}{alternative}{suffix}")); + } + } + Ok(expanded) +} + +fn glob_brace_alternatives(glob: &str) -> Result, Vec<&str>)>> { + let mut chars = glob.char_indices(); + let mut depth = 0; + let mut group_start = 0; + let mut alternative_start = 0; + let mut alternatives = Vec::new(); + while let Some((index, character)) = chars.next() { + match character { + '[' => { + glob_character_class_end(glob, &mut chars)?; + } + '{' => { + if depth == 0 { + group_start = index; + alternative_start = index + 1; + } + depth += 1; + } + ',' if depth == 1 => { + anyhow::ensure!( + alternatives.len() + 1 < DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES, + "document filter glob exceeds the alternative count limit" + ); + alternatives.push(&glob[alternative_start..index]); + alternative_start = index + 1; + } + '}' if depth > 0 => { + depth -= 1; + if depth == 0 { + alternatives.push(&glob[alternative_start..index]); + return Ok(Some((group_start..index + 1, alternatives))); + } + } + _ => {} + } + } + anyhow::ensure!(depth == 0, "unclosed `{{` in glob pattern {glob:?}"); + Ok(None) +} + +fn glob_character_class_end(glob: &str, chars: &mut std::str::CharIndices<'_>) -> Result { + let mut first = true; + let mut has_member = false; + for (index, character) in chars.by_ref() { + if character == ']' && has_member { + return Ok(index + 1); + } + // A leading `]`, also after negation, is a literal member rather than the delimiter. + if !first || !matches!(character, '!' | '^') { + has_member = true; + } + first = false; + } + anyhow::bail!("unclosed `[` in glob pattern {glob:?}") +} + +fn glob_regex(glob: &str) -> Result { + const GLOBSTAR: &str = "**"; + let mut segments = split_glob(glob, '/')?; + segments.dedup_by(|segment, previous| *segment == GLOBSTAR && *previous == GLOBSTAR); + if segments.is_empty() { + return Ok(String::new()); + } + if segments.iter().all(|segment| *segment == GLOBSTAR) { + return Ok("(?s:.*)".to_string()); + } + if segments.as_slice() == ["", GLOBSTAR] { + return Ok("/(?s:.*)".to_string()); + } + + let mut regex = String::new(); + for (index, segment) in segments.iter().enumerate() { + let is_last_segment = index + 1 == segments.len(); + if *segment == GLOBSTAR { + // A terminal globstar owns its separator, but cannot extend the preceding + // segment (e.g. `/root/**` must not match `/rooted/`). + regex.push_str(if is_last_segment { + "(?:/(?s:.*))?" + } else { + "(?:/|[^/]+/)*?" + }); + continue; } - if let Some(scheme) = &filter.scheme - && !scheme.eq_ignore_ascii_case(context.scheme) - { - return false; + let mut chars = segment.char_indices(); + while let Some((index, char)) = chars.next() { + match char { + '[' => { + let end = glob_character_class_end(segment, &mut chars)?; + regex.push_str(&glob_character_class_regex(&segment[index + 1..end - 1])); + } + '?' => regex.push_str("[^/]"), + '*' => regex.push_str("[^/]*?"), + char => regex.push_str(®ex::escape(char.encode_utf8(&mut [0; 4]))), + } } - true - }) + // A following `**` that ends the pattern brings its own separator. + let next_segment_is_last_globstar = segments + .get(index + 1) + .is_some_and(|next| *next == GLOBSTAR) + && index + 2 == segments.len(); + if !is_last_segment && !next_segment_is_last_globstar { + regex.push('/'); + } + } + Ok(regex) +} + +/// Members are escaped and only a `-` between two members forms a range, as in the JavaScript +/// regular expressions VS Code compiles classes into, so a `-` endpoint (e.g. `[--0]`) keeps +/// its meaning instead of being reinterpreted by the regex parser. +fn glob_character_class_regex(members: &str) -> String { + let push_member = |class: &mut String, member: char| { + class.push_str(®ex::escape(member.encode_utf8(&mut [0; 4]))); + }; + let mut class = String::new(); + let mut members = match members.strip_prefix(['!', '^']) { + Some(members) => { + class.push('^'); + members.chars() + } + None => members.chars(), + }; + while let Some(member) = members.next() { + push_member(&mut class, member); + let mut lookahead = members.clone(); + if lookahead.next() == Some('-') + && let Some(range_end) = lookahead.next() + { + class.push('-'); + push_member(&mut class, range_end); + members = lookahead; + } + } + format!("[[{class}]&&[^/]]") +} + +/// Splits a brace-expanded glob without interpreting separators inside character classes. +fn split_glob(glob: &str, separator: char) -> Result> { + let mut parts = Vec::new(); + if glob.is_empty() { + return Ok(parts); + } + let mut start = 0; + let mut chars = glob.char_indices(); + while let Some((index, character)) = chars.next() { + if character == '[' { + glob_character_class_end(glob, &mut chars)?; + } else if character == separator { + parts.push(&glob[start..index]); + start = index + character.len_utf8(); + } + } + parts.push(&glob[start..]); + Ok(parts) +} + +fn normalize_document_filter_drive_letter(path: &str) -> Cow<'_, str> { + match path.as_bytes() { + [drive_letter, b':', b'/', ..] if drive_letter.is_ascii_uppercase() => { + let mut path = path.to_string(); + path.replace_range( + ..1, + &char::from(drive_letter.to_ascii_lowercase()).to_string(), + ); + Cow::Owned(path) + } + _ => Cow::Borrowed(path), + } +} + +#[derive(Clone, Debug)] +struct DocumentFilterPattern { + base: Option, + matcher: regex::Regex, +} + +/// The base of a relative pattern, read in either path style, as the one of the host is only +/// known when matching, with `/` separators and without a trailing one. +#[derive(Clone, Debug)] +struct RelativePatternBase { + unix_path: Option, + windows_path: Option, +} + +impl DocumentFilterPattern { + fn new(pattern: &lsp::GlobPattern) -> Result { + let (base_uri, glob) = document_filter_glob(pattern); + let base = base_uri + .map(|base_uri| { + anyhow::ensure!( + base_uri.scheme() == "file", + "relative pattern base URI {base_uri} is not a file URI" + ); + let base_path = |path_style| { + let path = base_uri.to_file_path_ext(path_style).ok()?; + let path = path_with_slashes(&path.to_string_lossy(), path_style); + Some(path.trim_end_matches('/').to_string()) + }; + Ok(RelativePatternBase { + unix_path: base_path(PathStyle::Unix), + windows_path: base_path(PathStyle::Windows), + }) + }) + .transpose()?; + // VS Code's fsPath lowercases the drive letter, so drive prefixes of absolute patterns + // are canonicalized like those of Windows paths when matching. This leaves the matches + // of Unix paths unchanged, as they start with `/` rather than a drive letter. + let matcher = compile_document_filter_glob(glob, base.is_none())?; + Ok(Self { base, matcher }) + } + + fn matches(&self, path: &str, path_style: PathStyle) -> bool { + let Some(base) = &self.base else { + let path = match path_style { + PathStyle::Windows => normalize_document_filter_drive_letter(path), + PathStyle::Unix => Cow::Borrowed(path), + }; + return self.matcher.is_match(&path); + }; + + // The base URI is on the same host as the document, so it is read in the same path style. + let base_path = match path_style { + PathStyle::Windows => base.windows_path.as_deref(), + PathStyle::Unix => base.unix_path.as_deref(), + }; + let Some(base_path) = base_path else { + return false; + }; + let mut relative_path = path; + // Case-equivalent components can have different UTF-8 lengths (e.g. K and k), so + // consume the candidate's components rather than slicing at the base's byte length. + for base_component in base_path.split('/') { + // The base may be the document itself, leaving an empty path for the pattern, which + // `**` matches. A path running out before the base does fails to match its components. + let (component, remainder) = + relative_path.split_once('/').unwrap_or((relative_path, "")); + let matches = match path_style { + PathStyle::Windows => { + component == base_component + || component.to_lowercase() == base_component.to_lowercase() + } + PathStyle::Unix => component == base_component, + }; + if !matches { + return false; + } + relative_path = remainder; + } + self.matcher.is_match(relative_path) + } } fn remote_text_document_capabilities_match( @@ -15046,8 +15514,9 @@ fn dynamic_text_document_registration_allows_buffer( registration: &dynamic_registration::DynamicTextDocumentRegistration, buffer: &Buffer, adapter: &CachedLspAdapter, + cx: &App, ) -> bool { - let context = document_selector_context_for_buffer(buffer, adapter); + let context = document_selector_context_for_buffer(buffer, adapter, cx); document_selector_matches(registration.document_selector.as_ref(), &context) } @@ -15065,10 +15534,11 @@ fn text_document_registration_method(method: &str) -> &str { fn text_document_capabilities_for_buffer<'a>( local: &'a LocalLspStore, method: &str, - buffer: &'a Buffer, - adapter: &'a CachedLspAdapter, + buffer: &Buffer, + adapter: &CachedLspAdapter, server: &'a LanguageServer, -) -> impl Iterator> { + cx: &App, +) -> impl DoubleEndedIterator> + use<'a> { let code_action_kinds = server.code_action_kinds(); let static_capabilities = local .initial_server_capabilities @@ -15079,6 +15549,7 @@ fn text_document_capabilities_for_buffer<'a>( }); let registration_method = text_document_registration_method(method); + let context = document_selector_context_for_buffer(buffer, adapter, cx); let dynamic_capabilities = local .language_server_dynamic_registrations .get(&server.server_id()) @@ -15086,7 +15557,7 @@ fn text_document_capabilities_for_buffer<'a>( .into_iter() .flat_map(|registrations| registrations.values()) .filter(move |registration| { - dynamic_text_document_registration_allows_buffer(registration, buffer, adapter) + document_selector_matches(registration.document_selector.as_ref(), &context) }) .map(move |registration| AdapterServerCapabilities { server_capabilities: ®istration.server_capabilities, @@ -15099,10 +15570,11 @@ fn text_document_capabilities_for_buffer<'a>( fn applicable_lsp_command_capabilities_for_buffer<'a, R>( local: &'a LocalLspStore, request: &'a R, - buffer: &'a Buffer, - adapter: &'a CachedLspAdapter, + buffer: &Buffer, + adapter: &CachedLspAdapter, server: &'a LanguageServer, -) -> impl Iterator> + cx: &App, +) -> impl Iterator> + use<'a, R> where R: LspCommand, { @@ -15112,6 +15584,7 @@ where buffer, adapter, server, + cx, ) .filter(move |capabilities| request.check_capabilities(*capabilities)) } @@ -15122,11 +15595,12 @@ fn lsp_command_allowed_for_buffer( buffer: &Buffer, adapter: &CachedLspAdapter, server: &LanguageServer, + cx: &App, ) -> bool where R: LspCommand, { - applicable_lsp_command_capabilities_for_buffer(local, request, buffer, adapter, server) + applicable_lsp_command_capabilities_for_buffer(local, request, buffer, adapter, server, cx) .next() .is_some() } @@ -15136,11 +15610,17 @@ fn buffer_supports_lsp_formatting( buffer: &Buffer, adapter: &CachedLspAdapter, server: &LanguageServer, + cx: &App, ) -> bool { - text_document_capabilities_for_buffer(local, "textDocument/formatting", buffer, adapter, server) - .any(|capabilities| { - server_capabilities_support_formatting(capabilities.server_capabilities) - }) + text_document_capabilities_for_buffer( + local, + "textDocument/formatting", + buffer, + adapter, + server, + cx, + ) + .any(|capabilities| server_capabilities_support_formatting(capabilities.server_capabilities)) } fn buffer_supports_lsp_range_formatting( @@ -15148,6 +15628,7 @@ fn buffer_supports_lsp_range_formatting( buffer: &Buffer, adapter: &CachedLspAdapter, server: &LanguageServer, + cx: &App, ) -> bool { text_document_capabilities_for_buffer( local, @@ -15155,6 +15636,7 @@ fn buffer_supports_lsp_range_formatting( buffer, adapter, server, + cx, ) .any(|capabilities| { server_capabilities_support_range_formatting(capabilities.server_capabilities) @@ -15166,6 +15648,7 @@ fn completion_trigger_characters_for_buffer( server_id: LanguageServerId, adapter: &CachedLspAdapter, buffer: &Buffer, + cx: &App, ) -> BTreeSet { fn extend_triggers(triggers: &mut BTreeSet, options: &lsp::CompletionOptions) { if let Some(characters) = &options.trigger_characters { @@ -15187,7 +15670,7 @@ fn completion_trigger_characters_for_buffer( .and_then(|registrations| registrations.text_documents.get("textDocument/completion")) { for registration in registrations.values() { - if dynamic_text_document_registration_allows_buffer(registration, buffer, adapter) + if dynamic_text_document_registration_allows_buffer(registration, buffer, adapter, cx) && let Some(options) = registration .server_capabilities .completion_provider @@ -16841,6 +17324,7 @@ fn did_save_include_text_for_buffer( buffer: &Buffer, adapter: &CachedLspAdapter, server: &LanguageServer, + cx: &App, ) -> Option { fn save_options( capabilities: &lsp::ServerCapabilities, @@ -16857,7 +17341,7 @@ fn did_save_include_text_for_buffer( .buffers_opened_in_servers .get(&buffer.remote_id()) .is_some_and(|servers| servers.contains(&server_id)); - let context = document_selector_context_for_buffer(buffer, adapter); + let context = document_selector_context_for_buffer(buffer, adapter, cx); // Later registrations take precedence over earlier ones. Registrations without a selector // stand for the documents the client selects for the server, like the static options. let registered_save_options = local @@ -16898,20 +17382,29 @@ fn text_document_sync_kind_for_buffer( buffer: &Buffer, adapter: &CachedLspAdapter, server: &LanguageServer, + cx: &App, ) -> Option { - // Later registrations take precedence over earlier ones and the static options. - text_document_capabilities_for_buffer(local, "textDocument/didChange", buffer, adapter, server) - .filter_map(|capabilities| { - match capabilities - .server_capabilities - .text_document_sync - .as_ref()? - { - lsp::TextDocumentSyncCapability::Kind(kind) => Some(*kind), - lsp::TextDocumentSyncCapability::Options(options) => options.change, - } - }) - .last() + // Later registrations take precedence over earlier ones and the static options, so + // searching from the latest one stops at the first registration selecting the buffer. + text_document_capabilities_for_buffer( + local, + "textDocument/didChange", + buffer, + adapter, + server, + cx, + ) + .rev() + .find_map(|capabilities| { + match capabilities + .server_capabilities + .text_document_sync + .as_ref()? + { + lsp::TextDocumentSyncCapability::Kind(kind) => Some(*kind), + lsp::TextDocumentSyncCapability::Options(options) => options.change, + } + }) } /// Completion items are displayed in a `UniformList`. @@ -17415,6 +17908,34 @@ mod tests { )); assert!(should_log_lsp_request_failure("something else entirely")); } + + #[test] + fn synced_document_selector_drops_filters_that_fail_to_compile() { + let context = + |path: &str| toml_file_context(DocumentSelectorPath::present(path, PathStyle::Unix)); + let selector: CompiledDocumentSelector = serde_json::from_value(serde_json::json!([ + { "pattern": "**/[a.rs" }, + { "pattern": "**/b.rs" }, + ])) + .expect("a synced selector with an invalid pattern should deserialize"); + assert!(!document_selector_matches( + Some(&selector), + &context("/root/a.rs") + )); + assert!(document_selector_matches( + Some(&selector), + &context("/root/b.rs") + )); + + let selector: CompiledDocumentSelector = + serde_json::from_value(serde_json::json!([{ "pattern": "**/[a.rs" }])) + .expect("a synced selector with an invalid pattern should deserialize"); + assert!( + !document_selector_matches(Some(&selector), &context("/root/a.rs")), + "a selector without any usable filter should match no document", + ); + } + #[test] fn synced_server_capabilities_wire_format_is_compatible_with_plain_capabilities() { let registrations: dynamic_registration::TextDocumentRegistrations = @@ -17423,11 +17944,11 @@ mod tests { collections::IndexMap::from_iter([( "file-completion".to_string(), dynamic_registration::DynamicTextDocumentRegistration { - document_selector: Some(vec![lsp::DocumentFilter { + document_selector: Some(compiled_selector(vec![lsp::DocumentFilter { language: Some("rust".to_string()), scheme: Some("file".to_string()), pattern: None, - }]), + }])), server_capabilities: lsp::ServerCapabilities { completion_provider: Some(lsp::CompletionOptions { trigger_characters: Some(vec![".".to_string()]), @@ -17562,6 +18083,646 @@ mod tests { DocumentSelectorContext { language_id: Some("rust".to_string()), scheme: "file", + path: DocumentSelectorPath::Unknown, + } + } + + fn toml_file_context(path: DocumentSelectorPath) -> DocumentSelectorContext { + DocumentSelectorContext { + language_id: Some("toml".to_string()), + scheme: "file", + path, + } + } + + fn compiled_selector(document_selector: lsp::DocumentSelector) -> CompiledDocumentSelector { + CompiledDocumentSelector::new(document_selector).expect("valid document selector") + } + + fn pattern_selector( + language: Option<&str>, + pattern: lsp::GlobPattern, + ) -> Option { + Some(compiled_selector(vec![lsp::DocumentFilter { + language: language.map(str::to_string), + scheme: None, + pattern: Some(pattern), + }])) + } + + #[test] + fn document_selector_pattern_matches_document_path() { + let selector = pattern_selector( + Some("toml"), + lsp::GlobPattern::String("**/Project.toml".to_string()), + ); + let present = |path: &str| DocumentSelectorPath::present(path, PathStyle::local()); + + assert!(document_selector_matches( + selector.as_ref(), + &toml_file_context(present(util::path!("/root/Project.toml"))), + )); + assert!(!document_selector_matches( + selector.as_ref(), + &toml_file_context(present(util::path!("/root/Manifest.toml"))), + )); + assert!( + !document_selector_matches( + selector.as_ref(), + &toml_file_context(DocumentSelectorPath::Absent), + ), + "a document without a path cannot match a pattern filter", + ); + assert!( + document_selector_matches( + selector.as_ref(), + &toml_file_context(DocumentSelectorPath::Unknown), + ), + "per-language contexts do not evaluate pattern filters", + ); + + let mut context = toml_file_context(present(util::path!("/root/Project.toml"))); + context.language_id = Some("julia".to_string()); + assert!( + !document_selector_matches(selector.as_ref(), &context), + "the pattern must not override a mismatching language", + ); + } + + #[test] + fn document_selector_pattern_wildcard_does_not_cross_separators() { + let selector = + pattern_selector(None, lsp::GlobPattern::String("**/root/*.toml".to_string())); + let context = + |path: &str| toml_file_context(DocumentSelectorPath::present(path, PathStyle::local())); + + assert!(document_selector_matches( + selector.as_ref(), + &context(util::path!("/root/Project.toml")), + )); + assert!(!document_selector_matches( + selector.as_ref(), + &context(util::path!("/root/sub/Project.toml")), + )); + } + + #[test] + fn document_selector_relative_pattern_matches_below_base() { + let selector = pattern_selector( + None, + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right(lsp::Uri::from_file_path(util::path!("/root")).unwrap()), + pattern: "sub/*.toml".to_string(), + }), + ); + let context = + |path: &str| toml_file_context(DocumentSelectorPath::present(path, PathStyle::local())); + + assert!(document_selector_matches( + selector.as_ref(), + &context(util::path!("/root/sub/Project.toml")), + )); + assert!(!document_selector_matches( + selector.as_ref(), + &context(util::path!("/other/sub/Project.toml")), + )); + assert!(!document_selector_matches( + selector.as_ref(), + &context(util::path!("/root/Project.toml")), + )); + } + + #[test] + fn document_selector_relative_pattern_matches_base_document() -> Result<()> { + for (base_uri, pattern, path, path_style, expected) in [ + ( + "file:///root/a.rs", + "**", + "/root/a.rs", + PathStyle::Unix, + true, + ), + ( + "file:///root/a.rs", + "**", + "/root/a.rsx", + PathStyle::Unix, + false, + ), + ("file:///root/a.rs", "**", "/root", PathStyle::Unix, false), + ( + "file:///root/a.rs", + "*.rs", + "/root/a.rs", + PathStyle::Unix, + false, + ), + ( + "file:///C:/repo/a.rs", + "**", + r"c:\repo\A.rs", + PathStyle::Windows, + true, + ), + ( + "file:///C:/repo/a.rs", + "**", + r"C:\repo\a.rsx", + PathStyle::Windows, + false, + ), + ] { + let selector = pattern_selector( + None, + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right(base_uri.parse()?), + pattern: pattern.to_string(), + }), + ); + let context = toml_file_context(DocumentSelectorPath::present(path, path_style)); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "base {base_uri:?}, pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[cfg(unix)] + #[gpui::test] + fn document_selector_pattern_matches_windows_remote_worktree(cx: &mut TestAppContext) { + assert_eq!(PathStyle::local(), PathStyle::Unix); + let worktree = cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + Worktree::remote( + 1, + clock::ReplicaId::new(1), + proto::WorktreeMetadata { + id: 1, + root_name: "repo".to_string(), + visible: true, + abs_path: r"C:\repo".to_string(), + ..Default::default() + }, + AnyProtoClient::new(rpc::NoopProtoClient::new()), + PathStyle::Windows, + cx, + ) + }); + cx.read(|cx| { + let file = File::from_proto( + proto::File { + worktree_id: 1, + path: "sub/Project.toml".to_string(), + ..Default::default() + }, + worktree.clone(), + cx, + ) + .expect("valid remote file"); + assert!(worktree.read(cx).as_remote().is_some()); + assert!(!file.is_local); + assert_eq!( + file.abs_path(cx), + PathBuf::from(r"C:\repo\sub\Project.toml") + ); + let context = toml_file_context(DocumentSelectorPath::for_file(&file, cx)); + match &context.path { + DocumentSelectorPath::Present { path, path_style } => { + assert_eq!(path, "C:/repo/sub/Project.toml"); + assert_eq!(*path_style, PathStyle::Windows); + } + path => panic!("expected the remote file's absolute path, got {path:?}"), + } + for (pattern, expected) in [ + ("c:/repo/**/Project.toml", true), + ("c:/repo/**/Manifest.toml", false), + ("d:/repo/**/Project.toml", false), + ] { + let selector = + pattern_selector(Some("toml"), lsp::GlobPattern::String(pattern.to_string())); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "string pattern {pattern:?}", + ); + } + for (base_uri, expected) in [ + ("file:///c%3A/repo", true), + ("file:///d%3A/repo", false), + ("file:///c%3A/rep", false), + ] { + let selector = pattern_selector( + Some("toml"), + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right(base_uri.parse().expect("valid Windows file URI")), + pattern: "sub/*.toml".to_string(), + }), + ); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "relative pattern base {base_uri:?}", + ); + } + }); + } + + #[test] + fn document_selector_pattern_matches_paths_in_the_host_path_style() { + // Remote clients match the paths of hosts with another path style than their own. + let windows_context = + |path: &str| toml_file_context(DocumentSelectorPath::present(path, PathStyle::Windows)); + let absolute_selector = pattern_selector( + None, + lsp::GlobPattern::String("C:/repo/**/Project.toml".to_string()), + ); + assert!(document_selector_matches( + absolute_selector.as_ref(), + &windows_context(r"C:\repo\sub\Project.toml"), + )); + assert!(!document_selector_matches( + absolute_selector.as_ref(), + &windows_context(r"D:\repo\sub\Project.toml"), + )); + + let relative_selector = pattern_selector( + None, + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right("file:///c%3A/repo".parse().unwrap()), + pattern: "sub/*.toml".to_string(), + }), + ); + assert!( + document_selector_matches( + relative_selector.as_ref(), + &windows_context(r"C:\repo\sub\Project.toml"), + ), + "the base URI must be read in the host path style, ignoring the drive letter case", + ); + assert!(!document_selector_matches( + relative_selector.as_ref(), + &windows_context(r"C:\repository\sub\Project.toml"), + )); + + let unix_context = toml_file_context(DocumentSelectorPath::present( + r"/repo/sub\Project.toml", + PathStyle::Unix, + )); + assert!( + !document_selector_matches( + pattern_selector(None, lsp::GlobPattern::String("**/sub/*.toml".to_string())) + .as_ref(), + &unix_context, + ), + "backslashes are not separators in Unix paths", + ); + } + + #[test] + fn document_selector_absolute_pattern_normalizes_windows_drive_letter() { + for (pattern, path, expected) in [ + ("c:/repo/a.rs", r"C:\repo\a.rs", true), + ("C:/repo/a.rs", r"c:\repo\a.rs", true), + ("C:/repo/a.rs", r"C:\repo\a.rs", true), + ("c:/repo/a.rs", r"c:\repo\a.rs", true), + ("c:/repo/**/a.rs", r"C:\repo\sub\a.rs", true), + // Braces can enclose or produce drive prefixes. + ("{C:/repo,D:/repo}/a.rs", r"C:\repo\a.rs", true), + ("{c:/repo,d:/repo}/a.rs", r"C:\repo\a.rs", true), + ("{C,D}:/repo/a.rs", r"c:\repo\a.rs", true), + ("{D:/repo,E:/repo}/a.rs", r"C:\repo\a.rs", false), + ("{C:/Repo,D:/repo}/a.rs", r"C:\repo\a.rs", false), + ("c:/repo/a.rs", r"D:\repo\a.rs", false), + ("c:/Repo/a.rs", r"C:\repo\a.rs", false), + ("c:/repo/A.rs", r"C:\repo\a.rs", false), + ("c:/Équipe/a.rs", r"C:\équipe\a.rs", false), + ("//server/Share/a.rs", r"\\server\share\a.rs", false), + ] { + let selector = pattern_selector(None, lsp::GlobPattern::String(pattern.to_string())); + let context = + toml_file_context(DocumentSelectorPath::present(path, PathStyle::Windows)); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "pattern {pattern:?}, path {path:?}", + ); + } + } + + #[test] + fn document_selector_relative_pattern_matches_unicode_windows_base() -> Result<()> { + for (base_uri, pattern, path, expected) in [ + ("file:///C:/%C3%89quipe", "a.rs", r"C:\équipe\a.rs", true), + ("file:///c:/%C3%A9quipe", "a.rs", r"C:\Équipe\a.rs", true), + ("file:///C:/%E2%84%AA", "a.rs", r"c:\k\a.rs", true), + ("file:///c:/k", "a.rs", r"C:\K\a.rs", true), + ("file:///C:/%C3%89quipe/", "a.rs", r"c:\équipe\a.rs", true), + ( + "file://server/%C3%89quipe", + "a.rs", + r"\\SERVER\équipe\a.rs", + true, + ), + ("file:///C:/", "Équipe/a.rs", r"c:\Équipe\a.rs", true), + ("file:///C:/%C3%89quipe", "a.rs", r"C:\équipe\A.rs", false), + ( + "file:///C:/%C3%89quipe", + "Sub/a.rs", + r"C:\équipe\sub\a.rs", + false, + ), + ( + "file:///C:/%C3%89quipe", + "a.rs", + r"C:\équipement\a.rs", + false, + ), + ("file:///C:/%E2%84%AA", "a.rs", r"C:\kelvin\a.rs", false), + ("file:///C:/%C3%89quipe", "a.rs", r"D:\équipe\a.rs", false), + ] { + let selector = pattern_selector( + None, + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right(base_uri.parse()?), + pattern: pattern.to_string(), + }), + ); + let context = + toml_file_context(DocumentSelectorPath::present(path, PathStyle::Windows)); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "base {base_uri:?}, pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_selector_patterns_preserve_unix_case() -> Result<()> { + for pattern in ["/C:/repo/a.rs", "/Équipe/a.rs"] { + let selector = pattern_selector(None, lsp::GlobPattern::String(pattern.to_string())); + let context = toml_file_context(DocumentSelectorPath::present( + &pattern.to_lowercase(), + PathStyle::Unix, + )); + assert!(!document_selector_matches(selector.as_ref(), &context)); + } + + for (base_uri, path, expected) in [ + ("file:///%C3%89quipe", "/équipe/a.rs", false), + ("file:///%E2%84%AA", "/k/a.rs", false), + ("file:///%C3%89quipe", "/Équipe/a.rs", true), + ("file:///", "/a.rs", true), + ] { + let selector = pattern_selector( + None, + lsp::GlobPattern::Relative(lsp::RelativePattern { + base_uri: OneOf::Right(base_uri.parse()?), + pattern: "a.rs".to_string(), + }), + ); + let context = toml_file_context(DocumentSelectorPath::present(path, PathStyle::Unix)); + assert_eq!( + document_selector_matches(selector.as_ref(), &context), + expected, + "base {base_uri:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_filter_brace_alternatives_preserve_path_segments() -> Result<()> { + for (pattern, path, expected) in [ + ("/root/{**,src}/a.rs", "/root/a.rs", true), + ("/root/{**,src}/a.rs", "/root/sub/a.rs", true), + ("/root/{**,src}/a.rs", "/root/src/a.rs", true), + ("/root/{**,src}/a.rs", "/root/b.rs", false), + ("/root/{**,src}/a.rs", "/rooted/a.rs", false), + ("/root/{**,src}", "/root", true), + ("/root/{**,src}/**", "/root", true), + ("/root/{*,src}*/a.rs", "/root/a.rs", true), + ("/{root/**,other}/a.rs", "/root/a.rs", true), + ("/root/{src/,}a.rs", "/root/a.rs", true), + ("/root/{,src/}a.rs", "/root/src/a.rs", true), + ("/root/{,src}/a.rs", "/root/a.rs", false), + ("/root/{,src}/a.rs", "/root//a.rs", true), + ("/root/{src,{lib,tests}}/a.rs", "/root/lib/a.rs", true), + ("/root/{src,lib}/{a,b}.rs", "/root/lib/b.rs", true), + ("/root/{}a.rs", "/root/a.rs", true), + ] { + let matcher = compile_document_filter_glob(pattern, false)?; + assert_eq!( + matcher.is_match(path), + expected, + "pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_filter_braces_in_character_classes_are_literal() -> Result<()> { + for (pattern, path, expected) in [ + ("**/{[}],a}.rs", "/root/}.rs", true), + ("**/{[}],a}.rs", "/root/a.rs", true), + ("**/{[}],a}.rs", "/root/b.rs", false), + ("**/[{]/**/a.rs", "/root/{/a.rs", true), + ("**/[{]/**/a.rs", "/root/{/sub/a.rs", true), + ("**/[{]/**/a.rs", "/root/other/a.rs", false), + ("**/{[{],[}]}.rs", "/root/{.rs", true), + ("**/{[{],[}]}.rs", "/root/}.rs", true), + ("**/{[]}],a}.rs", "/root/].rs", true), + ("**/{[]}],a}.rs", "/root/}.rs", true), + ("**/{[,],a}.rs", "/root/,.rs", true), + ("**/{[!]],a}.rs", "/root/b.rs", true), + ("**/{[!]],a}.rs", "/root/].rs", false), + ] { + let matcher = compile_document_filter_glob(pattern, false)?; + assert_eq!( + matcher.is_match(path), + expected, + "pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_filter_brace_expansion_is_bounded() -> Result<()> { + assert_eq!( + expand_glob_braces(&"{a,b}".repeat(8))?.len(), + DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES, + ); + assert!(expand_glob_braces(&"{a,b}".repeat(9)).is_err()); + + let empty_alternatives = format!( + "{{{}}}", + ",".repeat(DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES - 1) + ); + assert_eq!( + expand_glob_braces(&empty_alternatives)?.len(), + DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES, + ); + let too_many_empty_alternatives = + format!("{{{}}}", ",".repeat(DOCUMENT_FILTER_GLOB_MAX_ALTERNATIVES)); + assert!(expand_glob_braces(&too_many_empty_alternatives).is_err()); + + let at_size_limit = "a".repeat(DOCUMENT_FILTER_GLOB_MAX_BYTES); + assert_eq!(expand_glob_braces(&at_size_limit)?, vec![at_size_limit]); + assert!(expand_glob_braces(&"a".repeat(DOCUMENT_FILTER_GLOB_MAX_BYTES + 1)).is_err()); + let deeply_nested = format!("{}a{}", "{".repeat(2048), "}".repeat(2048)); + assert!(expand_glob_braces(&deeply_nested).is_err()); + let large_regex = "*a".repeat(DOCUMENT_FILTER_GLOB_MAX_BYTES / 4); + assert!( + compile_document_filter_glob(&large_regex, false) + .expect_err("the generated regex must also have a bounded size") + .to_string() + .contains("compiled pattern size limit") + ); + Ok(()) + } + + #[test] + fn document_filter_globstar_runs_match_path_segments() -> Result<()> { + for (pattern, path, expected) in [ + ("/root/**/**", "/root/a.rs", true), + ("/root/**/**", "/root/sub/a.rs", true), + ("/root/**/**", "/root", true), + ("/root/**/**", "/root/", true), + ("/root/**/**", "/rooted/a.rs", false), + ("/root/**", "/rooted/", false), + ("/root/**/**", "/rooted//a.rs", false), + ("/root/**", "/root//a.rs", true), + ("/root/**", "/root/a\nb.rs", true), + ("/root/**/a.rs", "/root/sub\ndir/a.rs", true), + ("**", "/root/a\nb.rs", true), + ("**/**", "/root/a\nb.rs", true), + ("/**", "", false), + ("/**", "a.rs", false), + ("/**", "/", true), + ("/**", "/a.rs", true), + ("/", "/", true), + ("a/", "a", false), + ("a/", "a/", true), + ("/root/**/", "/root/sub", false), + ("/root/**/", "/root/sub/", true), + ("/root/**/**/**", "/root/a.rs", true), + ("/root/**/**/a.rs", "/root/a.rs", true), + ("/root/**/**/a.rs", "/root/sub/a.rs", true), + ("/root/**/**/a.rs", "/root/sub/b.rs", false), + ("**/**/a.rs", "a.rs", true), + ("**/**/a.rs", "/root/sub/a.rs", true), + ("**/**", "", true), + ("**/**", "a.rs", true), + ("**/**", "/root/a.rs", true), + ("/root/root/**/**", "/root/a.rs", false), + ("/root/root/**/**", "/root/root/a.rs", true), + ("/root/**/**/{a.rs,b.rs}", "/root/b.rs", true), + ] { + let matcher = compile_document_filter_glob(pattern, false)?; + assert_eq!( + matcher.is_match(path), + expected, + "pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_filter_character_classes_do_not_match_separators() -> Result<()> { + for (pattern, path, expected) in [ + ("**/a[!x]b.rs", "/root/a/b.rs", false), + ("**/a[!x]b.rs", "/root/axb.rs", false), + ("**/a[!x]b.rs", "/root/a0b.rs", true), + ("**/a[!x]b.rs", "/root/aéb.rs", true), + ("**/a[.-0]b.rs", "/root/a/b.rs", false), + ("**/a[.-0]b.rs", "/root/a.b.rs", true), + ("**/a[.-0]b.rs", "/root/a0b.rs", true), + ("**/a[.-0]b.rs", "/root/a-b.rs", false), + ("**/a[/]b.rs", "/root/a/b.rs", false), + ("**/a[!/]b.rs", "/root/a/b.rs", false), + ("**/a[!/]b.rs", "/root/aéb.rs", true), + ("**/a[.-/]b.rs", "/root/a/b.rs", false), + ("**/a[.-/]b.rs", "/root/a.b.rs", true), + ("**/a[.-/]b.rs", "/root/a-b.rs", false), + ("**/a[/-0]b.rs", "/root/a/b.rs", false), + ("**/a[/-0]b.rs", "/root/a0b.rs", true), + ("**/a[/-0]b.rs", "/root/a-b.rs", false), + ("**/a[é]b.rs", "/root/aéb.rs", true), + ("**/a[!é]b.rs", "/root/aéb.rs", false), + ("**/a[!é]b.rs", "/root/a/b.rs", false), + ("**/a[[]b.rs", "/root/a[b.rs", true), + ("**/a[]]b.rs", "/root/a]b.rs", true), + ("**/a[x-]b.rs", "/root/a-b.rs", true), + ] { + let matcher = compile_document_filter_glob(pattern, false)?; + assert_eq!( + matcher.is_match(path), + expected, + "pattern {pattern:?}, path {path:?}", + ); + } + Ok(()) + } + + #[test] + fn document_filter_pattern_matches_characters() { + let matches = |pattern: &str, path: &str| { + DocumentFilterPattern::new(&lsp::GlobPattern::String(pattern.to_string())) + .expect("valid pattern") + .matches(path, PathStyle::Unix) + }; + + // `?` and character classes match characters, not bytes. + assert!(matches("**/?.rs", "/root/a.rs")); + assert!(matches("**/?.rs", "/root/é.rs")); + assert!(matches("**/[é].rs", "/root/é.rs")); + assert!(!matches("**/?.rs", "/root/ab.rs")); + + assert!(matches("**/*.{rs,toml}", "/root/Project.toml")); + assert!(!matches("**/*.{rs,toml}", "/root/Project.json")); + assert!(matches("**/[!a].rs", "/root/b.rs")); + assert!(!matches("**/[!a].rs", "/root/a.rs")); + assert!(matches("**/[a-c].rs", "/root/b.rs")); + assert!(!matches("**/[a-c].rs", "/root/d.rs")); + + // A `-` is a range operator only between two members; elsewhere it is literal. + assert!(matches("**/[--0].rs", "/root/..rs")); + assert!(!matches("**/[!--0].rs", "/root/..rs")); + assert!(matches("**/[!--0].rs", "/root/a.rs")); + assert!(matches("**/[-a].rs", "/root/-.rs")); + assert!(!matches("**/[-a].rs", "/root/b.rs")); + assert!(matches("**/[a-].rs", "/root/-.rs")); + assert!(matches("**/[!-a].rs", "/root/b.rs")); + assert!(!matches("**/[!-a].rs", "/root/-.rs")); + assert!(matches("**/[a-c-e].rs", "/root/-.rs")); + assert!(matches("**/[a-c-e].rs", "/root/e.rs")); + assert!(!matches("**/[a-c-e].rs", "/root/d.rs")); + + assert!(matches("/root/**", "/root/sub/a.rs")); + assert!(matches("/root/**/a.rs", "/root/a.rs")); + assert!(matches("/root/**/a.rs", "/root/sub/a.rs")); + assert!(!matches("/root/**/a.rs", "/rooted/a.rs")); + assert!(!matches("/root/*.rs", "/root/sub/a.rs")); + + for invalid_pattern in [ + "**/[a.rs", + "**/{a,b.rs", + "**/{[}],a.rs", + "**/{a,{b,c}", + "**/[0--].rs", + ] { + assert!( + DocumentFilterPattern::new(&lsp::GlobPattern::String(invalid_pattern.to_string())) + .is_err(), + "expected {invalid_pattern:?} to be rejected", + ); } } @@ -17571,11 +18732,11 @@ mod tests { collections::IndexMap::from_iter([( "rename-registration".to_string(), dynamic_registration::DynamicTextDocumentRegistration { - document_selector: Some(vec![lsp::DocumentFilter { + document_selector: Some(compiled_selector(vec![lsp::DocumentFilter { language: Some(language.to_string()), scheme: Some("file".to_string()), pattern: None, - }]), + }])), server_capabilities: rename_capabilities(), }, )]) diff --git a/crates/project/src/lsp_store/dynamic_registration.rs b/crates/project/src/lsp_store/dynamic_registration.rs index 7572f4a5ef8..1ae77ca44d4 100644 --- a/crates/project/src/lsp_store/dynamic_registration.rs +++ b/crates/project/src/lsp_store/dynamic_registration.rs @@ -15,7 +15,7 @@ use lsp::{ }; use crate::lsp_store::{ - LanguageServerState, LspStore, RenamePathsWatchedForServer, + CompiledDocumentSelector, LanguageServerState, LspStore, RenamePathsWatchedForServer, completion_trigger_characters_for_buffer, lsp_workspace_diagnostics_refresh, }; @@ -55,7 +55,7 @@ impl CapabilityRegistrationChange { #[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)] pub(super) struct DynamicTextDocumentRegistration { - pub(super) document_selector: Option, + pub(super) document_selector: Option, pub(super) server_capabilities: lsp::ServerCapabilities, } @@ -83,6 +83,9 @@ impl LspStore { cx: &mut Context, capability_of: impl Fn(&mut lsp::ServerCapabilities) -> &mut Option, ) -> anyhow::Result { + let document_selector = document_selector + .map(CompiledDocumentSelector::new) + .transpose()?; let server_id = server.server_id(); let local = self .as_local_mut() @@ -230,6 +233,9 @@ impl LspStore { sync_options: lsp::TextDocumentSyncOptions, cx: &mut Context, ) -> anyhow::Result<()> { + let document_selector = document_selector + .map(CompiledDocumentSelector::new) + .transpose()?; let local = self .as_local_mut() .context("Expected LSP Store to be local")?; @@ -476,7 +482,7 @@ impl LspStore { for handle in buffers_with_language_server { handle.update(cx, |buffer, cx| { let triggers = - completion_trigger_characters_for_buffer(local, server_id, adapter, buffer); + completion_trigger_characters_for_buffer(local, server_id, adapter, buffer, cx); buffer.set_completion_triggers(server_id, triggers, cx); }); } @@ -491,7 +497,7 @@ impl LspStore { let server = self .language_server_for_id(server_id) .with_context(|| format!("no server {server_id} found"))?; - for reg in params.registrations { + let mut register_capability = |reg: lsp::Registration| -> Result<()> { match reg.method.as_str() { "workspace/didChangeWatchedFiles" => { if let Some(options) = reg.register_options { @@ -1035,6 +1041,26 @@ impl LspStore { } _ => log::warn!("unhandled capability registration: {reg:?}"), } + Ok(()) + }; + + // Keep valid siblings even when a batch is partially invalid, but report its failures + // to the server rather than acknowledging the whole batch as successful. + let mut registration_errors = Vec::new(); + for registration in params.registrations { + let method = registration.method.clone(); + let registration_id = registration.id.clone(); + if let Err(error) = register_capability(registration) { + registration_errors.push(format!( + "server {server_id}, method {method}, registration {registration_id:?}: {error:#}" + )); + } + } + if !registration_errors.is_empty() { + anyhow::bail!( + "Failed to register server capabilities:\n{}", + registration_errors.join("\n") + ); } Ok(()) diff --git a/crates/project/src/lsp_store/semantic_tokens.rs b/crates/project/src/lsp_store/semantic_tokens.rs index 06d3b65fd48..2bb3b00540b 100644 --- a/crates/project/src/lsp_store/semantic_tokens.rs +++ b/crates/project/src/lsp_store/semantic_tokens.rs @@ -27,8 +27,8 @@ use crate::{ SemanticTokensResponse, }, lsp_store::{ - LanguageServerState, document_selector_context_for_language, document_selector_matches, - missing_servers_to_query, + DocumentSelectorPath, LanguageServerState, document_selector_context_for_language, + document_selector_matches, missing_servers_to_query, }, project_settings::ProjectSettings, }; @@ -576,7 +576,11 @@ impl LspStore { } if let Some(initial_capabilities) = self.lsp_server_initial_capabilities.get(&server_id) { - let context = self.remote_document_selector_context(server_id, language); + let context = self.remote_document_selector_context( + server_id, + language, + DocumentSelectorPath::Unknown, + ); if let Some(registrations) = self .lsp_server_text_document_registrations .get(&server_id) diff --git a/crates/project/tests/integration/dynamic_registration.rs b/crates/project/tests/integration/dynamic_registration.rs index fdc8f37f409..8b1e0300720 100644 --- a/crates/project/tests/integration/dynamic_registration.rs +++ b/crates/project/tests/integration/dynamic_registration.rs @@ -3040,6 +3040,431 @@ async fn edit_and_receive_change( (params.text_document.uri, change.range.is_some()) } +#[gpui::test] +async fn test_registration_pattern_scopes_capability_to_matching_documents( + cx: &mut gpui::TestAppContext, +) { + init_test(cx); + let (project, fake_server) = + setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await; + let fs = project.read_with(cx, |project, _| project.fs().as_fake()); + fs.insert_tree(path!("/the-root"), json!({ "b.rs": "" })) + .await; + let method = "textDocument/completion"; + + let (buffer_a, _lsp_handle_a) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx) + }) + .await + .unwrap(); + let (buffer_b, _lsp_handle_b) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/b.rs"), cx) + }) + .await + .unwrap(); + let buffer_triggers = |buffer: &Entity, cx: &mut gpui::TestAppContext| { + buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone()) + }; + + let error = register_capabilities( + &fake_server, + vec![lsp::Registration { + id: "completion-invalid-pattern".to_string(), + method: method.to_string(), + register_options: Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/[a.rs" }], + "triggerCharacters": [":"], + })), + }], + ) + .await + .expect_err("an invalid selector pattern should produce an error response"); + assert!( + error + .to_string() + .contains("invalid document filter pattern") + ); + cx.executor().run_until_parked(); + assert_eq!( + server_capabilities(&project, fake_server.server.server_id(), cx).completion_provider, + None, + "expected a registration with an invalid pattern to be rejected", + ); + + register_capability( + &fake_server, + method, + "completion-a", + Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/a.rs" }], + "triggerCharacters": ["."], + })), + ) + .await; + cx.executor().run_until_parked(); + assert_eq!( + buffer_triggers(&buffer_a, cx), + BTreeSet::from([".".to_string()]), + "expected the registration to apply to the document matching its pattern", + ); + assert_eq!( + buffer_triggers(&buffer_b, cx), + BTreeSet::new(), + "expected the registration not to apply to a document outside its pattern", + ); +} + +#[gpui::test] +async fn test_registration_batch_applies_valid_siblings_and_reports_errors( + cx: &mut gpui::TestAppContext, +) { + init_test(cx); + let (project, fake_server) = + setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await; + let server_id = fake_server.server.server_id(); + let (buffer, _lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx) + }) + .await + .unwrap(); + let (events, _subscription) = observe_refresh_events(&project, cx); + let mut registrations = vec![ + lsp::Registration { + id: "hover-valid".to_string(), + method: "textDocument/hover".to_string(), + register_options: None, + }, + lsp::Registration { + id: "completion-invalid".to_string(), + method: "textDocument/completion".to_string(), + register_options: Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/[a.rs" }], + "triggerCharacters": ["."], + })), + }, + lsp::Registration { + id: "formatting-valid".to_string(), + method: "textDocument/formatting".to_string(), + register_options: None, + }, + lsp::Registration { + id: "code-lens-invalid".to_string(), + method: "textDocument/codeLens".to_string(), + register_options: Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/[b.rs" }], + "resolveProvider": true, + })), + }, + ]; + + let error = register_capabilities(&fake_server, registrations.clone()) + .await + .expect_err("a mixed registration batch should produce an error response") + .to_string(); + for (method, registration_id, pattern) in [ + ("textDocument/completion", "completion-invalid", "**/[a.rs"), + ("textDocument/codeLens", "code-lens-invalid", "**/[b.rs"), + ] { + assert!( + error.contains(&format!( + "server {server_id}, method {method}, registration {registration_id:?}" + )), + "expected the failed registration's context in {error}", + ); + assert!( + error.contains(pattern), + "expected the failed registration's pattern in {error}", + ); + } + cx.executor().run_until_parked(); + + let capabilities = server_capabilities(&project, server_id, cx); + assert_eq!( + capabilities.hover_provider, + Some(lsp::HoverProviderCapability::Simple(true)), + ); + assert_eq!(capabilities.completion_provider, None); + assert_eq!( + capabilities.document_formatting_provider, + Some(lsp::OneOf::Left(true)), + ); + assert_eq!(capabilities.code_lens_provider, None); + buffer.read_with(cx, |buffer, _| { + assert!(buffer.completion_triggers().is_empty()); + }); + assert!( + events.lock().is_empty(), + "a failed registration must not trigger its refresh followup", + ); + + for registration in &mut registrations { + if let Some(options) = registration.register_options.as_mut() { + options["documentSelector"] = json!([{ "language": "rust", "pattern": "**/a.rs" }]); + } + } + register_capabilities(&fake_server, registrations) + .await + .expect("an all-valid registration batch should produce a success response"); + cx.executor().run_until_parked(); + + let capabilities = server_capabilities(&project, server_id, cx); + assert_eq!( + capabilities.completion_provider, + Some(lsp::CompletionOptions { + trigger_characters: Some(vec![".".to_string()]), + ..lsp::CompletionOptions::default() + }), + ); + assert_eq!( + capabilities.code_lens_provider, + Some(lsp::CodeLensOptions { + resolve_provider: Some(true), + }), + ); + buffer.read_with(cx, |buffer, _| { + assert_eq!( + buffer.completion_triggers(), + &BTreeSet::from([".".to_string()]), + ); + }); + assert_eq!(*events.lock(), vec![format!("code_lens({server_id})")]); +} + +#[gpui::test] +async fn test_invalid_registration_pattern_preserves_previous_registration( + cx: &mut gpui::TestAppContext, +) { + init_test(cx); + let (project, fake_server) = + setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await; + let server_id = fake_server.server.server_id(); + let (buffer, _lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx) + }) + .await + .unwrap(); + let method = "textDocument/completion"; + let registration_id = "completion-a"; + register_capability( + &fake_server, + method, + registration_id, + Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/a.rs" }], + "triggerCharacters": ["."], + })), + ) + .await; + cx.executor().run_until_parked(); + let previous_capabilities = server_capabilities(&project, server_id, cx); + + let error = register_capabilities( + &fake_server, + vec![lsp::Registration { + id: registration_id.to_string(), + method: method.to_string(), + register_options: Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": "**/[a.rs" }], + "triggerCharacters": [":"], + })), + }], + ) + .await + .expect_err("an invalid replacement should produce an error response"); + assert!( + error + .to_string() + .contains("invalid document filter pattern") + ); + cx.executor().run_until_parked(); + assert_eq!( + server_capabilities(&project, server_id, cx), + previous_capabilities, + ); + buffer.read_with(cx, |buffer, _| { + assert_eq!( + buffer.completion_triggers(), + &BTreeSet::from([".".to_string()]), + ); + }); + + let fs = project.read_with(cx, |project, _| project.fs().as_fake()); + fs.insert_tree( + path!("/the-root"), + json!({ "nested": { "a.rs": "", "b.rs": "" } }), + ) + .await; + for (path, expected_triggers) in [ + ( + path!("/the-root/nested/a.rs"), + BTreeSet::from([".".to_string()]), + ), + (path!("/the-root/nested/b.rs"), BTreeSet::new()), + ] { + let (new_buffer, _lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path, cx) + }) + .await + .unwrap(); + new_buffer.read_with(cx, |buffer, _| { + assert_eq!(buffer.completion_triggers(), &expected_triggers); + }); + } +} + +#[gpui::test] +async fn test_invalid_sync_registration_pattern_preserves_previous_registration( + cx: &mut gpui::TestAppContext, +) { + init_test(cx); + let (project, mut fake_server) = + setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await; + let (buffer, _lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx) + }) + .await + .unwrap(); + let uri = lsp::Uri::from_file_path(path!("/the-root/a.rs")).unwrap(); + + // Test builds send incremental changes without a sync kind, so the registered `FULL` sync + // tells whether the registration still applies. + for (method, registration_id, options) in [ + ( + "textDocument/didChange", + "change-a", + json!({ "syncKind": 1 }), + ), + ( + "textDocument/didSave", + "save-a", + json!({ "includeText": false }), + ), + ] { + let register_options = |pattern: &str| { + let mut register_options = options.clone(); + register_options["documentSelector"] = json!([{ "pattern": pattern }]); + register_options + }; + register_capability( + &fake_server, + method, + registration_id, + Some(register_options("**/a.rs")), + ) + .await; + let error = register_capabilities( + &fake_server, + vec![lsp::Registration { + id: registration_id.to_string(), + method: method.to_string(), + register_options: Some(register_options("**/[a.rs")), + }], + ) + .await + .expect_err("an invalid replacement should produce an error response"); + assert!( + error + .to_string() + .contains("invalid document filter pattern"), + "unexpected error for an invalid {method} replacement: {error:#}", + ); + } + cx.executor().run_until_parked(); + + assert_eq!( + edit_and_receive_change(&buffer, &mut fake_server, cx).await, + (uri.clone(), false), + "expected the previous didChange registration to remain in effect", + ); + project + .update(cx, |project, cx| project.save_buffer(buffer.clone(), cx)) + .await + .unwrap(); + assert_eq!( + fake_server + .receive_notification::() + .await + .text_document + .uri, + uri, + "expected the previous didSave registration to remain in effect", + ); +} + +#[gpui::test] +async fn test_registration_patterns_respect_globstar_and_character_class_separators( + cx: &mut gpui::TestAppContext, +) { + init_test(cx); + let (project, fake_server) = + setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await; + let fs = project.read_with(cx, |project, _| project.fs().as_fake()); + fs.insert_tree( + path!("/the-root"), + json!({ "a0b.rs": "", "a": { "b.rs": "" } }), + ) + .await; + + let (flat_buffer, _flat_lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a0b.rs"), cx) + }) + .await + .unwrap(); + let (nested_buffer, _nested_lsp_handle) = project + .update(cx, |project, cx| { + project.open_local_buffer_with_lsp(path!("/the-root/a/b.rs"), cx) + }) + .await + .unwrap(); + let buffer_triggers = |buffer: &Entity, cx: &mut gpui::TestAppContext| { + buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone()) + }; + + let mut expected_flat_triggers = BTreeSet::new(); + for (id, pattern, trigger) in [ + ("completion-globstars", "**/the-root/**/**", "."), + ("completion-negated-class", "**/a[!x]b.rs", ":"), + ("completion-range-class", "**/a[.-0]b.rs", "!"), + ( + "completion-braced-globstar", + "**/the-root/{**,src}/a0b.rs", + ";", + ), + ("completion-literal-brace", "**/{[}],a0b}.rs", "?"), + ] { + register_capability( + &fake_server, + "textDocument/completion", + id, + Some(json!({ + "documentSelector": [{ "language": "rust", "pattern": pattern }], + "triggerCharacters": [trigger], + })), + ) + .await; + cx.executor().run_until_parked(); + + expected_flat_triggers.insert(trigger.to_string()); + assert_eq!( + buffer_triggers(&flat_buffer, cx), + expected_flat_triggers, + "expected {pattern} to enable its trigger for the flat filename", + ); + assert_eq!( + buffer_triggers(&nested_buffer, cx), + BTreeSet::from([".".to_string()]), + "expected only the globstar trigger for the nested path after registering {pattern}", + ); + } +} + async fn setup_dynamic_registration_test( cx: &mut gpui::TestAppContext, capabilities: lsp::ServerCapabilities, @@ -3080,20 +3505,29 @@ async fn register_capability( id: &str, register_options: Option, ) { + register_capabilities( + fake_server, + vec![lsp::Registration { + id: id.to_string(), + method: method.to_string(), + register_options, + }], + ) + .await + .unwrap(); +} + +async fn register_capabilities( + fake_server: &lsp::FakeLanguageServer, + registrations: Vec, +) -> anyhow::Result<()> { fake_server .request::( - lsp::RegistrationParams { - registrations: vec![lsp::Registration { - id: id.to_string(), - method: method.to_string(), - register_options, - }], - }, + lsp::RegistrationParams { registrations }, DEFAULT_LSP_REQUEST_TIMEOUT, ) .await .into_response() - .unwrap(); } async fn unregister_capabilities( diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rs index 2887f32b1c0..f1cbd4ce336 100644 --- a/crates/project/tests/integration/project_tests.rs +++ b/crates/project/tests/integration/project_tests.rs @@ -11419,7 +11419,7 @@ async fn test_dynamic_formatting_registrations_honor_document_selectors( } #[gpui::test] -async fn test_dynamic_formatting_registration_with_pattern_only_selector_fails_open( +async fn test_dynamic_formatting_registration_with_pattern_only_selector( cx: &mut gpui::TestAppContext, ) { init_test(cx); @@ -11466,40 +11466,55 @@ async fn test_dynamic_formatting_registration_with_pattern_only_selector_fails_o } }); - fake_server - .request::( - lsp::RegistrationParams { - registrations: vec![lsp::Registration { - id: "pattern-only-formatting".to_string(), - method: "textDocument/formatting".to_string(), - register_options: Some(json!({ - "documentSelector": [{ "pattern": "**/*.nomatch" }], - })), - }], - }, - DEFAULT_LSP_REQUEST_TIMEOUT, - ) - .await - .into_response() - .unwrap(); - cx.executor().run_until_parked(); - - project - .update(cx, |project, cx| { - project.format( - HashSet::from_iter([buffer.clone()]), - project::lsp_store::LspFormatTarget::Buffers, - false, - project::lsp_store::FormatTrigger::Manual, - cx, + let register_formatting = async |id: &str, pattern: &str| { + fake_server + .request::( + lsp::RegistrationParams { + registrations: vec![lsp::Registration { + id: id.to_string(), + method: "textDocument/formatting".to_string(), + register_options: Some(json!({ + "documentSelector": [{ "pattern": pattern }], + })), + }], + }, + DEFAULT_LSP_REQUEST_TIMEOUT, ) - }) - .await - .unwrap(); + .await + .into_response() + .unwrap(); + }; + let format = async |cx: &mut gpui::TestAppContext| { + project + .update(cx, |project, cx| { + project.format( + HashSet::from_iter([buffer.clone()]), + project::lsp_store::LspFormatTarget::Buffers, + false, + project::lsp_store::FormatTrigger::Manual, + cx, + ) + }) + .await + .unwrap(); + }; + + register_formatting("pattern-only-formatting", "**/*.nomatch").await; + cx.executor().run_until_parked(); + format(cx).await; + assert_eq!( + format_request_count.load(atomic::Ordering::SeqCst), + 0, + "expected a pattern-only filter not matching the buffer's path not to route the formatting request", + ); + + register_formatting("matching-pattern-formatting", "**/*.rs").await; + cx.executor().run_until_parked(); + format(cx).await; assert_eq!( format_request_count.load(atomic::Ordering::SeqCst), 1, - "expected a pattern-only filter to fail open and route the formatting request", + "expected a pattern-only filter matching the buffer's path to route the formatting request", ); }