Move multi_buffer to editor crate

crates/language/src/language.rs

@@ -1,7 +1,6 @@
 mod buffer;
 mod diagnostic_set;
 mod highlight_map;
-pub mod multi_buffer;
 pub mod proto;
 #[cfg(test)]
 mod tests;
@@ -14,7 +13,6 @@ use gpui::{executor::Background, AppContext};
 use highlight_map::HighlightMap;
 use lazy_static::lazy_static;
 use lsp::LanguageServer;
-pub use multi_buffer::MultiBuffer;
 use parking_lot::Mutex;
 use serde::Deserialize;
 use std::{collections::HashSet, path::Path, str, sync::Arc};

crates/language/src/multi_buffer/anchor.rs

@@ -1,113 +0,0 @@
-use super::{ExcerptId, MultiBufferSnapshot, ToOffset, ToPoint};
-use anyhow::{anyhow, Result};
-use std::{
-    cmp::Ordering,
-    ops::{Range, Sub},
-};
-use sum_tree::Bias;
-use text::{rope::TextDimension, Point};
-
-#[derive(Clone, Eq, PartialEq, Debug, Hash)]
-pub struct Anchor {
-    pub(crate) excerpt_id: ExcerptId,
-    pub(crate) text_anchor: text::Anchor,
-}
-
-impl Anchor {
-    pub fn min() -> Self {
-        Self {
-            excerpt_id: ExcerptId::min(),
-            text_anchor: text::Anchor::min(),
-        }
-    }
-
-    pub fn max() -> Self {
-        Self {
-            excerpt_id: ExcerptId::max(),
-            text_anchor: text::Anchor::max(),
-        }
-    }
-
-    pub fn cmp<'a>(&self, other: &Anchor, snapshot: &MultiBufferSnapshot) -> Result<Ordering> {
-        let excerpt_id_cmp = self.excerpt_id.cmp(&other.excerpt_id);
-        if excerpt_id_cmp.is_eq() {
-            if self.excerpt_id == ExcerptId::max() {
-                return Ok(Ordering::Equal);
-            }
-            self.text_anchor.cmp(
-                &other.text_anchor,
-                snapshot
-                    .buffer_snapshot_for_excerpt(&self.excerpt_id)
-                    .ok_or_else(|| anyhow!("excerpt {:?} not found", self.excerpt_id))?,
-            )
-        } else {
-            return Ok(excerpt_id_cmp);
-        }
-    }
-
-    pub fn bias_left(&self, snapshot: &MultiBufferSnapshot) -> Anchor {
-        if self.text_anchor.bias != Bias::Left {
-            if let Some(buffer_snapshot) = snapshot.buffer_snapshot_for_excerpt(&self.excerpt_id) {
-                return Self {
-                    excerpt_id: self.excerpt_id.clone(),
-                    text_anchor: self.text_anchor.bias_left(buffer_snapshot),
-                };
-            }
-        }
-        self.clone()
-    }
-
-    pub fn bias_right(&self, snapshot: &MultiBufferSnapshot) -> Anchor {
-        if self.text_anchor.bias != Bias::Right {
-            if let Some(buffer_snapshot) = snapshot.buffer_snapshot_for_excerpt(&self.excerpt_id) {
-                return Self {
-                    excerpt_id: self.excerpt_id.clone(),
-                    text_anchor: self.text_anchor.bias_right(buffer_snapshot),
-                };
-            }
-        }
-        self.clone()
-    }
-
-    pub fn summary<D>(&self, snapshot: &MultiBufferSnapshot) -> D
-    where
-        D: TextDimension + Ord + Sub<D, Output = D>,
-    {
-        snapshot.summary_for_anchor(self)
-    }
-}
-
-impl ToOffset for Anchor {
-    fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
-        self.summary(snapshot)
-    }
-}
-
-impl ToPoint for Anchor {
-    fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {
-        self.summary(snapshot)
-    }
-}
-
-pub trait AnchorRangeExt {
-    fn cmp(&self, b: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> Result<Ordering>;
-    fn to_offset(&self, content: &MultiBufferSnapshot) -> Range<usize>;
-    fn to_point(&self, content: &MultiBufferSnapshot) -> Range<Point>;
-}
-
-impl AnchorRangeExt for Range<Anchor> {
-    fn cmp(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> Result<Ordering> {
-        Ok(match self.start.cmp(&other.start, buffer)? {
-            Ordering::Equal => other.end.cmp(&self.end, buffer)?,
-            ord @ _ => ord,
-        })
-    }
-
-    fn to_offset(&self, content: &MultiBufferSnapshot) -> Range<usize> {
-        self.start.to_offset(&content)..self.end.to_offset(&content)
-    }
-
-    fn to_point(&self, content: &MultiBufferSnapshot) -> Range<Point> {
-        self.start.to_point(&content)..self.end.to_point(&content)
-    }
-}

crates/language/src/multi_buffer/selection.rs

@@ -1,121 +0,0 @@
-use super::{Anchor, MultiBufferSnapshot, ToOffset};
-use std::{
-    ops::{Range, Sub},
-    sync::Arc,
-};
-use sum_tree::Bias;
-use text::{rope::TextDimension, Selection, SelectionSetId};
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct SelectionSet {
-    pub id: SelectionSetId,
-    pub active: bool,
-    pub selections: Arc<[Selection<Anchor>]>,
-}
-
-impl SelectionSet {
-    pub fn len(&self) -> usize {
-        self.selections.len()
-    }
-
-    pub fn selections<'a, D>(
-        &'a self,
-        snapshot: &'a MultiBufferSnapshot,
-    ) -> impl 'a + Iterator<Item = Selection<D>>
-    where
-        D: TextDimension + Ord + Sub<D, Output = D>,
-    {
-        resolve_selections(&self.selections, snapshot)
-    }
-
-    pub fn intersecting_selections<'a, D, I>(
-        &'a self,
-        range: Range<(I, Bias)>,
-        snapshot: &'a MultiBufferSnapshot,
-    ) -> impl 'a + Iterator<Item = Selection<D>>
-    where
-        D: TextDimension + Ord + Sub<D, Output = D>,
-        I: 'a + ToOffset,
-    {
-        let start = snapshot.anchor_at(range.start.0, range.start.1);
-        let end = snapshot.anchor_at(range.end.0, range.end.1);
-        let start_ix = match self
-            .selections
-            .binary_search_by(|probe| probe.end.cmp(&start, snapshot).unwrap())
-        {
-            Ok(ix) | Err(ix) => ix,
-        };
-        let end_ix = match self
-            .selections
-            .binary_search_by(|probe| probe.start.cmp(&end, snapshot).unwrap())
-        {
-            Ok(ix) | Err(ix) => ix,
-        };
-        resolve_selections(&self.selections[start_ix..end_ix], snapshot)
-    }
-
-    pub fn oldest_selection<'a, D>(
-        &'a self,
-        snapshot: &'a MultiBufferSnapshot,
-    ) -> Option<Selection<D>>
-    where
-        D: TextDimension + Ord + Sub<D, Output = D>,
-    {
-        self.selections
-            .iter()
-            .min_by_key(|selection| selection.id)
-            .map(|selection| resolve_selection(selection, snapshot))
-    }
-
-    pub fn newest_selection<'a, D>(
-        &'a self,
-        snapshot: &'a MultiBufferSnapshot,
-    ) -> Option<Selection<D>>
-    where
-        D: TextDimension + Ord + Sub<D, Output = D>,
-    {
-        self.selections
-            .iter()
-            .max_by_key(|selection| selection.id)
-            .map(|selection| resolve_selection(selection, snapshot))
-    }
-}
-
-fn resolve_selection<'a, D>(
-    selection: &'a Selection<Anchor>,
-    snapshot: &'a MultiBufferSnapshot,
-) -> Selection<D>
-where
-    D: TextDimension + Ord + Sub<D, Output = D>,
-{
-    Selection {
-        id: selection.id,
-        start: selection.start.summary::<D>(snapshot),
-        end: selection.end.summary::<D>(snapshot),
-        reversed: selection.reversed,
-        goal: selection.goal,
-    }
-}
-
-fn resolve_selections<'a, D>(
-    selections: &'a [Selection<Anchor>],
-    snapshot: &'a MultiBufferSnapshot,
-) -> impl 'a + Iterator<Item = Selection<D>>
-where
-    D: TextDimension + Ord + Sub<D, Output = D>,
-{
-    let mut summaries = snapshot
-        .summaries_for_anchors::<D, _>(
-            selections
-                .iter()
-                .flat_map(|selection| [&selection.start, &selection.end]),
-        )
-        .into_iter();
-    selections.iter().map(move |selection| Selection {
-        id: selection.id,
-        start: summaries.next().unwrap(),
-        end: summaries.next().unwrap(),
-        reversed: selection.reversed,
-        goal: selection.goal,
-    })
-}