Implement anchor resolution using locators

crates/text/src/anchor.rs

@@ -1,117 +1,88 @@
 use crate::{rope::TextDimension, Snapshot};
 
-use super::{Buffer, FromAnchor, FullOffset, Point, ToOffset};
+use super::{Buffer, ToOffset};
 use anyhow::Result;
-use std::{
-    cmp::Ordering,
-    fmt::{Debug, Formatter},
-    ops::Range,
-};
-use sum_tree::{Bias, SumTree};
+use std::{cmp::Ordering, fmt::Debug, ops::Range};
+use sum_tree::Bias;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
-pub struct Anchor {
-    pub full_offset: FullOffset,
-    pub bias: Bias,
-    pub version: clock::Global,
-}
-
-#[derive(Clone)]
-pub struct AnchorMap<T> {
-    pub(crate) version: clock::Global,
-    pub(crate) bias: Bias,
-    pub(crate) entries: Vec<(FullOffset, T)>,
-}
-
-#[derive(Clone)]
-pub struct AnchorSet(pub(crate) AnchorMap<()>);
-
-#[derive(Clone)]
-pub struct AnchorRangeMap<T> {
-    pub(crate) version: clock::Global,
-    pub(crate) entries: Vec<(Range<FullOffset>, T)>,
-    pub(crate) start_bias: Bias,
-    pub(crate) end_bias: Bias,
-}
-
-#[derive(Clone)]
-pub struct AnchorRangeSet(pub(crate) AnchorRangeMap<()>);
-
-#[derive(Clone)]
-pub struct AnchorRangeMultimap<T: Clone> {
-    pub(crate) entries: SumTree<AnchorRangeMultimapEntry<T>>,
-    pub(crate) version: clock::Global,
-    pub(crate) start_bias: Bias,
-    pub(crate) end_bias: Bias,
-}
-
-#[derive(Clone)]
-pub(crate) struct AnchorRangeMultimapEntry<T> {
-    pub(crate) range: FullOffsetRange,
-    pub(crate) value: T,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct FullOffsetRange {
-    pub(crate) start: FullOffset,
-    pub(crate) end: FullOffset,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct AnchorRangeMultimapSummary {
-    start: FullOffset,
-    end: FullOffset,
-    min_start: FullOffset,
-    max_end: FullOffset,
-    count: usize,
+pub enum Anchor {
+    Min,
+    Insertion {
+        timestamp: clock::Local,
+        offset: usize,
+        bias: Bias,
+    },
+    Max,
 }
 
 impl Anchor {
     pub fn min() -> Self {
-        Self {
-            full_offset: FullOffset(0),
-            bias: Bias::Left,
-            version: Default::default(),
-        }
+        Self::Min
     }
 
     pub fn max() -> Self {
-        Self {
-            full_offset: FullOffset::MAX,
-            bias: Bias::Right,
-            version: Default::default(),
-        }
+        Self::Max
     }
 
     pub fn cmp<'a>(&self, other: &Anchor, buffer: &Snapshot) -> Result<Ordering> {
-        if self == other {
-            return Ok(Ordering::Equal);
+        match (self, other) {
+            (Self::Min, Self::Min) => Ok(Ordering::Equal),
+            (Self::Min, _) => Ok(Ordering::Less),
+            (_, Self::Min) => Ok(Ordering::Greater),
+            (Self::Max, Self::Max) => Ok(Ordering::Equal),
+            (Self::Max, _) => Ok(Ordering::Greater),
+            (_, Self::Max) => Ok(Ordering::Less),
+            (
+                Self::Insertion {
+                    timestamp: lhs_id,
+                    bias: lhs_bias,
+                    offset: lhs_offset,
+                },
+                Self::Insertion {
+                    timestamp: rhs_id,
+                    bias: rhs_bias,
+                    offset: rhs_offset,
+                },
+            ) => {
+                let offset_comparison = if lhs_id == rhs_id {
+                    lhs_offset.cmp(&rhs_offset)
+                } else {
+                    buffer
+                        .full_offset_for_anchor(self)
+                        .cmp(&buffer.full_offset_for_anchor(other))
+                };
+
+                Ok(offset_comparison.then_with(|| lhs_bias.cmp(&rhs_bias)))
+            }
         }
-
-        let offset_comparison = if self.version == other.version {
-            self.full_offset.cmp(&other.full_offset)
-        } else {
-            buffer
-                .full_offset_for_anchor(self)
-                .cmp(&buffer.full_offset_for_anchor(other))
-        };
-
-        Ok(offset_comparison.then_with(|| self.bias.cmp(&other.bias)))
     }
 
     pub fn bias_left(&self, buffer: &Buffer) -> Anchor {
-        if self.bias == Bias::Left {
-            self.clone()
-        } else {
-            buffer.anchor_before(self)
+        match self {
+            Anchor::Min => Anchor::Min,
+            Anchor::Insertion { bias, .. } => {
+                if *bias == Bias::Left {
+                    self.clone()
+                } else {
+                    buffer.anchor_before(self)
+                }
+            }
+            Anchor::Max => buffer.anchor_before(self),
         }
     }
 
     pub fn bias_right(&self, buffer: &Buffer) -> Anchor {
-        if self.bias == Bias::Right {
-            self.clone()
-        } else {
-            buffer.anchor_after(self)
+        match self {
+            Anchor::Min => buffer.anchor_after(self),
+            Anchor::Insertion { bias, .. } => {
+                if *bias == Bias::Right {
+                    self.clone()
+                } else {
+                    buffer.anchor_after(self)
+                }
+            }
+            Anchor::Max => Anchor::Max,
         }
     }
 
@@ -123,442 +94,6 @@ impl Anchor {
     }
 }
 
-impl<T> AnchorMap<T> {
-    pub fn version(&self) -> &clock::Global {
-        &self.version
-    }
-
-    pub fn len(&self) -> usize {
-        self.entries.len()
-    }
-
-    pub fn iter<'a, D>(&'a self, snapshot: &'a Snapshot) -> impl Iterator<Item = (D, &'a T)> + 'a
-    where
-        D: 'a + TextDimension<'a>,
-    {
-        snapshot
-            .summaries_for_anchors(
-                self.version.clone(),
-                self.bias,
-                self.entries.iter().map(|e| &e.0),
-            )
-            .zip(self.entries.iter().map(|e| &e.1))
-    }
-}
-
-impl AnchorSet {
-    pub fn version(&self) -> &clock::Global {
-        &self.0.version
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn iter<'a, D>(&'a self, content: &'a Snapshot) -> impl Iterator<Item = D> + 'a
-    where
-        D: 'a + TextDimension<'a>,
-    {
-        self.0.iter(content).map(|(position, _)| position)
-    }
-}
-
-impl<T> AnchorRangeMap<T> {
-    pub fn version(&self) -> &clock::Global {
-        &self.version
-    }
-
-    pub fn len(&self) -> usize {
-        self.entries.len()
-    }
-
-    pub fn from_full_offset_ranges(
-        version: clock::Global,
-        start_bias: Bias,
-        end_bias: Bias,
-        entries: Vec<(Range<FullOffset>, T)>,
-    ) -> Self {
-        Self {
-            version,
-            start_bias,
-            end_bias,
-            entries,
-        }
-    }
-
-    pub fn ranges<'a, D>(
-        &'a self,
-        content: &'a Snapshot,
-    ) -> impl Iterator<Item = (Range<D>, &'a T)> + 'a
-    where
-        D: 'a + TextDimension<'a>,
-    {
-        content
-            .summaries_for_anchor_ranges(
-                self.version.clone(),
-                self.start_bias,
-                self.end_bias,
-                self.entries.iter().map(|e| &e.0),
-            )
-            .zip(self.entries.iter().map(|e| &e.1))
-    }
-
-    pub fn intersecting_ranges<'a, D, I>(
-        &'a self,
-        range: Range<(I, Bias)>,
-        content: &'a Snapshot,
-    ) -> impl Iterator<Item = (Range<D>, &'a T)> + 'a
-    where
-        D: 'a + TextDimension<'a>,
-        I: ToOffset,
-    {
-        let range = content.anchor_at(range.start.0, range.start.1)
-            ..content.anchor_at(range.end.0, range.end.1);
-
-        let mut probe_anchor = Anchor {
-            full_offset: Default::default(),
-            bias: self.start_bias,
-            version: self.version.clone(),
-        };
-        let start_ix = self.entries.binary_search_by(|probe| {
-            probe_anchor.full_offset = probe.0.end;
-            probe_anchor.cmp(&range.start, &content).unwrap()
-        });
-
-        match start_ix {
-            Ok(start_ix) | Err(start_ix) => content
-                .summaries_for_anchor_ranges(
-                    self.version.clone(),
-                    self.start_bias,
-                    self.end_bias,
-                    self.entries[start_ix..].iter().map(|e| &e.0),
-                )
-                .zip(self.entries.iter().map(|e| &e.1)),
-        }
-    }
-
-    pub fn full_offset_ranges(&self) -> impl Iterator<Item = &(Range<FullOffset>, T)> {
-        self.entries.iter()
-    }
-
-    pub fn min_by_key<'a, D, F, K>(
-        &self,
-        content: &'a Snapshot,
-        mut extract_key: F,
-    ) -> Option<(Range<D>, &T)>
-    where
-        D: 'a + TextDimension<'a>,
-        F: FnMut(&T) -> K,
-        K: Ord,
-    {
-        self.entries
-            .iter()
-            .min_by_key(|(_, value)| extract_key(value))
-            .map(|(range, value)| (self.resolve_range(range, &content), value))
-    }
-
-    pub fn max_by_key<'a, D, F, K>(
-        &self,
-        content: &'a Snapshot,
-        mut extract_key: F,
-    ) -> Option<(Range<D>, &T)>
-    where
-        D: 'a + TextDimension<'a>,
-        F: FnMut(&T) -> K,
-        K: Ord,
-    {
-        self.entries
-            .iter()
-            .max_by_key(|(_, value)| extract_key(value))
-            .map(|(range, value)| (self.resolve_range(range, &content), value))
-    }
-
-    fn resolve_range<'a, D>(&self, range: &Range<FullOffset>, content: &'a Snapshot) -> Range<D>
-    where
-        D: 'a + TextDimension<'a>,
-    {
-        let mut anchor = Anchor {
-            full_offset: range.start,
-            bias: self.start_bias,
-            version: self.version.clone(),
-        };
-        let start = content.summary_for_anchor(&anchor);
-
-        anchor.full_offset = range.end;
-        anchor.bias = self.end_bias;
-        let end = content.summary_for_anchor(&anchor);
-
-        start..end
-    }
-}
-
-impl<T: PartialEq> PartialEq for AnchorRangeMap<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.version == other.version && self.entries == other.entries
-    }
-}
-
-impl<T: Eq> Eq for AnchorRangeMap<T> {}
-
-impl<T: Debug> Debug for AnchorRangeMap<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
-        let mut f = f.debug_map();
-        for (range, value) in &self.entries {
-            f.key(range);
-            f.value(value);
-        }
-        f.finish()
-    }
-}
-
-impl Debug for AnchorRangeSet {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let mut f = f.debug_set();
-        for (range, _) in &self.0.entries {
-            f.entry(range);
-        }
-        f.finish()
-    }
-}
-
-impl AnchorRangeSet {
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn version(&self) -> &clock::Global {
-        self.0.version()
-    }
-
-    pub fn ranges<'a, D>(&'a self, content: &'a Snapshot) -> impl 'a + Iterator<Item = Range<Point>>
-    where
-        D: 'a + TextDimension<'a>,
-    {
-        self.0.ranges(content).map(|(range, _)| range)
-    }
-}
-
-impl<T: Clone> Default for AnchorRangeMultimap<T> {
-    fn default() -> Self {
-        Self {
-            entries: Default::default(),
-            version: Default::default(),
-            start_bias: Bias::Left,
-            end_bias: Bias::Left,
-        }
-    }
-}
-
-impl<T: Clone> AnchorRangeMultimap<T> {
-    pub fn version(&self) -> &clock::Global {
-        &self.version
-    }
-
-    pub fn intersecting_ranges<'a, I, O>(
-        &'a self,
-        range: Range<I>,
-        content: &'a Snapshot,
-        inclusive: bool,
-    ) -> impl Iterator<Item = (usize, Range<O>, &T)> + 'a
-    where
-        I: ToOffset,
-        O: FromAnchor,
-    {
-        let end_bias = if inclusive { Bias::Right } else { Bias::Left };
-        let range = range.start.to_full_offset(&content, Bias::Left)
-            ..range.end.to_full_offset(&content, end_bias);
-        let mut cursor = self.entries.filter::<_, usize>(
-            {
-                let mut endpoint = Anchor {
-                    full_offset: FullOffset(0),
-                    bias: Bias::Right,
-                    version: self.version.clone(),
-                };
-                move |summary: &AnchorRangeMultimapSummary| {
-                    endpoint.full_offset = summary.max_end;
-                    endpoint.bias = self.end_bias;
-                    let max_end = endpoint.to_full_offset(&content, self.end_bias);
-                    let start_cmp = range.start.cmp(&max_end);
-
-                    endpoint.full_offset = summary.min_start;
-                    endpoint.bias = self.start_bias;
-                    let min_start = endpoint.to_full_offset(&content, self.start_bias);
-                    let end_cmp = range.end.cmp(&min_start);
-
-                    if inclusive {
-                        start_cmp <= Ordering::Equal && end_cmp >= Ordering::Equal
-                    } else {
-                        start_cmp == Ordering::Less && end_cmp == Ordering::Greater
-                    }
-                }
-            },
-            &(),
-        );
-
-        std::iter::from_fn({
-            let mut endpoint = Anchor {
-                full_offset: FullOffset(0),
-                bias: Bias::Left,
-                version: self.version.clone(),
-            };
-            move || {
-                if let Some(item) = cursor.item() {
-                    let ix = *cursor.start();
-                    endpoint.full_offset = item.range.start;
-                    endpoint.bias = self.start_bias;
-                    let start = O::from_anchor(&endpoint, &content);
-                    endpoint.full_offset = item.range.end;
-                    endpoint.bias = self.end_bias;
-                    let end = O::from_anchor(&endpoint, &content);
-                    let value = &item.value;
-                    cursor.next(&());
-                    Some((ix, start..end, value))
-                } else {
-                    None
-                }
-            }
-        })
-    }
-
-    pub fn from_full_offset_ranges(
-        version: clock::Global,
-        start_bias: Bias,
-        end_bias: Bias,
-        entries: impl Iterator<Item = (Range<FullOffset>, T)>,
-    ) -> Self {
-        Self {
-            version,
-            start_bias,
-            end_bias,
-            entries: SumTree::from_iter(
-                entries.map(|(range, value)| AnchorRangeMultimapEntry {
-                    range: FullOffsetRange {
-                        start: range.start,
-                        end: range.end,
-                    },
-                    value,
-                }),
-                &(),
-            ),
-        }
-    }
-
-    pub fn full_offset_ranges(&self) -> impl Iterator<Item = (Range<FullOffset>, &T)> {
-        self.entries
-            .cursor::<()>()
-            .map(|entry| (entry.range.start..entry.range.end, &entry.value))
-    }
-
-    pub fn filter<'a, O, F>(
-        &'a self,
-        content: &'a Snapshot,
-        mut f: F,
-    ) -> impl 'a + Iterator<Item = (usize, Range<O>, &T)>
-    where
-        O: FromAnchor,
-        F: 'a + FnMut(&'a T) -> bool,
-    {
-        let mut endpoint = Anchor {
-            full_offset: FullOffset(0),
-            bias: Bias::Left,
-            version: self.version.clone(),
-        };
-        self.entries
-            .cursor::<()>()
-            .enumerate()
-            .filter_map(move |(ix, entry)| {
-                if f(&entry.value) {
-                    endpoint.full_offset = entry.range.start;
-                    endpoint.bias = self.start_bias;
-                    let start = O::from_anchor(&endpoint, &content);
-                    endpoint.full_offset = entry.range.end;
-                    endpoint.bias = self.end_bias;
-                    let end = O::from_anchor(&endpoint, &content);
-                    Some((ix, start..end, &entry.value))
-                } else {
-                    None
-                }
-            })
-    }
-}
-
-impl<T: Clone> sum_tree::Item for AnchorRangeMultimapEntry<T> {
-    type Summary = AnchorRangeMultimapSummary;
-
-    fn summary(&self) -> Self::Summary {
-        AnchorRangeMultimapSummary {
-            start: self.range.start,
-            end: self.range.end,
-            min_start: self.range.start,
-            max_end: self.range.end,
-            count: 1,
-        }
-    }
-}
-
-impl Default for AnchorRangeMultimapSummary {
-    fn default() -> Self {
-        Self {
-            start: FullOffset(0),
-            end: FullOffset::MAX,
-            min_start: FullOffset::MAX,
-            max_end: FullOffset(0),
-            count: 0,
-        }
-    }
-}
-
-impl sum_tree::Summary for AnchorRangeMultimapSummary {
-    type Context = ();
-
-    fn add_summary(&mut self, other: &Self, _: &Self::Context) {
-        self.min_start = self.min_start.min(other.min_start);
-        self.max_end = self.max_end.max(other.max_end);
-
-        #[cfg(debug_assertions)]
-        {
-            let start_comparison = self.start.cmp(&other.start);
-            assert!(start_comparison <= Ordering::Equal);
-            if start_comparison == Ordering::Equal {
-                assert!(self.end.cmp(&other.end) >= Ordering::Equal);
-            }
-        }
-
-        self.start = other.start;
-        self.end = other.end;
-        self.count += other.count;
-    }
-}
-
-impl Default for FullOffsetRange {
-    fn default() -> Self {
-        Self {
-            start: FullOffset(0),
-            end: FullOffset::MAX,
-        }
-    }
-}
-
-impl<'a> sum_tree::Dimension<'a, AnchorRangeMultimapSummary> for usize {
-    fn add_summary(&mut self, summary: &'a AnchorRangeMultimapSummary, _: &()) {
-        *self += summary.count;
-    }
-}
-
-impl<'a> sum_tree::Dimension<'a, AnchorRangeMultimapSummary> for FullOffsetRange {
-    fn add_summary(&mut self, summary: &'a AnchorRangeMultimapSummary, _: &()) {
-        self.start = summary.start;
-        self.end = summary.end;
-    }
-}
-
-impl<'a> sum_tree::SeekTarget<'a, AnchorRangeMultimapSummary, FullOffsetRange> for FullOffsetRange {
-    fn cmp(&self, cursor_location: &FullOffsetRange, _: &()) -> Ordering {
-        Ord::cmp(&self.start, &cursor_location.start)
-            .then_with(|| Ord::cmp(&cursor_location.end, &self.end))
-    }
-}
-
 pub trait AnchorRangeExt {
     fn cmp(&self, b: &Range<Anchor>, buffer: &Snapshot) -> Result<Ordering>;
     fn to_offset(&self, content: &Snapshot) -> Range<usize>;

crates/text/src/selection.rs

@@ -1,8 +1,8 @@
 use sum_tree::Bias;
 
-use crate::{rope::TextDimension, Snapshot};
+use crate::{rope::TextDimension, Anchor, Snapshot};
 
-use super::{AnchorRangeMap, Buffer, Point, ToOffset, ToPoint};
+use super::{Buffer, Point, ToOffset, ToPoint};
 use std::{cmp::Ordering, ops::Range, sync::Arc};
 
 pub type SelectionSetId = clock::Lamport;
@@ -28,7 +28,7 @@ pub struct Selection<T> {
 pub struct SelectionSet {
     pub id: SelectionSetId,
     pub active: bool,
-    pub selections: Arc<AnchorRangeMap<SelectionState>>,
+    pub selections: Arc<[Selection<Anchor>]>,
 }
 
 #[derive(Debug, Eq, PartialEq)]
@@ -98,6 +98,21 @@ impl<T: ToOffset + ToPoint + Copy + Ord> Selection<T> {
     }
 }
 
+impl Selection<Anchor> {
+    pub fn resolve<'a, D: 'a + TextDimension<'a>>(
+        &'a self,
+        snapshot: &'a Snapshot,
+    ) -> Selection<D> {
+        Selection {
+            id: self.id,
+            start: snapshot.summary_for_anchor(&self.start),
+            end: snapshot.summary_for_anchor(&self.end),
+            reversed: self.reversed,
+            goal: self.goal,
+        }
+    }
+}
+
 impl SelectionSet {
     pub fn len(&self) -> usize {
         self.selections.len()
@@ -105,69 +120,59 @@ impl SelectionSet {
 
     pub fn selections<'a, D>(
         &'a self,
-        content: &'a Snapshot,
+        snapshot: &'a Snapshot,
     ) -> impl 'a + Iterator<Item = Selection<D>>
     where
         D: 'a + TextDimension<'a>,
     {
-        self.selections
-            .ranges(content)
-            .map(|(range, state)| Selection {
-                id: state.id,
-                start: range.start,
-                end: range.end,
-                reversed: state.reversed,
-                goal: state.goal,
-            })
+        self.selections.iter().map(|s| s.resolve(snapshot))
     }
 
     pub fn intersecting_selections<'a, D, I>(
         &'a self,
         range: Range<(I, Bias)>,
-        content: &'a Snapshot,
+        snapshot: &'a Snapshot,
     ) -> impl 'a + Iterator<Item = Selection<D>>
     where
         D: 'a + TextDimension<'a>,
         I: 'a + ToOffset,
     {
-        self.selections
-            .intersecting_ranges(range, content)
-            .map(|(range, state)| Selection {
-                id: state.id,
-                start: range.start,
-                end: range.end,
-                reversed: state.reversed,
-                goal: state.goal,
-            })
+        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.start.cmp(&start, snapshot).unwrap())
+        {
+            Ok(ix) | Err(ix) => ix,
+        };
+        let end_ix = match self
+            .selections
+            .binary_search_by(|probe| probe.end.cmp(&end, snapshot).unwrap())
+        {
+            Ok(ix) | Err(ix) => ix,
+        };
+        self.selections[start_ix..end_ix]
+            .iter()
+            .map(|s| s.resolve(snapshot))
     }
 
