use collections::HashMap;use gpui::{AppContext, Context, Entity, Window};use itertools::Itertools;use language::Buffer;use std::{ops::Range, sync::Arc, time::Duration};use text::{Anchor, AnchorRangeExt, Bias, BufferId, ToOffset, ToPoint};use util::ResultExt; use crate::Editor; #[derive(Clone, Default)]pub(super) struct LinkedEditingRanges(    /// Ranges are non-overlapping and sorted by .0 (thus, [x + 1].start > [x].end must hold)    pub HashMap<BufferId, Vec<(Range<Anchor>, Vec<Range<Anchor>>)>>,); impl LinkedEditingRanges {    pub(super) fn get(        &self,        id: BufferId,        anchor: Range<Anchor>,        snapshot: &text::BufferSnapshot,    ) -> Option<&(Range<Anchor>, Vec<Range<Anchor>>)> {        let ranges_for_buffer = self.0.get(&id)?;        let lower_bound = ranges_for_buffer            .partition_point(|(range, _)| range.start.cmp(&anchor.start, snapshot).is_le());        if lower_bound == 0 {            // None of the linked ranges contains `anchor`.            return None;        }        ranges_for_buffer            .get(lower_bound - 1)            .filter(|(range, _)| range.end.cmp(&anchor.end, snapshot).is_ge())    }    pub(super) fn is_empty(&self) -> bool {        self.0.is_empty()    }     pub(super) fn clear(&mut self) {        self.0.clear();    }} const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50); // TODO do not refresh anything at all, if the settings/capabilities do not have it enabled.pub(super) fn refresh_linked_ranges(    editor: &mut Editor,    window: &mut Window,    cx: &mut Context<Editor>,) -> Option<()> {    if !editor.lsp_data_enabled() || editor.pending_rename.is_some() {        return None;    }    let project = editor.project()?.downgrade();     editor.linked_editing_range_task = Some(cx.spawn_in(window, async move |editor, cx| {        cx.background_executor().timer(UPDATE_DEBOUNCE).await;         let mut applicable_selections = Vec::new();        editor            .update(cx, |editor, cx| {                let display_snapshot = editor.display_snapshot(cx);                let selections = editor.selections.all_anchors(&display_snapshot);                let snapshot = display_snapshot.buffer_snapshot();                let buffer = editor.buffer.read(cx);                for selection in selections.iter() {                    if let Some((_, range)) =                        snapshot.anchor_range_to_buffer_anchor_range(selection.range())                        && let Some(buffer) = buffer.buffer(range.start.buffer_id)                    {                        applicable_selections.push((buffer, range.start, range.end));                    }                }            })            .ok()?;         if applicable_selections.is_empty() {            return None;        }         let highlights = project            .update(cx, |project, cx| {                let mut linked_edits_tasks = vec![];                for (buffer, start, end) in &applicable_selections {                    let linked_edits_task = project.linked_edits(buffer, *start, cx);                    let cx = cx.to_async();                    let highlights = async move {                        let edits = linked_edits_task.await.log_err()?;                        let snapshot = cx.read_entity(&buffer, |buffer, _| buffer.snapshot());                        let buffer_id = snapshot.remote_id();                         // Find the range containing our current selection.                        // We might not find one, because the selection contains both the start and end of the contained range                        // (think of selecting <`html>foo`</html> - even though there's a matching closing tag, the selection goes beyond the range of the opening tag)                        // or the language server may not have returned any ranges.                         let start_point = start.to_point(&snapshot);                        let end_point = end.to_point(&snapshot);                        let _current_selection_contains_range = edits.iter().find(|range| {                            range.start.to_point(&snapshot) <= start_point                                && range.end.to_point(&snapshot) >= end_point                        });                        _current_selection_contains_range?;                        // Now link every range as each-others sibling.                        let mut siblings: HashMap<Range<Anchor>, Vec<_>> = Default::default();                        let mut insert_sorted_anchor =                            |key: &Range<Anchor>, value: &Range<Anchor>| {                                siblings.entry(key.clone()).or_default().push(value.clone());                            };                        for items in edits.into_iter().combinations(2) {                            let Ok([first, second]): Result<[_; 2], _> = items.try_into() else {                                unreachable!()                            };                             insert_sorted_anchor(&first, &second);                            insert_sorted_anchor(&second, &first);                        }                        let mut siblings: Vec<(_, _)> = siblings.into_iter().collect();                        siblings.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0, &snapshot));                        Some((buffer_id, siblings))                    };                    linked_edits_tasks.push(highlights);                }                linked_edits_tasks            })            .ok()?;         let highlights = futures::future::join_all(highlights).await;         editor            .update(cx, |this, cx| {                this.linked_edit_ranges.0.clear();                if this.pending_rename.is_some() {                    return;                }                for (buffer_id, ranges) in highlights.into_iter().flatten() {                    this.linked_edit_ranges                        .0                        .entry(buffer_id)                        .or_default()                        .extend(ranges);                }                for (buffer_id, values) in this.linked_edit_ranges.0.iter_mut() {                    let Some(snapshot) = this                        .buffer                        .read(cx)                        .buffer(*buffer_id)                        .map(|buffer| buffer.read(cx).snapshot())                    else {                        continue;                    };                    values.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0, &snapshot));                }                 cx.notify();            })            .ok()?;         Some(())    }));    None} /// Accumulates edits destined for linked editing ranges, for example, matching/// HTML/JSX tags, across one or more buffers. Edits are stored as anchor ranges/// so they track buffer changes and are only resolved to concrete points at/// apply time.pub struct LinkedEdits(HashMap<Entity<Buffer>, Vec<(Range<Anchor>, Arc<str>)>>); impl LinkedEdits {    pub fn new() -> Self {        Self(HashMap::default())    }     /// Queries the editor's linked editing ranges for the given anchor range and, if any    /// are found, records them paired with `text` for later application.    pub(crate) fn push(        &mut self,        editor: &Editor,        anchor_range: Range<Anchor>,        text: Arc<str>,        cx: &gpui::App,    ) {        if let Some(editing_ranges) = editor.linked_editing_ranges_for(anchor_range, cx) {            for (buffer, ranges) in editing_ranges {                self.0                    .entry(buffer)                    .or_default()                    .extend(ranges.into_iter().map(|range| (range, text.clone())));            }        }    }     /// Resolves all stored anchor ranges to points using the current buffer snapshot,    /// sorts them, and applies the edits.    pub fn apply(self, cx: &mut Context<Editor>) {        self.apply_inner(false, cx);    }     /// Like [`apply`](Self::apply), but empty ranges (where start == end) are    /// expanded one character to the left before applying. For context, this    /// was introduced in order to be available to `backspace` so as to delete a    /// character in each linked range even when the selection was a cursor.    pub fn apply_with_left_expansion(self, cx: &mut Context<Editor>) {        self.apply_inner(true, cx);    }     fn apply_inner(self, expand_empty_ranges_left: bool, cx: &mut Context<Editor>) {        for (buffer, ranges_edits) in self.0 {            buffer.update(cx, |buffer, cx| {                let snapshot = buffer.snapshot();                let edits = ranges_edits                    .into_iter()                    .map(|(range, text)| {                        let mut start = range.start.to_point(&snapshot);                        let end = range.end.to_point(&snapshot);                         if expand_empty_ranges_left && start == end {                            let offset = range.start.to_offset(&snapshot).saturating_sub(1);                            start = snapshot.clip_point(offset.to_point(&snapshot), Bias::Left);                        }                         (start..end, text)                    })                    .sorted_by_key(|(range, _)| range.start);                 buffer.edit(edits, None, cx);            });        }    }} #[cfg(test)]mod tests {    use crate::{editor_tests::init_test, test::editor_test_context::EditorTestContext};    use gpui::TestAppContext;    use text::Point;     #[gpui::test]    async fn test_linked_edits_push_and_apply(cx: &mut TestAppContext) {        init_test(cx, |_| {});        let mut cx = EditorTestContext::new(cx).await;         cx.set_state("<diˇv></div>");        cx.update_editor(|editor, _window, cx| {            editor                .set_linked_edit_ranges_for_testing(                    vec![(                        Point::new(0, 1)..Point::new(0, 4),                        vec![Point::new(0, 7)..Point::new(0, 10)],                    )],                    cx,                )                .unwrap();        });         cx.simulate_keystroke("x");        cx.assert_editor_state("<dixˇv></dixv>");    }     #[gpui::test]    async fn test_linked_edits_backspace(cx: &mut TestAppContext) {        init_test(cx, |_| {});        let mut cx = EditorTestContext::new(cx).await;         cx.set_state("<divˇ></div>");        cx.update_editor(|editor, _window, cx| {            editor                .set_linked_edit_ranges_for_testing(                    vec![(                        Point::new(0, 1)..Point::new(0, 4),                        vec![Point::new(0, 7)..Point::new(0, 10)],                    )],                    cx,                )                .unwrap();        });         cx.update_editor(|editor, window, cx| {            editor.backspace(&Default::default(), window, cx);        });        cx.assert_editor_state("<diˇ></di>");    }     #[gpui::test]    async fn test_linked_edits_delete(cx: &mut TestAppContext) {        init_test(cx, |_| {});        let mut cx = EditorTestContext::new(cx).await;         cx.set_state("<ˇdiv></div>");        cx.update_editor(|editor, _window, cx| {            editor                .set_linked_edit_ranges_for_testing(                    vec![(                        Point::new(0, 1)..Point::new(0, 4),                        vec![Point::new(0, 7)..Point::new(0, 10)],                    )],                    cx,                )                .unwrap();        });         cx.update_editor(|editor, window, cx| {            editor.delete(&Default::default(), window, cx);        });        cx.assert_editor_state("<ˇiv></iv>");    }     #[gpui::test]    async fn test_linked_edits_selection(cx: &mut TestAppContext) {        init_test(cx, |_| {});        let mut cx = EditorTestContext::new(cx).await;         cx.set_state("<«divˇ»></div>");        cx.update_editor(|editor, _window, cx| {            editor                .set_linked_edit_ranges_for_testing(                    vec![(                        Point::new(0, 1)..Point::new(0, 4),                        vec![Point::new(0, 7)..Point::new(0, 10)],                    )],                    cx,                )                .unwrap();        });         cx.simulate_keystrokes("s p a n");        cx.assert_editor_state("<spanˇ></span>");    }}