lsp: Add support for linked editing range edits (HTML tag autorenaming) (#12769)

This PR adds support for [linked editing of
ranges](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_linkedEditingRange),
which in short means that editing one part of a file can now change
related parts in that same file. Think of automatically renaming
HTML/TSX closing tags when the opening one is changed.
TODO:
- [x] proto changes
- [x] Allow disabling linked editing ranges on a per language basis.

Fixes #4535 

Release Notes:
- Added support for linked editing ranges LSP request. Editing opening
tags in HTML/TSX files (with vtsls) performs the same edit on the
closing tag as well (and vice versa). It can be turned off on a language-by-language basis with the following setting:
```
  "languages": {
    "HTML": {
      "linked_edits": true
    },
  }
```

---------

Co-authored-by: Bennet <bennet@zed.dev>

crates/editor/src/linked_editing_ranges.rs

@@ -0,0 +1,150 @@
+use std::ops::Range;
+
+use collections::HashMap;
+use itertools::Itertools;
+use text::{AnchorRangeExt, BufferId, ToPoint};
+use ui::ViewContext;
+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<text::Anchor>, Vec<Range<text::Anchor>>)>>,
+);
+
+impl LinkedEditingRanges {
+    pub(super) fn get(
+        &self,
+        id: BufferId,
+        anchor: Range<text::Anchor>,
+        snapshot: &text::BufferSnapshot,
+    ) -> Option<&(Range<text::Anchor>, Vec<Range<text::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 refresh_linked_ranges(this: &mut Editor, cx: &mut ViewContext<Editor>) -> Option<()> {
+    if this.pending_rename.is_some() {
+        return None;
+    }
+    let project = this.project.clone()?;
+    let buffer = this.buffer.read(cx);
+    let mut applicable_selections = vec![];
+    let selections = this.selections.all::<usize>(cx);
+    let snapshot = buffer.snapshot(cx);
+    for selection in selections {
+        let cursor_position = selection.head();
+        let start_position = snapshot.anchor_before(cursor_position);
+        let end_position = snapshot.anchor_after(selection.tail());
+        if start_position.buffer_id != end_position.buffer_id || end_position.buffer_id.is_none() {
+            // Throw away selections spanning multiple buffers.
+            continue;
+        }
+        if let Some(buffer) = end_position.buffer_id.and_then(|id| buffer.buffer(id)) {
+            applicable_selections.push((
+                buffer,
+                start_position.text_anchor,
+                end_position.text_anchor,
+            ));
+        }
+    }
+    if applicable_selections.is_empty() {
+        return None;
+    }
+    this.linked_editing_range_task = Some(cx.spawn(|this, mut cx| async move {
+        let highlights = project
+            .update(&mut cx, |project, cx| {
+                let mut linked_edits_tasks = vec![];
+
+                for (buffer, start, end) in &applicable_selections {
+                    let snapshot = buffer.read(cx).snapshot();
+                    let buffer_id = buffer.read(cx).remote_id();
+
+                    let linked_edits_task = project.linked_edit(&buffer, *start, cx);
+                    let highlights = move || async move {
+                        let edits = linked_edits_task.await.log_err()?;
+                        // 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
+                        });
+                        if _current_selection_contains_range.is_none() {
+                            return None;
+                        }
+                        // Now link every range as each-others sibling.
+                        let mut siblings: HashMap<Range<text::Anchor>, Vec<_>> = Default::default();
+                        let mut insert_sorted_anchor =
+                            |key: &Range<text::Anchor>, value: &Range<text::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
+            })
+            .log_err()?;
+
+        let highlights = futures::future::join_all(highlights).await;
+
+        this.update(&mut 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();
+        })
+        .log_err();
+
+        Some(())
+    }));
+    None
+}