-    pub fn oldest_selection<'a, D>(&'a self, content: &'a Snapshot) -> Option<Selection<D>>
+    pub fn oldest_selection<'a, D>(&'a self, snapshot: &'a Snapshot) -> Option<Selection<D>>
     where
         D: 'a + TextDimension<'a>,
     {
         self.selections
-            .min_by_key(content, |selection| selection.id)
-            .map(|(range, state)| Selection {
-                id: state.id,
-                start: range.start,
-                end: range.end,
-                reversed: state.reversed,
-                goal: state.goal,
-            })
+            .iter()
+            .min_by_key(|s| s.id)
+            .map(|s| s.resolve(snapshot))
     }
 
-    pub fn newest_selection<'a, D>(&'a self, content: &'a Snapshot) -> Option<Selection<D>>
+    pub fn newest_selection<'a, D>(&'a self, snapshot: &'a Snapshot) -> Option<Selection<D>>
     where
         D: 'a + TextDimension<'a>,
     {
         self.selections
-            .max_by_key(content, |selection| selection.id)
-            .map(|(range, state)| Selection {
-                id: state.id,
-                start: range.start,
-                end: range.end,
-                reversed: state.reversed,
-                goal: state.goal,
-            })
+            .iter()
+            .max_by_key(|s| s.id)
+            .map(|s| s.resolve(snapshot))
     }
 }

