Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
language: Fix incomplete bracket matches during error recovery (#61604)
mTvare200fb85c902b
diff --git a/crates/editor/src/input.rs b/crates/editor/src/input.rsindex 8192fc4a18f..b44b1bf6106 100644--- a/crates/editor/src/input.rs+++ b/crates/editor/src/input.rs@@ -2397,7 +2397,7 @@ impl NewlineConfig {_ => return false,};let pair = {- let mut result: Option<BracketMatch<usize>> = None;+ let mut result: Option<BracketMatch> = None;for pair in buffer.all_bracket_ranges(range.start.0..range.end.0)diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rsindex 67db23e04ce..8e2f6ee946e 100644--- a/crates/language/src/buffer.rs+++ b/crates/language/src/buffer.rs@@ -1,5 +1,8 @@+mod bracket_ranges;pub mod row_chunk;+pub use bracket_ranges::BracketMatch;+use crate::{ByteContent, DebuggerTextObject, LanguageScope, ModelineSettings, Outline, OutlineConfig,PLAIN_TEXT, RunnableTag, TextObject, TreeSitterOptions, analyze_byte_content,@@ -23,7 +26,7 @@ pub use crate::{use anyhow::{Context as _, Result};use clock::Lamport;pub use clock::ReplicaId;-use collections::{HashMap, HashSet};+use collections::HashMap;use encoding_rs::Encoding;use fs::MTime;use futures::channel::oneshot;@@ -144,7 +147,7 @@ pub struct Buffer {#[derive(Debug)]pub struct TreeSitterData {chunks: RowChunks,- brackets_by_chunks: Mutex<HashMap<usize, Vec<BracketMatch<usize>>>>,+ brackets_by_chunks: Mutex<HashMap<usize, Vec<BracketMatch>>>,}const MAX_ROWS_IN_A_CHUNK: u32 = 50;@@ -947,64 +950,6 @@ impl EditPreview {}}-#[derive(Clone, Debug, PartialEq, Eq)]-pub struct BracketMatch<T> {- pub open_range: Range<T>,- pub close_range: Range<T>,- pub newline_only: bool,- pub syntax_layer_depth: usize,- pub color_index: Option<usize>,-}--impl<T> BracketMatch<T> {- pub fn bracket_ranges(self) -> (Range<T>, Range<T>) {- (self.open_range, self.close_range)- }-}--/// A single bracket pair candidate produced by a brackets query, before-/// bogus tree-sitter matches are repaired and color indices are assigned.-#[derive(Clone, Debug)]-struct BracketMatchCandidate {- bracket_match: BracketMatch<usize>,- pattern: BracketPatternKey,- rainbow_exclude: bool,-}--impl BracketMatchCandidate {- fn open_delimiter(&self) -> BracketDelimiter {- BracketDelimiter {- start: self.bracket_match.open_range.start,- end: self.bracket_match.open_range.end,- pattern: self.pattern,- }- }-- fn close_delimiter(&self) -> BracketDelimiter {- BracketDelimiter {- start: self.bracket_match.close_range.start,- end: self.bracket_match.close_range.end,- pattern: self.pattern,- }- }-}--/// Identifies a brackets query pattern, unique across all grammars of a syntax map.-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]-struct BracketPatternKey {- grammar_index: usize,- pattern_index: usize,-}--/// One delimiter (open or close) of a bracket pair candidate.-/// Ordered by buffer position first, so sorting yields document order.-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]-struct BracketDelimiter {- start: usize,- end: usize,- pattern: BracketPatternKey,-}-impl Buffer {/// Create a new buffer with the given base text.pub fn local<T: Into<String>>(base_text: T, cx: &Context<Self>) -> Self {@@ -4809,339 +4754,6 @@ impl BufferSnapshot {self.syntax.matches(range, self, query)}- /// Finds all [`RowChunks`] applicable to the given range, then returns all bracket pairs that intersect with those chunks.- /// Hence, may return more bracket pairs than the range contains.- ///- /// Will omit known chunks.- /// The resulting bracket match collections are not ordered.- pub fn fetch_bracket_ranges(- &self,- range: Range<usize>,- known_chunks: Option<&HashSet<Range<BufferRow>>>,- ) -> HashMap<Range<BufferRow>, Vec<BracketMatch<usize>>> {- let mut all_bracket_matches = HashMap::default();- if self- .language- .as_ref()- .is_none_or(|language| language.grammar().is_none())- {- return all_bracket_matches;- }-- for chunk in self- .tree_sitter_data- .chunks- .applicable_chunks(&[range.to_point(self)])- {- if known_chunks.is_some_and(|chunks| chunks.contains(&chunk.row_range())) {- continue;- }- let chunk_range = chunk.anchor_range();- let chunk_range = chunk_range.to_offset(&self);-- if let Some(cached_brackets) = self- .tree_sitter_data- .brackets_by_chunks- .lock()- .get(&chunk.id)- {- all_bracket_matches.insert(chunk.row_range(), cached_brackets.clone());- continue;- }-- let mut all_brackets = Vec::new();- let mut opens = Vec::new();- let mut color_pairs = Vec::new();-- let bounded_query = (- chunk_range.clone(),- TreeSitterOptions {- max_bytes_to_query: Some(MAX_BYTES_TO_QUERY),- max_start_depth: None,- },- );- // The bounded query drops any pair spanning more than `MAX_BYTES_TO_QUERY`- // (tree-sitter's containing byte range requires full containment), which- // resets bracket depth at chunk boundaries. Every such pair encloses a- // chunk edge, so recover them with two point-sized unbounded queries that- // only traverse the syntax tree spine around each edge.- let boundary_queries = [chunk_range.start, chunk_range.end].map(|offset| {- (- self.clip_offset(offset.saturating_sub(1), Bias::Left)- ..self.clip_offset(offset.saturating_add(1), Bias::Right),- TreeSitterOptions::default(),- )- });-- let mut grammar_ids = Vec::new();- let mut configs = Vec::new();- let mut seen_delimiters = HashSet::default();- // Group matches by open delimiter so we can either trust grammar output- // or repair it by picking a single closest close per open.- let mut close_delimiters_by_open = BTreeMap::new();- let mut bogus_patterns = HashSet::default();- for (query_range, options) in iter::once(bounded_query).chain(boundary_queries) {- let mut matches =- self.syntax- .matches_with_options(query_range, &self.text, options, |grammar| {- grammar.brackets_config.as_ref().map(|c| &c.query)- });- let grammar_indices = matches- .grammars()- .iter()- .map(|grammar| {- grammar_ids- .iter()- .position(|&id| id == grammar.id())- .unwrap_or_else(|| {- grammar_ids.push(grammar.id());- configs.push(grammar.brackets_config.as_ref().unwrap());- grammar_ids.len() - 1- })- })- .collect::<Vec<_>>();-- while let Some(mat) = matches.peek() {- let mut open = None;- let mut close = None;- let syntax_layer_depth = mat.depth;- let grammar_index = grammar_indices[mat.grammar_index];- let pattern_key = BracketPatternKey {- grammar_index,- pattern_index: mat.pattern_index,- };- let config = configs[grammar_index];- let pattern = &config.patterns[mat.pattern_index];- for capture in mat.captures {- if capture.index == config.open_capture_ix {- open = Some(capture.node.byte_range());- } else if capture.index == config.close_capture_ix {- close = Some(capture.node.byte_range());- }- }-- matches.advance();-- let Some((open_range, close_range)) = open.zip(close) else {- continue;- };-- let bracket_range = open_range.start..=close_range.end;- if !bracket_range.overlaps(&chunk_range) {- continue;- }-- let candidate = BracketMatchCandidate {- bracket_match: BracketMatch {- open_range,- close_range,- syntax_layer_depth,- newline_only: pattern.newline_only,- color_index: None,- },- pattern: pattern_key,- rainbow_exclude: pattern.rainbow_exclude,- };-- if !seen_delimiters- .insert((candidate.open_delimiter(), candidate.close_delimiter()))- {- continue;- }-- let close_delimiters = close_delimiters_by_open- .entry(candidate.open_delimiter())- .or_insert_with(BTreeSet::new);- close_delimiters.insert(candidate.close_delimiter());- if close_delimiters.len() > 1 {- bogus_patterns.insert(pattern_key);- }-- all_brackets.push(candidate);- }- }-- if !bogus_patterns.is_empty() {- // Certain patterns produce bogus matches where one open is paired with multiple- // closes (e.g. same-character delimiters inside a single parent node).- // Repair only those patterns, keeping trustworthy grammar output intact:- // clean patterns may legitimately pair an open in one chunk with a close in- // another, and must not be dropped by the chunk-local repair below.- // For each close, we know the expected open_len from tree-sitter matches.- let is_bogus =- |candidate: &BracketMatchCandidate| bogus_patterns.contains(&candidate.pattern);-- // Map each close to its expected open length (for inferring opens)- let close_to_open_len = all_brackets- .iter()- .filter(|candidate| is_bogus(candidate))- .map(|candidate| {- (- candidate.close_delimiter(),- candidate.bracket_match.open_range.len(),- )- })- .collect::<HashMap<_, _>>();-- // Collect unique opens and closes within this chunk- let unique_opens = all_brackets- .iter()- .filter(|candidate| is_bogus(candidate))- .map(|candidate| candidate.open_delimiter())- .filter(|open| chunk_range.contains(&open.start))- .collect::<HashSet<_>>();-- let mut unique_closes = all_brackets- .iter()- .filter(|candidate| is_bogus(candidate))- .map(|candidate| candidate.close_delimiter())- .filter(|close| chunk_range.contains(&close.start))- .collect::<Vec<_>>();- unique_closes.sort_unstable();- unique_closes.dedup();-- // Build valid pairs by walking through closes in order- let mut sorted_opens = unique_opens.into_iter().collect::<Vec<_>>();- sorted_opens.sort_unstable();-- let mut valid_pairs = HashSet::default();- let mut open_stacks = HashMap::default();- let mut open_idx = 0;-- for close in &unique_closes {- // Push all opens before this close onto stack- while open_idx < sorted_opens.len()- && sorted_opens[open_idx].start < close.start- {- let open = sorted_opens[open_idx];- open_stacks- .entry(open.pattern)- .or_insert_with(Vec::new)- .push(open);- open_idx += 1;- }-- // Try to match with most recent open- if let Some(open) = open_stacks- .get_mut(&close.pattern)- .and_then(|open_stack| open_stack.pop())- {- valid_pairs.insert((open, *close));- } else if let Some(&open_len) = close_to_open_len.get(close) {- // No open on stack - infer one based on expected open_len- if close.start >= open_len {- let inferred = BracketDelimiter {- start: close.start - open_len,- end: close.start,- pattern: close.pattern,- };- valid_pairs.insert((inferred, *close));- let pattern = &configs[close.pattern.grammar_index].patterns- [close.pattern.pattern_index];- all_brackets.push(BracketMatchCandidate {- bracket_match: BracketMatch {- open_range: inferred.start..inferred.end,- close_range: close.start..close.end,- newline_only: pattern.newline_only,- syntax_layer_depth: 0,- color_index: None,- },- pattern: close.pattern,- rainbow_exclude: pattern.rainbow_exclude,- });- }- }- }-- all_brackets.retain(|candidate| {- !is_bogus(candidate)- || valid_pairs- .contains(&(candidate.open_delimiter(), candidate.close_delimiter()))- });- }-- let mut all_brackets = all_brackets- .into_iter()- .enumerate()- .map(|(index, candidate)| {- let bracket_match = candidate.bracket_match;- // Certain languages have "brackets" that are not brackets, e.g. tags. and such- // bracket will match the entire tag with all text inside.- // For now, avoid highlighting any pair that has more than single char in each bracket.- // We need to colorize `<Element/>` bracket pairs, so cannot make this check stricter.- let should_color = !candidate.rainbow_exclude- && (bracket_match.open_range.len() == 1- || bracket_match.close_range.len() == 1);- if should_color {- opens.push(bracket_match.open_range.clone());- color_pairs.push((- bracket_match.open_range.clone(),- bracket_match.close_range.clone(),- index,- ));- }- bracket_match- })- .collect::<Vec<_>>();-- opens.sort_by_key(|r| (r.start, r.end));- opens.dedup_by(|a, b| a.start == b.start && a.end == b.end);- color_pairs.sort_by_key(|(_, close, _)| close.end);-- let mut open_stack = Vec::new();- let mut open_index = 0;- for (open, close, index) in color_pairs {- while open_index < opens.len() && opens[open_index].start < close.start {- open_stack.push(opens[open_index].clone());- open_index += 1;- }-- if open_stack.last() == Some(&open) {- let depth_index = open_stack.len() - 1;- all_brackets[index].color_index = Some(depth_index);- open_stack.pop();- }- }-- all_brackets.sort_by_key(|bracket_match| {- (bracket_match.open_range.start, bracket_match.open_range.end)- });-- self.tree_sitter_data- .brackets_by_chunks- .lock()- .entry(chunk.id)- .or_insert_with(|| all_brackets.clone());- all_bracket_matches.insert(chunk.row_range(), all_brackets);- }-- all_bracket_matches- }-- pub fn all_bracket_ranges(- &self,- range: Range<usize>,- ) -> impl Iterator<Item = BracketMatch<usize>> {- self.fetch_bracket_ranges(range.clone(), None)- .into_values()- .flatten()- .filter(move |bracket_match| {- let bracket_range = bracket_match.open_range.start..bracket_match.close_range.end;- bracket_range.overlaps(&range)- })- }-- /// Returns bracket range pairs overlapping or adjacent to `range`- pub fn bracket_ranges<T: ToOffset>(- &self,- range: Range<T>,- ) -> impl Iterator<Item = BracketMatch<usize>> + '_ {- // Find bracket pairs that *inclusively* contain the given range.- let range = range.start.to_previous_offset(self)..range.end.to_next_offset(self);- self.all_bracket_ranges(range)- .filter(|pair| !pair.newline_only)- }-pub fn debug_variables_query<T: ToOffset>(&self,range: Range<T>,@@ -5277,61 +4889,6 @@ impl BufferSnapshot {})}- /// Returns enclosing bracket ranges containing the given range- pub fn enclosing_bracket_ranges<T: ToOffset>(- &self,- range: Range<T>,- ) -> impl Iterator<Item = BracketMatch<usize>> + '_ {- let range = range.start.to_offset(self)..range.end.to_offset(self);-- let result: Vec<_> = self.bracket_ranges(range.clone()).collect();- let max_depth = result- .iter()- .map(|mat| mat.syntax_layer_depth)- .max()- .unwrap_or(0);- result.into_iter().filter(move |pair| {- pair.open_range.start <= range.start- && pair.close_range.end >= range.end- && pair.syntax_layer_depth == max_depth- })- }-- /// Returns the smallest enclosing bracket ranges containing the given range or None if no brackets contain range- ///- /// Can optionally pass a range_filter to filter the ranges of brackets to consider- pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(- &self,- range: Range<T>,- range_filter: Option<&dyn Fn(Range<usize>, Range<usize>) -> bool>,- ) -> Option<(Range<usize>, Range<usize>)> {- let range = range.start.to_offset(self)..range.end.to_offset(self);-- // Get the ranges of the innermost pair of brackets.- let mut result: Option<(Range<usize>, Range<usize>)> = None;-- for pair in self.enclosing_bracket_ranges(range) {- if let Some(range_filter) = range_filter- && !range_filter(pair.open_range.clone(), pair.close_range.clone())- {- continue;- }-- let len = pair.close_range.end - pair.open_range.start;-- if let Some((existing_open, existing_close)) = &result {- let existing_len = existing_close.end - existing_open.start;- if len > existing_len {- continue;- }- }-- result = Some((pair.open_range, pair.close_range));- }-- result- }-/// Returns anchor ranges for any matches of the redaction query./// The buffer can be associated with multiple languages, and the redaction query associated with each/// will be run on the relevant section of the buffer.diff --git a/crates/language/src/buffer/bracket_ranges.rs b/crates/language/src/buffer/bracket_ranges.rsnew file mode 100644index 00000000000..fe38e9a034a--- /dev/null+++ b/crates/language/src/buffer/bracket_ranges.rs@@ -0,0 +1,866 @@+//! Bracket pair discovery for [`BufferSnapshot`]s.+//!+//! Bracket queries run per [`RowChunk`](super::row_chunk::RowChunk) and the results are+//! cached in [`TreeSitterData`](super::TreeSitterData) until the buffer is reparsed.+//! Tree-sitter error recovery can produce bogus or incomplete query matches, which are+//! repaired chunk-locally before caching, see [`ChunkBrackets`].++use std::{iter, ops::Range};++use collections::{HashMap, HashSet};+use text::{Bias, OffsetRangeExt, ToOffset};+use util::RangeExt;++use crate::{+ BracketsConfig, BufferRow, BufferSnapshot, Grammar, GrammarId, TreeSitterOptions,+ syntax_map::{MAX_BYTES_TO_QUERY, SyntaxLayer},+};++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct BracketMatch {+ pub open_range: Range<usize>,+ pub close_range: Range<usize>,+ pub newline_only: bool,+ pub syntax_layer_depth: usize,+ pub color_index: Option<usize>,+}++impl BracketMatch {+ pub fn bracket_ranges(self) -> (Range<usize>, Range<usize>) {+ (self.open_range, self.close_range)+ }+}++/// A single bracket pair candidate produced by a brackets query, before+/// bogus tree-sitter matches are repaired and color indices are assigned.+#[derive(Clone, Debug)]+struct BracketMatchCandidate {+ bracket_match: BracketMatch,+ pattern: BracketPatternKey,+ rainbow_exclude: bool,+}++impl BracketMatchCandidate {+ fn open_delimiter(&self) -> BracketDelimiter {+ BracketDelimiter {+ start: self.bracket_match.open_range.start,+ end: self.bracket_match.open_range.end,+ pattern: self.pattern,+ }+ }++ fn close_delimiter(&self) -> BracketDelimiter {+ BracketDelimiter {+ start: self.bracket_match.close_range.start,+ end: self.bracket_match.close_range.end,+ pattern: self.pattern,+ }+ }+}++/// Identifies a brackets query pattern, unique across all grammars of a syntax map.+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]+struct BracketPatternKey {+ grammar_index: usize,+ pattern_index: usize,+}++/// One delimiter (open or close) of a bracket pair candidate.+/// Ordered by buffer position first, so sorting yields document order.+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]+struct BracketDelimiter {+ start: usize,+ end: usize,+ pattern: BracketPatternKey,+}++type BracketDelimiterPair = (BracketDelimiter, BracketDelimiter);++impl BufferSnapshot {+ /// Finds all [`super::row_chunk::RowChunks`] applicable to the given range, then returns all bracket pairs that intersect with those chunks.+ /// Hence, may return more bracket pairs than the range contains.+ ///+ /// Will omit known chunks.+ /// The resulting bracket match collections are not ordered.+ pub fn fetch_bracket_ranges(+ &self,+ range: Range<usize>,+ known_chunks: Option<&HashSet<Range<BufferRow>>>,+ ) -> HashMap<Range<BufferRow>, Vec<BracketMatch>> {+ let mut all_bracket_matches = HashMap::default();+ if self+ .language+ .as_ref()+ .is_none_or(|language| language.grammar().is_none())+ {+ return all_bracket_matches;+ }++ for chunk in self+ .tree_sitter_data+ .chunks+ .applicable_chunks(&[range.to_point(self)])+ {+ if known_chunks.is_some_and(|chunks| chunks.contains(&chunk.row_range())) {+ continue;+ }+ if let Some(cached_brackets) = self+ .tree_sitter_data+ .brackets_by_chunks+ .lock()+ .get(&chunk.id)+ {+ all_bracket_matches.insert(chunk.row_range(), cached_brackets.clone());+ continue;+ }++ let chunk_range = chunk.anchor_range().to_offset(self);+ let chunk_brackets = self.chunk_bracket_matches(chunk_range);+ self.tree_sitter_data+ .brackets_by_chunks+ .lock()+ .entry(chunk.id)+ .or_insert_with(|| chunk_brackets.clone());+ all_bracket_matches.insert(chunk.row_range(), chunk_brackets);+ }++ all_bracket_matches+ }++ fn chunk_bracket_matches(&self, chunk_range: Range<usize>) -> Vec<BracketMatch> {+ let mut chunk_brackets = ChunkBrackets::new(self, chunk_range);+ chunk_brackets.collect_queried_candidates(self);+ chunk_brackets.recover_error_node_delimiters();+ chunk_brackets.repair_bogus_patterns();+ chunk_brackets.deduplicate_overlapping_patterns();+ chunk_brackets.into_colorized_matches()+ }++ pub fn all_bracket_ranges(&self, range: Range<usize>) -> impl Iterator<Item = BracketMatch> {+ self.fetch_bracket_ranges(range.clone(), None)+ .into_values()+ .flatten()+ .filter(move |bracket_match| {+ let bracket_range = bracket_match.open_range.start..bracket_match.close_range.end;+ bracket_range.overlaps(&range)+ })+ }++ /// Returns bracket range pairs overlapping or adjacent to `range`+ pub fn bracket_ranges<T: ToOffset>(+ &self,+ range: Range<T>,+ ) -> impl Iterator<Item = BracketMatch> + '_ {+ // Find bracket pairs that *inclusively* contain the given range.+ let range = range.start.to_previous_offset(self)..range.end.to_next_offset(self);+ self.all_bracket_ranges(range)+ .filter(|pair| !pair.newline_only)+ }++ /// Returns enclosing bracket ranges containing the given range+ pub fn enclosing_bracket_ranges<T: ToOffset>(+ &self,+ range: Range<T>,+ ) -> impl Iterator<Item = BracketMatch> + '_ {+ let range = range.start.to_offset(self)..range.end.to_offset(self);++ let result: Vec<_> = self.bracket_ranges(range.clone()).collect();+ let max_depth = result+ .iter()+ .map(|mat| mat.syntax_layer_depth)+ .max()+ .unwrap_or(0);+ result.into_iter().filter(move |pair| {+ pair.open_range.start <= range.start+ && pair.close_range.end >= range.end+ && pair.syntax_layer_depth == max_depth+ })+ }++ /// Returns the smallest enclosing bracket ranges containing the given range or None if no brackets contain range+ ///+ /// Can optionally pass a range_filter to filter the ranges of brackets to consider+ pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(+ &self,+ range: Range<T>,+ range_filter: Option<&dyn Fn(Range<usize>, Range<usize>) -> bool>,+ ) -> Option<(Range<usize>, Range<usize>)> {+ let range = range.start.to_offset(self)..range.end.to_offset(self);++ // Get the ranges of the innermost pair of brackets.+ let mut result: Option<(Range<usize>, Range<usize>)> = None;++ for pair in self.enclosing_bracket_ranges(range) {+ if let Some(range_filter) = range_filter+ && !range_filter(pair.open_range.clone(), pair.close_range.clone())+ {+ continue;+ }++ let len = pair.close_range.end - pair.open_range.start;++ if let Some((existing_open, existing_close)) = &result {+ let existing_len = existing_close.end - existing_open.start;+ if len > existing_len {+ continue;+ }+ }++ result = Some((pair.open_range, pair.close_range));+ }++ result+ }+}++/// Bracket pair candidates of a single row chunk, in the middle of being repaired.+///+/// Tree-sitter error recovery makes bracket queries unreliable in two ways: a query+/// can match one open delimiter against several closes (bogus patterns), and it can+/// omit delimiters that only exist as concrete leaves inside ERROR nodes (incomplete+/// patterns). Affected patterns are re-paired chunk-locally, while trustworthy query+/// output is kept as is.+struct ChunkBrackets<'a> {+ chunk_range: Range<usize>,+ error_layers: Vec<SyntaxLayer<'a>>,+ grammar_ids: Vec<GrammarId>,+ configs: Vec<&'a BracketsConfig>,+ candidates: Vec<BracketMatchCandidate>,+ delimiter_kinds_by_pattern: HashMap<BracketPatternKey, (HashSet<u16>, HashSet<u16>)>,+ syntax_layer_depths_by_delimiter: HashMap<BracketDelimiter, usize>,+ bogus_patterns: HashSet<BracketPatternKey>,+ incomplete_patterns: HashSet<BracketPatternKey>,+ syntax_opens_by_pattern: HashMap<BracketPatternKey, HashSet<BracketDelimiter>>,+ syntax_closes_by_pattern: HashMap<BracketPatternKey, HashSet<BracketDelimiter>>,+}++impl<'a> ChunkBrackets<'a> {+ fn new(snapshot: &'a BufferSnapshot, chunk_range: Range<usize>) -> Self {+ let error_layers = snapshot+ .syntax+ .layers_for_range(chunk_range.clone(), &snapshot.text, true)+ .filter(|layer| layer.node().has_error())+ .collect::<Vec<_>>();+ Self {+ chunk_range,+ error_layers,+ grammar_ids: Vec::new(),+ configs: Vec::new(),+ candidates: Vec::new(),+ delimiter_kinds_by_pattern: HashMap::default(),+ syntax_layer_depths_by_delimiter: HashMap::default(),+ bogus_patterns: HashSet::default(),+ incomplete_patterns: HashSet::default(),+ syntax_opens_by_pattern: HashMap::default(),+ syntax_closes_by_pattern: HashMap::default(),+ }+ }++ /// Runs the bracket queries and collects pair candidates overlapping the chunk,+ /// marking patterns that pair one open delimiter with several closes as bogus.+ fn collect_queried_candidates(&mut self, snapshot: &'a BufferSnapshot) {+ let bounded_query = (+ self.chunk_range.clone(),+ TreeSitterOptions {+ max_bytes_to_query: Some(MAX_BYTES_TO_QUERY),+ max_start_depth: None,+ },+ );+ // The bounded query drops any pair spanning more than `MAX_BYTES_TO_QUERY`+ // (tree-sitter's containing byte range requires full containment), which+ // resets bracket depth at chunk boundaries. Every such pair encloses a+ // chunk edge, so recover them with two point-sized unbounded queries that+ // only traverse the syntax tree spine around each edge.+ let boundary_queries = [self.chunk_range.start, self.chunk_range.end].map(|offset| {+ (+ snapshot.clip_offset(offset.saturating_sub(1), Bias::Left)+ ..snapshot.clip_offset(offset.saturating_add(1), Bias::Right),+ TreeSitterOptions::default(),+ )+ });++ let mut seen_pairs = HashSet::default();+ // Track the close seen for each open delimiter: a second, different close+ // for the same open means the pattern's matches cannot be trusted.+ let mut close_by_open = HashMap::default();+ for (query_range, options) in iter::once(bounded_query).chain(boundary_queries) {+ let mut matches = snapshot.syntax.matches_with_options(+ query_range,+ &snapshot.text,+ options,+ |grammar| grammar.brackets_config.as_ref().map(|c| &c.query),+ );+ let grammar_indices = matches+ .grammars()+ .iter()+ .map(|grammar| self.grammar_index(grammar))+ .collect::<Vec<_>>();++ while let Some(mat) = matches.peek() {+ let mut open = None;+ let mut close = None;+ let syntax_layer_depth = mat.depth;+ let grammar_index = grammar_indices[mat.grammar_index];+ let pattern_key = BracketPatternKey {+ grammar_index,+ pattern_index: mat.pattern_index,+ };+ let config = self.configs[grammar_index];+ let pattern = &config.patterns[mat.pattern_index];+ for capture in mat.captures {+ if capture.index == config.open_capture_ix {+ open = Some((capture.node.byte_range(), capture.node.kind_id()));+ } else if capture.index == config.close_capture_ix {+ close = Some((capture.node.byte_range(), capture.node.kind_id()));+ }+ }++ matches.advance();++ let Some(((open_range, open_kind), (close_range, close_kind))) = open.zip(close)+ else {+ continue;+ };++ let bracket_range = open_range.start..=close_range.end;+ if !bracket_range.overlaps(&self.chunk_range) {+ continue;+ }++ let candidate = BracketMatchCandidate {+ bracket_match: BracketMatch {+ open_range,+ close_range,+ syntax_layer_depth,+ newline_only: pattern.newline_only,+ color_index: None,+ },+ pattern: pattern_key,+ rainbow_exclude: pattern.rainbow_exclude,+ };++ if !self.error_layers.is_empty() {+ let (open_kinds, close_kinds) = self+ .delimiter_kinds_by_pattern+ .entry(pattern_key)+ .or_insert_with(|| (HashSet::default(), HashSet::default()));+ open_kinds.insert(open_kind);+ close_kinds.insert(close_kind);+ }++ if !seen_pairs.insert((candidate.open_delimiter(), candidate.close_delimiter())) {+ continue;+ }++ if close_by_open+ .insert(candidate.open_delimiter(), candidate.close_delimiter())+ .is_some()+ {+ self.bogus_patterns.insert(pattern_key);+ }++ self.candidates.push(candidate);+ }+ }+ }++ fn grammar_index(&mut self, grammar: &'a Grammar) -> usize {+ self.grammar_ids+ .iter()+ .position(|&id| id == grammar.id())+ .unwrap_or_else(|| {+ self.grammar_ids.push(grammar.id());+ self.configs.push(grammar.brackets_config.as_ref().unwrap());+ self.grammar_ids.len() - 1+ })+ }++ /// Bracket queries can omit delimiters swallowed by tree-sitter error recovery.+ /// Collects the concrete delimiter leaves inside ERROR nodes and marks the+ /// patterns whose query output misses some of them as incomplete (and bogus).+ fn recover_error_node_delimiters(&mut self) {+ let unambiguous_kinds = self.unambiguous_delimiter_kinds();+ self.collect_error_layer_delimiters(&unambiguous_kinds);+ self.mark_incomplete_patterns(&unambiguous_kinds);+ }++ /// Patterns whose open and close delimiters map to exactly one distinct+ /// syntax-node kind each, making their leaves recognizable inside ERROR nodes.+ fn unambiguous_delimiter_kinds(&self) -> Vec<(BracketPatternKey, u16, u16)> {+ self.delimiter_kinds_by_pattern+ .iter()+ .filter_map(|(pattern, (open_kinds, close_kinds))| {+ // Kinds are observed from this chunk's matches only: a pattern+ // alternating several delimiter tokens may pass this check when just+ // one alternative occurs in the chunk, and a pattern whose every+ // match was swallowed by an error is never recovered at all.+ if open_kinds.len() != 1 || close_kinds.len() != 1 {+ return None;+ }+ let open_kind = *open_kinds.iter().next()?;+ let close_kind = *close_kinds.iter().next()?;+ // Syntax leaves cannot distinguish the two roles of delimiters such as quotes.+ (open_kind != close_kind).then_some((*pattern, open_kind, close_kind))+ })+ .collect()+ }++ fn collect_error_layer_delimiters(+ &mut self,+ unambiguous_kinds: &[(BracketPatternKey, u16, u16)],+ ) {+ if unambiguous_kinds.is_empty() {+ return;+ }+ for layer in &self.error_layers {+ let Some(grammar) = layer.language.grammar() else {+ continue;+ };+ let Some(grammar_index) = self.grammar_ids.iter().position(|&id| id == grammar.id())+ else {+ continue;+ };+ let relevant_patterns = unambiguous_kinds+ .iter()+ .filter(|(pattern, _, _)| pattern.grammar_index == grammar_index)+ .collect::<Vec<_>>();+ if relevant_patterns.is_empty() {+ continue;+ }++ let root_node = layer.node();+ let mut cursor = root_node.walk();+ let mut nodes = vec![(root_node, false)];+ while let Some((node, inside_error)) = nodes.pop() {+ let node_range = node.byte_range();+ if node_range.end <= self.chunk_range.start+ || node_range.start >= self.chunk_range.end+ {+ continue;+ }+ let inside_error = inside_error || node.is_error();+ if !inside_error && !node.has_error() {+ continue;+ }++ if node.child_count() == 0 {+ if !inside_error+ || node_range.is_empty()+ || !self.chunk_range.contains(&node_range.start)+ {+ continue;+ }++ for (pattern, open_kind, close_kind) in &relevant_patterns {+ let delimiters_by_pattern = if node.kind_id() == *open_kind {+ &mut self.syntax_opens_by_pattern+ } else if node.kind_id() == *close_kind {+ &mut self.syntax_closes_by_pattern+ } else {+ continue;+ };+ let delimiter = BracketDelimiter {+ start: node_range.start,+ end: node_range.end,+ pattern: *pattern,+ };+ delimiters_by_pattern+ .entry(*pattern)+ .or_default()+ .insert(delimiter);+ self.syntax_layer_depths_by_delimiter+ .entry(delimiter)+ .or_insert(layer.depth);+ }+ } else {+ nodes.extend(+ node.children(&mut cursor)+ .map(|child| (child, inside_error)),+ );+ }+ }+ }+ }++ fn mark_incomplete_patterns(&mut self, unambiguous_kinds: &[(BracketPatternKey, u16, u16)]) {+ for (pattern, _, _) in unambiguous_kinds {+ // Recovery needs both delimiter roles inside this chunk's ERROR nodes;+ // a pair split between an ERROR node and a regular node is left as queried.+ let Some(syntax_opens) = self.syntax_opens_by_pattern.get(pattern) else {+ continue;+ };+ let Some(syntax_closes) = self.syntax_closes_by_pattern.get(pattern) else {+ continue;+ };+ // A count mismatch means some delimiter genuinely lacks a partner while the+ // user is editing; repairing would invent one. Balanced counts can still pair+ // unrelated stray delimiters, which is accepted as best-effort recovery.+ if syntax_opens.len() != syntax_closes.len() {+ continue;+ }++ let query_opens = self+ .candidates+ .iter()+ .filter(|candidate| candidate.pattern == *pattern)+ .map(|candidate| candidate.open_delimiter())+ .filter(|open| self.chunk_range.contains(&open.start))+ .collect::<HashSet<_>>();+ let query_closes = self+ .candidates+ .iter()+ .filter(|candidate| candidate.pattern == *pattern)+ .map(|candidate| candidate.close_delimiter())+ .filter(|close| self.chunk_range.contains(&close.start))+ .collect::<HashSet<_>>();+ let has_missing_open = !syntax_opens.is_subset(&query_opens);+ let has_missing_close = !syntax_closes.is_subset(&query_closes);+ if has_missing_open || has_missing_close {+ self.bogus_patterns.insert(*pattern);+ self.incomplete_patterns.insert(*pattern);+ }+ }+ }++ /// Certain patterns produce bogus or incomplete matches during error recovery.+ /// Repairs only those patterns, keeping trustworthy grammar output intact:+ /// clean patterns may legitimately pair an open in one chunk with a close in+ /// another, and must not be dropped by the chunk-local repair.+ fn repair_bogus_patterns(&mut self) {+ if self.bogus_patterns.is_empty() {+ return;+ }++ for candidate in bogus_candidates(&self.candidates, &self.bogus_patterns) {+ let syntax_layer_depth = candidate.bracket_match.syntax_layer_depth;+ self.syntax_layer_depths_by_delimiter+ .entry(candidate.open_delimiter())+ .or_insert(syntax_layer_depth);+ self.syntax_layer_depths_by_delimiter+ .entry(candidate.close_delimiter())+ .or_insert(syntax_layer_depth);+ }++ let pair_counts = self.bogus_pair_counts();+ let mut existing_pairs = bogus_candidates(&self.candidates, &self.bogus_patterns)+ .map(|candidate| (candidate.open_delimiter(), candidate.close_delimiter()))+ .collect::<HashSet<_>>();+ let mut valid_pairs = self.stack_matched_pairs(&pair_counts, &mut existing_pairs);+ self.trust_cross_chunk_pairs(&pair_counts, &mut valid_pairs);+ self.replace_bogus_pairs(valid_pairs, existing_pairs);+ }++ /// A cross-product of bogus matches multiply pairs its delimiters, while+ /// structural error-recovery pairs stay uniquely paired and can be trusted.+ fn bogus_pair_counts(&self) -> DelimiterPairCounts {+ let mut counts = DelimiterPairCounts::default();+ for candidate in bogus_candidates(&self.candidates, &self.bogus_patterns) {+ *counts+ .opens+ .entry(candidate.open_delimiter())+ .or_insert(0_usize) += 1;+ *counts+ .closes+ .entry(candidate.close_delimiter())+ .or_insert(0_usize) += 1;+ }+ counts+ }++ // Tree-sitter represents missing error-recovery tokens as empty nodes.+ fn is_concrete(&self, delimiter: &BracketDelimiter) -> bool {+ delimiter.start < delimiter.end || !self.incomplete_patterns.contains(&delimiter.pattern)+ }++ /// The concrete delimiters of bogus patterns that lie within the chunk, augmented+ /// with the ones recovered from ERROR nodes, sorted in document order.+ fn repairable_delimiters(+ &self,+ mut delimiters: Vec<BracketDelimiter>,+ syntax_delimiters_by_pattern: &HashMap<BracketPatternKey, HashSet<BracketDelimiter>>,+ ) -> Vec<BracketDelimiter> {+ delimiters.retain(|delimiter| {+ self.chunk_range.contains(&delimiter.start) && self.is_concrete(delimiter)+ });+ for pattern in &self.incomplete_patterns {+ if let Some(syntax_delimiters) = syntax_delimiters_by_pattern.get(pattern) {+ delimiters.extend(syntax_delimiters.iter().copied());+ }+ }+ delimiters.sort_unstable();+ delimiters.dedup();+ delimiters+ }++ /// Re-pairs the chunk-local delimiters of bogus patterns with a stack walk in+ /// document order. A close without any open on its stack gets one inferred right+ /// before it, unless the grammar paired it with an open beyond the chunk.+ fn stack_matched_pairs(+ &mut self,+ pair_counts: &DelimiterPairCounts,+ existing_pairs: &mut HashSet<BracketDelimiterPair>,+ ) -> HashSet<BracketDelimiterPair> {+ // Map each close to its expected open length (for inferring opens)+ let close_to_open_len = bogus_candidates(&self.candidates, &self.bogus_patterns)+ .map(|candidate| {+ (+ candidate.close_delimiter(),+ candidate.bracket_match.open_range.len(),+ )+ })+ .collect::<HashMap<_, _>>();+ let sorted_opens = self.repairable_delimiters(+ bogus_candidates(&self.candidates, &self.bogus_patterns)+ .map(|candidate| candidate.open_delimiter())+ .collect(),+ &self.syntax_opens_by_pattern,+ );+ let unique_closes = self.repairable_delimiters(+ bogus_candidates(&self.candidates, &self.bogus_patterns)+ .map(|candidate| candidate.close_delimiter())+ .collect(),+ &self.syntax_closes_by_pattern,+ );+ let closes_with_cross_chunk_opens =+ bogus_candidates(&self.candidates, &self.bogus_patterns)+ .filter(|candidate| {+ !self+ .chunk_range+ .contains(&candidate.bracket_match.open_range.start)+ && pair_counts.uniquely_paired(+ &candidate.open_delimiter(),+ &candidate.close_delimiter(),+ )+ })+ .map(|candidate| candidate.close_delimiter())+ .collect::<HashSet<_>>();++ let mut valid_pairs = HashSet::default();+ let mut open_stacks = HashMap::default();+ let mut open_idx = 0;+ for close in &unique_closes {+ // Push all opens before this close onto stack+ while open_idx < sorted_opens.len() && sorted_opens[open_idx].start < close.start {+ let open = sorted_opens[open_idx];+ open_stacks+ .entry(open.pattern)+ .or_insert_with(Vec::new)+ .push(open);+ open_idx += 1;+ }++ // Try to match with most recent open+ if let Some(open) = open_stacks+ .get_mut(&close.pattern)+ .and_then(|open_stack| open_stack.pop())+ {+ valid_pairs.insert((open, *close));+ } else if !closes_with_cross_chunk_opens.contains(close)+ && let Some(&open_len) = close_to_open_len.get(close)+ {+ // No open on stack and the grammar offers no open beyond the+ // chunk either - infer one based on expected open_len+ if close.start >= open_len {+ let inferred = BracketDelimiter {+ start: close.start - open_len,+ end: close.start,+ pattern: close.pattern,+ };+ valid_pairs.insert((inferred, *close));+ existing_pairs.insert((inferred, *close));+ let syntax_layer_depth = self+ .syntax_layer_depths_by_delimiter+ .get(close)+ .copied()+ .unwrap_or(0);+ self.syntax_layer_depths_by_delimiter+ .entry(inferred)+ .or_insert(syntax_layer_depth);+ let pattern = &self.configs[close.pattern.grammar_index].patterns+ [close.pattern.pattern_index];+ self.candidates.push(BracketMatchCandidate {+ bracket_match: BracketMatch {+ open_range: inferred.start..inferred.end,+ close_range: close.start..close.end,+ newline_only: pattern.newline_only,+ syntax_layer_depth,+ color_index: None,+ },+ pattern: close.pattern,+ rainbow_exclude: pattern.rainbow_exclude,+ });+ }+ }+ }+ valid_pairs+ }++ /// Pairs with a delimiter outside the chunk (boundary queries recover+ /// those to keep bracket depth stable across chunks) cannot be verified+ /// by the chunk-local stack: the delimiters beyond the chunk are unknown.+ /// Trust grammar output for whichever remained unmatched, but only+ /// uniquely paired ones: cross-product bogosity multiply pairs delimiters.+ fn trust_cross_chunk_pairs(+ &self,+ pair_counts: &DelimiterPairCounts,+ valid_pairs: &mut HashSet<BracketDelimiterPair>,+ ) {+ let matched_opens = valid_pairs+ .iter()+ .map(|(open, _)| *open)+ .collect::<HashSet<_>>();+ let matched_closes = valid_pairs+ .iter()+ .map(|(_, close)| *close)+ .collect::<HashSet<_>>();+ for candidate in bogus_candidates(&self.candidates, &self.bogus_patterns) {+ let open = candidate.open_delimiter();+ let close = candidate.close_delimiter();+ let open_inside = self.chunk_range.contains(&open.start);+ let close_inside = self.chunk_range.contains(&close.start);+ let crosses_chunk = !open_inside || !close_inside;+ let unmatched = (!open_inside || !matched_opens.contains(&open))+ && (!close_inside || !matched_closes.contains(&close));+ if crosses_chunk+ && unmatched+ && pair_counts.uniquely_paired(&open, &close)+ && self.is_concrete(&open)+ && self.is_concrete(&close)+ {+ valid_pairs.insert((open, close));+ }+ }+ }++ /// Drops the bogus candidates that did not survive the repair and adds+ /// candidates for the repaired pairs that the queries never produced.+ fn replace_bogus_pairs(+ &mut self,+ valid_pairs: HashSet<BracketDelimiterPair>,+ existing_pairs: HashSet<BracketDelimiterPair>,+ ) {+ let mut repaired_pairs = valid_pairs+ .iter()+ .filter(|pair| !existing_pairs.contains(*pair))+ .copied()+ .collect::<Vec<_>>();+ repaired_pairs.sort_unstable();+ for (open, close) in repaired_pairs {+ let pattern =+ &self.configs[open.pattern.grammar_index].patterns[open.pattern.pattern_index];+ self.candidates.push(BracketMatchCandidate {+ bracket_match: BracketMatch {+ open_range: open.start..open.end,+ close_range: close.start..close.end,+ newline_only: pattern.newline_only,+ syntax_layer_depth: self+ .syntax_layer_depths_by_delimiter+ .get(&open)+ .copied()+ .or_else(|| self.syntax_layer_depths_by_delimiter.get(&close).copied())+ .unwrap_or(0),+ color_index: None,+ },+ pattern: open.pattern,+ rainbow_exclude: pattern.rainbow_exclude,+ });+ }++ let bogus_patterns = &self.bogus_patterns;+ self.candidates.retain(|candidate| {+ !bogus_patterns.contains(&candidate.pattern)+ || valid_pairs.contains(&(candidate.open_delimiter(), candidate.close_delimiter()))+ });+ }++ /// Overlapping query patterns can attribute one physical pair to several+ /// patterns, both when queried and when repaired. Keeps the first match,+ /// following the pattern order in the query.+ fn deduplicate_overlapping_patterns(&mut self) {+ let mut seen_ranges = HashSet::default();+ self.candidates.retain(|candidate| {+ seen_ranges.insert((+ candidate.bracket_match.open_range.start,+ candidate.bracket_match.open_range.end,+ candidate.bracket_match.close_range.start,+ candidate.bracket_match.close_range.end,+ ))+ });+ }++ /// Assigns nesting-depth color indices and returns the matches sorted by open range.+ fn into_colorized_matches(self) -> Vec<BracketMatch> {+ let mut opens = Vec::new();+ let mut color_pairs = Vec::new();+ let mut all_brackets = self+ .candidates+ .into_iter()+ .enumerate()+ .map(|(index, candidate)| {+ let bracket_match = candidate.bracket_match;+ // Certain languages have "brackets" that are not brackets, e.g. tags. and such+ // bracket will match the entire tag with all text inside.+ // For now, avoid highlighting any pair that has more than single char in each bracket.+ // We need to colorize `<Element/>` bracket pairs, so cannot make this check stricter.+ let should_color = !candidate.rainbow_exclude+ && (bracket_match.open_range.len() == 1+ || bracket_match.close_range.len() == 1);+ if should_color {+ opens.push(bracket_match.open_range.clone());+ color_pairs.push((+ bracket_match.open_range.clone(),+ bracket_match.close_range.clone(),+ index,+ ));+ }+ bracket_match+ })+ .collect::<Vec<_>>();++ opens.sort_by_key(|r| (r.start, r.end));+ opens.dedup_by(|a, b| a.start == b.start && a.end == b.end);+ color_pairs.sort_by_key(|(_, close, _)| close.end);++ let mut open_stack = Vec::new();+ let mut open_index = 0;+ for (open, close, index) in color_pairs {+ while open_index < opens.len() && opens[open_index].start < close.start {+ open_stack.push(opens[open_index].clone());+ open_index += 1;+ }++ if open_stack.last() == Some(&open) {+ let depth_index = open_stack.len() - 1;+ all_brackets[index].color_index = Some(depth_index);+ open_stack.pop();+ }+ }++ all_brackets.sort_by_key(|bracket_match| {+ (bracket_match.open_range.start, bracket_match.open_range.end)+ });++ all_brackets+ }+}++fn bogus_candidates<'a>(+ candidates: &'a [BracketMatchCandidate],+ bogus_patterns: &'a HashSet<BracketPatternKey>,+) -> impl Iterator<Item = &'a BracketMatchCandidate> {+ candidates+ .iter()+ .filter(|candidate| bogus_patterns.contains(&candidate.pattern))+}++#[derive(Default)]+struct DelimiterPairCounts {+ opens: HashMap<BracketDelimiter, usize>,+ closes: HashMap<BracketDelimiter, usize>,+}++impl DelimiterPairCounts {+ fn uniquely_paired(&self, open: &BracketDelimiter, close: &BracketDelimiter) -> bool {+ self.opens.get(open) == Some(&1) && self.closes.get(close) == Some(&1)+ }+}diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rsindex 57068230404..4ec52fc1056 100644--- a/crates/language/src/buffer_tests.rs+++ b/crates/language/src/buffer_tests.rs@@ -1474,6 +1474,243 @@ fn test_bracket_colorization_indices_remain_stable_across_row_chunks(cx: &mut Ap}}+#[gpui::test]+fn test_c_bracket_ranges_in_error_nodes(cx: &mut App) {+ let text = indoc! {r#"+ CLAY(CLAY_ID("MenuContainer"),+ CLAY_RECTANGLE({.color = {43, 41, 51, 255}}),+ CLAY_LAYOUT({.layoutDirection = CLAY_LEFT_TO_RIGHT,+ .sizing = {.width = CLAY_SIZING_FIT()},+ .padding = {16, 16},+ .childGap = 16})) {+ CLAY(CLAY_ID("StartStopButton"), CLAY_LAYOUT({.padding = {16, 8}}),+ CLAY_RECTANGLE({.color = {140, 140, 140, 255}, .cornerRadius = 5}),+ Clay_OnHover(HandleStartButtonInteraction, 1)) {+ CLAY_TEXT(CLAY_STRING("Start/Stop"),+ CLAY_TEXT_CONFIG({.fontId = FONT_ID_BODY_16,+ .fontSize = 16,+ .textColor = {255, 255, 255, 255}}));+ }+ }+ "#};+ let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(c_lang(), cx));+ let snapshot = buffer.read(cx).snapshot();+ assert_has_syntax_errors(&snapshot);+ let matches = snapshot+ .all_bracket_ranges(0..snapshot.len())+ .map(BracketMatch::bracket_ranges)+ // Quote pairs share one delimiter kind, so error recovery leaves them as queried.+ .filter(|(open, _)| matches!(&text[open.clone()], "(" | "{"))+ .collect::<Vec<_>>();++ let (mut expected, unmatched_parens) = stack_paired_brackets(text, '(', ')');+ let (curly_pairs, unmatched_curlies) = stack_paired_brackets(text, '{', '}');+ expected.extend(curly_pairs);+ assert_eq!(unmatched_parens, Vec::<Range<usize>>::new());+ assert_eq!(unmatched_curlies, Vec::<Range<usize>>::new());+ assert_set_eq!(matches, expected);+}++#[gpui::test]+fn test_bracket_ranges_do_not_repair_unbalanced_error_nodes(cx: &mut App) {+ let (text, ranges) = marked_text_ranges(+ indoc! {r#"+ CLAY«(»CLAY_ID("MenuContainer"),+ CLAY_LAYOUT({.layoutDirection = CLAY_LEFT_TO_RIGHT,+ .sizing = {.width = CLAY_SIZING_FIT()},+ .padding = {16, 16},+ .childGap = 16}) {+ }+ "#},+ false,+ );+ let buffer = cx.new(|cx| Buffer::local(text.clone(), cx).with_language(c_lang(), cx));+ let snapshot = buffer.read(cx).snapshot();+ assert_has_syntax_errors(&snapshot);+ let matches = snapshot+ .all_bracket_ranges(0..snapshot.len())+ .map(BracketMatch::bracket_ranges)+ // Tree-sitter pairs unmatched opens with zero-width MISSING close tokens.+ .filter(|(open, close)| matches!(&text[open.clone()], "(" | "{") && !close.is_empty())+ .collect::<Vec<_>>();++ let (mut expected, unmatched_parens) = stack_paired_brackets(&text, '(', ')');+ let (curly_pairs, unmatched_curlies) = stack_paired_brackets(&text, '{', '}');+ expected.extend(curly_pairs);+ assert_eq!(+ unmatched_parens,+ vec![ranges[0].clone()],+ "the fixture should contain exactly one unbalanced opening parenthesis"+ );+ assert_eq!(unmatched_curlies, Vec::<Range<usize>>::new());+ assert_set_eq!(matches, expected);+}++// This test passes without the error recovery too: it pins the retention of+// cross-chunk pairs, which the chunk-local repair can neither see nor verify.+#[gpui::test]+fn test_bracket_ranges_keep_chunk_spanning_pairs_amid_errors(cx: &mut App) {+ let mut text = String::from("void outer(void) {\n");+ for index in 0..60 {+ text.push_str(&format!(" int before_{index:02} = 0;\n"));+ }+ text.push_str(+ r#" CLAY(CLAY_ID("MenuContainer"),+ CLAY_RECTANGLE({.color = {43, 41, 51, 255}}),+ CLAY_LAYOUT({.layoutDirection = CLAY_LEFT_TO_RIGHT,+ .sizing = {.width = CLAY_SIZING_FIT()},+ .padding = {16, 16},+ .childGap = 16})) {+ }+"#,+ );+ for index in 0..60 {+ text.push_str(&format!(" int after_{index:02} = 0;\n"));+ }+ text.push_str("}\n");++ let buffer = cx.new(|cx| Buffer::local(text.clone(), cx).with_language(c_lang(), cx));+ let snapshot = buffer.read(cx).snapshot();+ assert_has_syntax_errors(&snapshot);++ let open_offset = text.find('{').unwrap();+ let close_offset = text.rfind('}').unwrap();+ let matches = snapshot.fetch_bracket_ranges(0..snapshot.len(), None);+ assert!(+ matches.len() >= 3,+ "the fixture should span at least three row chunks, got {:?}",+ matches.keys().collect::<Vec<_>>()+ );+ for (row_range, chunk_matches) in &matches {+ let enclosing = chunk_matches+ .iter()+ .find(|bracket_match| bracket_match.open_range.start == open_offset)+ .map(|bracket_match| {+ (+ bracket_match.open_range.clone(),+ bracket_match.close_range.clone(),+ )+ });+ assert_eq!(+ enclosing,+ Some((open_offset..open_offset + 1, close_offset..close_offset + 1)),+ "chunk {row_range:?} should keep the function body pair that spans all chunks"+ );+ }+}++#[gpui::test]+fn test_bracket_ranges_keep_pairs_straddling_a_chunk_boundary_amid_errors(cx: &mut App) {+ let mut text = String::from("void outer(void) {\n");+ for index in 0..56 {+ text.push_str(&format!(" int before_{index:02} = 0;\n"));+ }+ let if_open_offset = text.len() + " if (before_00) ".len();+ text.push_str(" if (before_00) {\n");+ text.push_str(+ r#" CLAY(CLAY_ID("MenuContainer"),+ CLAY_RECTANGLE({.color = {43, 41, 51, 255}}),+ CLAY_LAYOUT({.layoutDirection = CLAY_LEFT_TO_RIGHT,+ .sizing = {.width = CLAY_SIZING_FIT()},+ .padding = {16, 16},+ .childGap = 16})) {+ }+"#,+ );+ for index in 0..55 {+ text.push_str(&format!(" int after_{index:02} = 0;\n"));+ }+ let if_close_offset = text.len() + " ".len();+ text.push_str(" }\n}\n");++ let buffer = cx.new(|cx| Buffer::local(text.clone(), cx).with_language(c_lang(), cx));+ let snapshot = buffer.read(cx).snapshot();+ assert_has_syntax_errors(&snapshot);++ let open_row = snapshot.offset_to_point(if_open_offset).row;+ let close_row = snapshot.offset_to_point(if_close_offset).row;+ let matches = snapshot.fetch_bracket_ranges(0..snapshot.len(), None);+ assert!(+ matches.len() >= 3,+ "the fixture should span at least three row chunks, got {:?}",+ matches.keys().collect::<Vec<_>>()+ );+ assert!(+ matches+ .keys()+ .any(|row_range| row_range.contains(&open_row) && !row_range.contains(&close_row)),+ "the if body pair should straddle a chunk boundary, opening at row {open_row} and closing at row {close_row}"+ );+ for (row_range, chunk_matches) in &matches {+ if !row_range.contains(&open_row) && !row_range.contains(&close_row) {+ continue;+ }+ let straddling = chunk_matches+ .iter()+ .find(|bracket_match| bracket_match.open_range.start == if_open_offset)+ .map(|bracket_match| {+ (+ bracket_match.open_range.clone(),+ bracket_match.close_range.clone(),+ )+ });+ assert_eq!(+ straddling,+ Some((+ if_open_offset..if_open_offset + 1,+ if_close_offset..if_close_offset + 1+ )),+ "chunk {row_range:?} should keep the if body pair straddling the chunk boundary"+ );+ }+}++#[gpui::test]+fn test_bracket_ranges_deduplicate_overlapping_patterns(cx: &mut App) {+ let text = indoc! {r#"+ CLAY(CLAY_ID("MenuContainer"),+ CLAY_RECTANGLE({.color = {43, 41, 51, 255}}),+ CLAY_LAYOUT({.layoutDirection = CLAY_LEFT_TO_RIGHT,+ .sizing = {.width = CLAY_SIZING_FIT()},+ .padding = {16, 16},+ .childGap = 16})) {+ }+ "#};+ let language = Arc::new(+ Language::new(+ LanguageConfig {+ name: "C".into(),+ ..Default::default()+ },+ Some(tree_sitter_c::LANGUAGE.into()),+ )+ .with_brackets_query(+ r#"+ ("(" @open ")" @close)+ ("(" @open ")" @close)+ "#,+ )+ .unwrap(),+ );+ let buffer = cx.new(|cx| Buffer::local(text, cx).with_language(language, cx));+ let snapshot = buffer.read(cx).snapshot();+ assert_has_syntax_errors(&snapshot);++ let mut matches = snapshot+ .all_bracket_ranges(0..snapshot.len())+ .map(BracketMatch::bracket_ranges)+ .collect::<Vec<_>>();+ matches.sort_by_key(|(open, close)| (open.start, open.end, close.start, close.end));++ let (mut expected, unmatched_parens) = stack_paired_brackets(text, '(', ')');+ assert_eq!(unmatched_parens, Vec::<Range<usize>>::new());+ expected.sort_by_key(|(open, close)| (open.start, open.end, close.start, close.end));+ assert_eq!(+ matches, expected,+ "one match per physical pair, even when several query patterns capture it"+ );+}+#[test]fn test_applicable_row_chunks() {let text = (0..125)@@ -4525,7 +4762,7 @@ fn erb_lang() -> Language {}fn color_index_for_open(- matches: &HashMap<Range<BufferRow>, Vec<BracketMatch<usize>>>,+ matches: &HashMap<Range<BufferRow>, Vec<BracketMatch>>,open_offset: usize,) -> Option<usize> {matches@@ -4568,10 +4805,49 @@ fn c_lang() -> Arc<Language> {Some(tree_sitter_c::LANGUAGE.into()),).with_outline_query(include_str!("../../grammars/src/c/outline.scm"))+ .unwrap()+ .with_brackets_query(include_str!("../../grammars/src/c/brackets.scm")).unwrap(),)}+#[track_caller]+fn assert_has_syntax_errors(snapshot: &BufferSnapshot) {+ assert!(+ snapshot+ .syntax+ .layers_for_range(0..snapshot.len(), &snapshot.text, true)+ .any(|layer| layer.node().has_error()),+ "the fixture should parse with syntax errors"+ );+}++/// Pairs bracket characters anywhere in `text`, including inside string literals.+#[track_caller]+fn stack_paired_brackets(+ text: &str,+ open: char,+ close: char,+) -> (Vec<(Range<usize>, Range<usize>)>, Vec<Range<usize>>) {+ let mut open_offsets = Vec::new();+ let mut pairs = Vec::new();+ for (offset, character) in text.char_indices() {+ if character == open {+ open_offsets.push(offset);+ } else if character == close {+ let Some(open_offset) = open_offsets.pop() else {+ panic!("unexpected closing {close} at offset {offset}");+ };+ pairs.push((open_offset..open_offset + 1, offset..offset + 1));+ }+ }+ let unmatched_opens = open_offsets+ .into_iter()+ .map(|offset| offset..offset + 1)+ .collect::<Vec<_>>();+ (pairs, unmatched_opens)+}+pub fn markdown_inline_lang() -> Language {Language::new(LanguageConfig {