crates/text/src/tests.rs

@@ -645,11 +645,13 @@ impl Buffer {
             assert_eq!(insertion_fragment.fragment_id, fragment.id);
         }
 
-        let insertions = self.snapshot.insertions.items(&());
-        assert_eq!(
-            HashSet::from_iter(insertions.iter().map(|i| &i.fragment_id)).len(),
-            insertions.len()
-        );
+        let mut cursor = self.snapshot.fragments.cursor::<Locator>();
+        for insertion_fragment in self.snapshot.insertions.cursor::<()>() {
+            cursor.seek(&insertion_fragment.fragment_id, Bias::Left, &None);
+            let fragment = cursor.item().unwrap();
+            assert_eq!(insertion_fragment.fragment_id, fragment.id);
+            assert_eq!(insertion_fragment.split_offset, fragment.insertion_offset);
+        }
     }
 }
 

crates/text/src/text.rs

@@ -27,7 +27,7 @@ use rope::TextDimension;
 pub use rope::{Chunks, Rope, TextSummary};
 pub use selection::*;
 use std::{
-    cmp::{self, Reverse},
+    cmp::{self, Ordering},
     iter::Iterator,
     ops::{self, Deref, Range, Sub},
     str,
@@ -67,8 +67,8 @@ pub struct Transaction {
     end: clock::Global,
     edits: Vec<clock::Local>,
     ranges: Vec<Range<FullOffset>>,
-    selections_before: HashMap<SelectionSetId, Arc<AnchorRangeMap<SelectionState>>>,
-    selections_after: HashMap<SelectionSetId, Arc<AnchorRangeMap<SelectionState>>>,
+    selections_before: HashMap<SelectionSetId, Arc<[Selection<Anchor>]>>,
+    selections_after: HashMap<SelectionSetId, Arc<[Selection<Anchor>]>>,
     first_edit_at: Instant,
     last_edit_at: Instant,
 }
@@ -155,7 +155,7 @@ impl History {
     fn start_transaction(
         &mut self,
         start: clock::Global,
-        selections_before: HashMap<SelectionSetId, Arc<AnchorRangeMap<SelectionState>>>,
+        selections_before: HashMap<SelectionSetId, Arc<[Selection<Anchor>]>>,
         now: Instant,
     ) {
         self.transaction_depth += 1;
@@ -175,7 +175,7 @@ impl History {
 
     fn end_transaction(
         &mut self,
-        selections_after: HashMap<SelectionSetId, Arc<AnchorRangeMap<SelectionState>>>,
+        selections_after: HashMap<SelectionSetId, Arc<[Selection<Anchor>]>>,
         now: Instant,
     ) -> Option<&Transaction> {
         assert_ne!(self.transaction_depth, 0);
@@ -430,7 +430,7 @@ pub enum Operation {
     },
     UpdateSelections {
         set_id: SelectionSetId,
-        selections: Arc<AnchorRangeMap<SelectionState>>,
+        selections: Arc<[Selection<Anchor>]>,
         lamport_timestamp: clock::Lamport,
     },
     RemoveSelections {
@@ -1122,9 +1122,9 @@ impl Buffer {
             match op {
                 Operation::Edit(edit) => self.version.ge(&edit.version),
                 Operation::Undo { undo, .. } => self.version.ge(&undo.version),
-                Operation::UpdateSelections { selections, .. } => {
-                    self.version.ge(selections.version())
-                }
+                Operation::UpdateSelections { selections, .. } => selections
+                    .iter()
+                    .all(|s| self.can_resolve(&s.start) && self.can_resolve(&s.end)),
                 Operation::RemoveSelections { .. } => true,
                 Operation::SetActiveSelections { set_id, .. } => {
                     set_id.map_or(true, |set_id| self.selections.contains_key(&set_id))
@@ -1135,6 +1135,14 @@ impl Buffer {
         }
     }
 
+    fn can_resolve(&self, anchor: &Anchor) -> bool {
+        match anchor {
+            Anchor::Min => true,
+            Anchor::Insertion { timestamp, .. } => self.version.observed(*timestamp),
+            Anchor::Max => true,
+        }
+    }
+
     pub fn peek_undo_stack(&self) -> Option<&Transaction> {
         self.history.undo_stack.last()
     }
@@ -1280,25 +1288,22 @@ impl Buffer {
         self.selections.iter()
     }
 
-    fn build_selection_anchor_range_map<T: ToOffset>(
+    fn build_anchor_selection_set<T: ToOffset>(
         &self,
         selections: &[Selection<T>],
-    ) -> Arc<AnchorRangeMap<SelectionState>> {
-        Arc::new(self.anchor_range_map(
-            Bias::Left,
-            Bias::Left,
-            selections.iter().map(|selection| {
-                let start = selection.start.to_offset(self);
-                let end = selection.end.to_offset(self);
-                let range = start..end;
-                let state = SelectionState {
+    ) -> Arc<[Selection<Anchor>]> {
+        Arc::from(
+            selections
+                .iter()
+                .map(|selection| Selection {
                     id: selection.id,
+                    start: self.anchor_before(&selection.start),
+                    end: self.anchor_before(&selection.end),
                     reversed: selection.reversed,
                     goal: selection.goal,
-                };
-                (range, state)
-            }),
-        ))
+                })
+                .collect::<Vec<_>>(),
+        )
     }
 
     pub fn update_selection_set<T: ToOffset>(
@@ -1306,7 +1311,7 @@ impl Buffer {
         set_id: SelectionSetId,
         selections: &[Selection<T>],
     ) -> Result<Operation> {
-        let selections = self.build_selection_anchor_range_map(selections);
+        let selections = self.build_anchor_selection_set(selections);
         let set = self
             .selections
             .get_mut(&set_id)
@@ -1322,7 +1327,7 @@ impl Buffer {
     pub fn restore_selection_set(
         &mut self,
         set_id: SelectionSetId,
-        selections: Arc<AnchorRangeMap<SelectionState>>,
+        selections: Arc<[Selection<Anchor>]>,
     ) -> Result<Operation> {
         let set = self
             .selections
@@ -1337,7 +1342,7 @@ impl Buffer {
     }
 
     pub fn add_selection_set<T: ToOffset>(&mut self, selections: &[Selection<T>]) -> Operation {
-        let selections = self.build_selection_anchor_range_map(selections);
+        let selections = self.build_anchor_selection_set(selections);
         let set_id = self.lamport_clock.tick();
         self.selections.insert(
             set_id,
@@ -1675,19 +1680,81 @@ impl Snapshot {
     where
         D: TextDimension<'a>,
     {
-        let cx = Some(anchor.version.clone());
-        let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
-        cursor.seek(
-            &VersionedFullOffset::Offset(anchor.full_offset),
-            anchor.bias,
-            &cx,
-        );
-        let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
-            anchor.full_offset - cursor.start().0.full_offset()
-        } else {
-            0
-        };
-        self.text_summary_for_range(0..cursor.start().1 + overshoot)
+        match anchor {
+            Anchor::Min => D::default(),
+            Anchor::Insertion {
+                timestamp,
+                offset,
+                bias,
+            } => {
+                let anchor_key = InsertionFragmentKey {
+                    timestamp: *timestamp,
+                    split_offset: *offset,
+                };
+                let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
+                insertion_cursor.seek(&anchor_key, *bias, &());
+                if let Some(insertion) = insertion_cursor.item() {
+                    let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
+                    if comparison == Ordering::Greater
+                        || (*bias == Bias::Left && comparison == Ordering::Equal && *offset > 0)
+                    {
+                        insertion_cursor.prev(&());
+                    }
+                } else {
+                    insertion_cursor.prev(&());
+                }
+                let insertion = insertion_cursor.item().expect("invalid insertion");
+                debug_assert_eq!(insertion.timestamp, *timestamp, "invalid insertion");
+
+                let mut fragment_cursor = self.fragments.cursor::<(Locator, usize)>();
+                fragment_cursor.seek(&insertion.fragment_id, Bias::Left, &None);
+                let fragment = fragment_cursor.item().unwrap();
+                let mut fragment_offset = fragment_cursor.start().1;
+                if fragment.visible {
+                    fragment_offset += *offset - insertion.split_offset;
+                }
+                self.text_summary_for_range(0..fragment_offset)
+            }
+            Anchor::Max => D::from_text_summary(&self.visible_text.summary()),
+        }
+    }
+
+    fn full_offset_for_anchor(&self, anchor: &Anchor) -> FullOffset {
+        match anchor {
+            Anchor::Min => Default::default(),
+            Anchor::Insertion {
+                timestamp,
+                offset,
+                bias,
+            } => {
+                let anchor_key = InsertionFragmentKey {
+                    timestamp: *timestamp,
+                    split_offset: *offset,
+                };
+                let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
+                insertion_cursor.seek(&anchor_key, *bias, &());
+                if let Some(insertion) = insertion_cursor.item() {
+                    let comparison = sum_tree::KeyedItem::key(insertion).cmp(&anchor_key);
+                    if comparison == Ordering::Greater
+                        || (*bias == Bias::Left && comparison == Ordering::Equal && *offset > 0)
+                    {
+                        insertion_cursor.prev(&());
+                    }
+                } else {
+                    insertion_cursor.prev(&());
+                }
+                let insertion = insertion_cursor.item().expect("invalid insertion");
+                debug_assert_eq!(insertion.timestamp, *timestamp, "invalid insertion");
+
+                let mut fragment_cursor = self.fragments.cursor::<(Locator, FullOffset)>();
+                fragment_cursor.seek(&insertion.fragment_id, Bias::Left, &None);
+                fragment_cursor.start().1 + (*offset - insertion.split_offset)
+            }
+            Anchor::Max => {
+                let text = self.fragments.summary().text;
+                FullOffset(text.visible + text.deleted)
+            }
+        }
     }
 
     pub fn text_summary_for_range<'a, D, O: ToOffset>(&'a self, range: Range<O>) -> D
@@ -1699,70 +1766,6 @@ impl Snapshot {
             .summary(range.end.to_offset(self))
     }
 
-    fn summaries_for_anchors<'a, D, I>(
-        &'a self,
-        version: clock::Global,
-        bias: Bias,
-        ranges: I,
-    ) -> impl 'a + Iterator<Item = D>
-    where
-        D: 'a + TextDimension<'a>,
-        I: 'a + IntoIterator<Item = &'a FullOffset>,
-    {
-        let cx = Some(version.clone());
-        let mut summary = D::default();
-        let mut rope_cursor = self.visible_text.cursor(0);
-        let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
-        ranges.into_iter().map(move |offset| {
-            cursor.seek_forward(&VersionedFullOffset::Offset(*offset), bias, &cx);
-            let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
-                *offset - cursor.start().0.full_offset()
-            } else {
-                0
-            };
-            summary.add_assign(&rope_cursor.summary(cursor.start().1 + overshoot));
-            summary.clone()
-        })
-    }
-
-    fn summaries_for_anchor_ranges<'a, D, I>(
-        &'a self,
-        version: clock::Global,
-        start_bias: Bias,
-        end_bias: Bias,
-        ranges: I,
-    ) -> impl 'a + Iterator<Item = Range<D>>
-    where
-        D: 'a + TextDimension<'a>,
-        I: 'a + IntoIterator<Item = &'a Range<FullOffset>>,
-    {
-        let cx = Some(version);
-        let mut summary = D::default();
-        let mut rope_cursor = self.visible_text.cursor(0);
-        let mut cursor = self.fragments.cursor::<(VersionedFullOffset, usize)>();
-        ranges.into_iter().map(move |range| {
-            cursor.seek_forward(&VersionedFullOffset::Offset(range.start), start_bias, &cx);
-            let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
-                range.start - cursor.start().0.full_offset()
-            } else {
-                0
-            };
-            summary.add_assign(&rope_cursor.summary::<D>(cursor.start().1 + overshoot));
-            let start_summary = summary.clone();
-
-            cursor.seek_forward(&VersionedFullOffset::Offset(range.end), end_bias, &cx);
-            let overshoot = if cursor.item().map_or(false, |fragment| fragment.visible) {
-                range.end - cursor.start().0.full_offset()
-            } else {
-                0
-            };
-            summary.add_assign(&rope_cursor.summary::<D>(cursor.start().1 + overshoot));
-            let end_summary = summary.clone();
-
-            start_summary..end_summary
-        })
-    }
-
     pub fn anchor_before<T: ToOffset>(&self, position: T) -> Anchor {
         self.anchor_at(position, Bias::Left)
     }
@@ -1772,139 +1775,22 @@ impl Snapshot {
     }
 
     pub fn anchor_at<T: ToOffset>(&self, position: T, bias: Bias) -> Anchor {
-        Anchor {
-            full_offset: position.to_full_offset(self, bias),
-            bias,
-            version: self.version.clone(),
-        }
-    }
-
-    pub fn anchor_map<T, E>(&self, bias: Bias, entries: E) -> AnchorMap<T>
-    where
-        E: IntoIterator<Item = (usize, T)>,
-    {
-        let version = self.version.clone();
-        let mut cursor = self.fragments.cursor::<FragmentTextSummary>();
-        let entries = entries
-            .into_iter()
-            .map(|(offset, value)| {
-                cursor.seek_forward(&offset, bias, &None);
-                let full_offset = FullOffset(cursor.start().deleted + offset);
-                (full_offset, value)
-            })
-            .collect();
-
-        AnchorMap {
-            version,
-            bias,
-            entries,
-        }
-    }
-
-    pub fn anchor_range_map<T, E>(
-        &self,
-        start_bias: Bias,
-        end_bias: Bias,
-        entries: E,
-    ) -> AnchorRangeMap<T>
-    where
-        E: IntoIterator<Item = (Range<usize>, T)>,
-    {
-        let version = self.version.clone();
-        let mut cursor = self.fragments.cursor::<FragmentTextSummary>();
-        let entries = entries
-            .into_iter()
-            .map(|(range, value)| {
-                let Range {
-                    start: start_offset,
-                    end: end_offset,
-                } = range;
-                cursor.seek_forward(&start_offset, start_bias, &None);
-                let full_start_offset = FullOffset(cursor.start().deleted + start_offset);
-                cursor.seek_forward(&end_offset, end_bias, &None);
-                let full_end_offset = FullOffset(cursor.start().deleted + end_offset);
-                (full_start_offset..full_end_offset, value)
-            })
-            .collect();
-
-        AnchorRangeMap {
-            version,
-            start_bias,
-            end_bias,
-            entries,
-        }
-    }
-
-    pub fn anchor_set<E>(&self, bias: Bias, entries: E) -> AnchorSet
-    where
-        E: IntoIterator<Item = usize>,
-    {
-        AnchorSet(self.anchor_map(bias, entries.into_iter().map(|range| (range, ()))))
-    }
-
-    pub fn anchor_range_set<E>(
-        &self,
-        start_bias: Bias,
-        end_bias: Bias,
-        entries: E,
-    ) -> AnchorRangeSet
-    where
-        E: IntoIterator<Item = Range<usize>>,
-    {
-        AnchorRangeSet(self.anchor_range_map(
-            start_bias,
-            end_bias,
-            entries.into_iter().map(|range| (range, ())),
-        ))
-    }
-
-    pub fn anchor_range_multimap<T, E, O>(
-        &self,
-        start_bias: Bias,
-        end_bias: Bias,
-        entries: E,
-    ) -> AnchorRangeMultimap<T>
-    where
-        T: Clone,
-        E: IntoIterator<Item = (Range<O>, T)>,
-        O: ToOffset,
-    {
-        let mut entries = entries
-            .into_iter()
-            .map(|(range, value)| AnchorRangeMultimapEntry {
-                range: FullOffsetRange {
-                    start: range.start.to_full_offset(self, start_bias),
-                    end: range.end.to_full_offset(self, end_bias),
-                },
-                value,
-            })
-            .collect::<Vec<_>>();
-        entries.sort_unstable_by_key(|i| (i.range.start, Reverse(i.range.end)));
-        AnchorRangeMultimap {
-            entries: SumTree::from_iter(entries, &()),
-            version: self.version.clone(),
-            start_bias,
-            end_bias,
-        }
-    }
-
-    fn full_offset_for_anchor(&self, anchor: &Anchor) -> FullOffset {
-        let cx = Some(anchor.version.clone());
-        let mut cursor = self
-            .fragments
-            .cursor::<(VersionedFullOffset, FragmentTextSummary)>();
-        cursor.seek(
-            &VersionedFullOffset::Offset(anchor.full_offset),
-            anchor.bias,
-            &cx,
-        );
-        let overshoot = if cursor.item().is_some() {
-            anchor.full_offset - cursor.start().0.full_offset()
+        let offset = position.to_offset(self);
+        if bias == Bias::Left && offset == 0 {
+            Anchor::Min
+        } else if bias == Bias::Right && offset == self.len() {
+            Anchor::Max
         } else {
-            0
-        };
-        let summary = cursor.start().1;
-        FullOffset(summary.visible + summary.deleted + overshoot)
+            let mut fragment_cursor = self.fragments.cursor::<(usize, Locator)>();
+            fragment_cursor.seek(&offset, bias, &None);
+            let fragment = fragment_cursor.item().unwrap();
+            let overshoot = offset - fragment_cursor.start().0;
+            Anchor::Insertion {
+                timestamp: fragment.insertion_timestamp.local(),
+                offset: fragment.insertion_offset + overshoot,
+                bias,
+            }
+        }
     }
 
     pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize {
@@ -2200,10 +2086,6 @@ impl sum_tree::Summary for InsertionFragmentKey {
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FullOffset(pub usize);
 
-impl FullOffset {
-    const MAX: Self = FullOffset(usize::MAX);
-}
-
 impl ops::AddAssign<usize> for FullOffset {
     fn add_assign(&mut self, rhs: usize) {
         self.0 += rhs;
@@ -2239,6 +2121,12 @@ impl<'a> sum_tree::Dimension<'a, FragmentSummary> for FullOffset {
     }
 }
 
+impl<'a> sum_tree::Dimension<'a, FragmentSummary> for Locator {
+    fn add_summary(&mut self, summary: &FragmentSummary, _: &Option<clock::Global>) {
+        *self = summary.max_id.clone();
+    }
+}
+
 impl<'a> sum_tree::SeekTarget<'a, FragmentSummary, FragmentTextSummary> for usize {
     fn cmp(
         &self,
@@ -2363,9 +2251,9 @@ impl ToOffset for Anchor {
     }
 }
 
-impl<'a> ToOffset for &'a Anchor {
+impl<'a, T: ToOffset> ToOffset for &'a T {
     fn to_offset(&self, content: &Snapshot) -> usize {
-        content.summary_for_anchor(self)
+        (*self).to_offset(content)
     }
 }