Don't use an enum for anchors and model min/max more implicitly

This will make it easier to serialize an anchor.

crates/clock/src/clock.rs

@@ -21,6 +21,15 @@ pub struct Lamport {
 }
 
 impl Local {
+    pub const MIN: Self = Self {
+        replica_id: ReplicaId::MIN,
+        value: Seq::MIN,
+    };
+    pub const MAX: Self = Self {
+        replica_id: ReplicaId::MAX,
+        value: Seq::MAX,
+    };
+
     pub fn new(replica_id: ReplicaId) -> Self {
         Self {
             replica_id,

crates/text/src/anchor.rs

@@ -1,90 +1,59 @@
-use crate::{rope::TextDimension, Snapshot};
+use super::{rope::TextDimension, Buffer, Point, Snapshot, ToOffset};
-
-use super::{Buffer, ToOffset};
 use anyhow::Result;
 use std::{cmp::Ordering, fmt::Debug, ops::Range};
 use sum_tree::Bias;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
-pub enum Anchor {
+pub struct Anchor {
-    Min,
+    pub timestamp: clock::Local,
-    Insertion {
+    pub offset: usize,
-        timestamp: clock::Local,
+    pub bias: Bias,
-        offset: usize,
-        bias: Bias,
-    },
-    Max,
 }
 
 impl Anchor {
     pub fn min() -> Self {
-        Self::Min
+        Self {
+            timestamp: clock::Local::MIN,
+            offset: usize::MIN,
+            bias: Bias::Left,
+        }
     }
 
     pub fn max() -> Self {
-        Self::Max
+        Self {
+            timestamp: clock::Local::MAX,
+            offset: usize::MAX,
+            bias: Bias::Right,
+        }
     }
 
     pub fn cmp<'a>(&self, other: &Anchor, buffer: &Snapshot) -> Result<Ordering> {
-        match (self, other) {
+        let offset_comparison = if self.timestamp == other.timestamp {
-            (Self::Min, Self::Min) => Ok(Ordering::Equal),
+            self.offset.cmp(&other.offset)
-            (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)))
+        Ok(offset_comparison.then_with(|| self.bias.cmp(&other.bias)))
-            }
-        }
     }
 
     pub fn bias_left(&self, buffer: &Buffer) -> Anchor {
-        match self {
+        if self.bias == Bias::Left {
-            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 {
-        match self {
+        if self.bias == Bias::Right {
-            Anchor::Min => buffer.anchor_after(self),
-            Anchor::Insertion { bias, .. } => {
-                if *bias == Bias::Right {
             self.clone()
         } else {
             buffer.anchor_after(self)
         }
     }
-            Anchor::Max => Anchor::Max,
-        }
-    }
 
     pub fn summary<'a, D>(&self, content: &'a Snapshot) -> D
     where
@@ -97,6 +66,7 @@ impl Anchor {
 pub trait AnchorRangeExt {
     fn cmp(&self, b: &Range<Anchor>, buffer: &Snapshot) -> Result<Ordering>;
     fn to_offset(&self, content: &Snapshot) -> Range<usize>;
+    fn to_point(&self, content: &Snapshot) -> Range<Point>;
 }
 
 impl AnchorRangeExt for Range<Anchor> {
@@ -110,4 +80,8 @@ impl AnchorRangeExt for Range<Anchor> {
     fn to_offset(&self, content: &Snapshot) -> Range<usize> {
         self.start.to_offset(&content)..self.end.to_offset(&content)
     }
+
+    fn to_point(&self, content: &Snapshot) -> Range<Point> {
+        self.start.summary::<Point>(&content)..self.end.summary::<Point>(&content)
+    }
 }

crates/text/src/text.rs

@@ -1136,11 +1136,9 @@ impl Buffer {
     }
 
     fn can_resolve(&self, anchor: &Anchor) -> bool {
-        match anchor {
+        *anchor == Anchor::min()
-            Anchor::Min => true,
+            || *anchor == Anchor::max()
-            Anchor::Insertion { timestamp, .. } => self.version.observed(*timestamp),
+            || self.version.observed(anchor.timestamp)
-            Anchor::Max => true,
-        }
     }
 
     pub fn peek_undo_stack(&self) -> Option<&Transaction> {
@@ -1680,23 +1678,23 @@ impl Snapshot {
     where
         D: TextDimension<'a>,
     {
-        match anchor {
+        if *anchor == Anchor::min() {
-            Anchor::Min => D::default(),
+            D::default()
-            Anchor::Insertion {
+        } else if *anchor == Anchor::max() {
-                timestamp,
+            D::from_text_summary(&self.visible_text.summary())
-                offset,
+        } else {
-                bias,
-            } => {
             let anchor_key = InsertionFragmentKey {
-                    timestamp: *timestamp,
+                timestamp: anchor.timestamp,
-                    split_offset: *offset,
+                split_offset: anchor.offset,
             };
             let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
-                insertion_cursor.seek(&anchor_key, *bias, &());
+            insertion_cursor.seek(&anchor_key, anchor.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)
+                    || (anchor.bias == Bias::Left
+                        && comparison == Ordering::Equal
+                        && anchor.offset > 0)
                 {
                     insertion_cursor.prev(&());
                 }
@@ -1704,39 +1702,38 @@ impl Snapshot {
                 insertion_cursor.prev(&());
             }
             let insertion = insertion_cursor.item().expect("invalid insertion");
-                debug_assert_eq!(insertion.timestamp, *timestamp, "invalid insertion");
+            debug_assert_eq!(insertion.timestamp, anchor.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;
+                fragment_offset += anchor.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 {
+        if *anchor == Anchor::min() {
-            Anchor::Min => Default::default(),
+            Default::default()
-            Anchor::Insertion {
+        } else if *anchor == Anchor::max() {
-                timestamp,
+            let text = self.fragments.summary().text;
-                offset,
+            FullOffset(text.visible + text.deleted)
-                bias,
+        } else {
-            } => {
             let anchor_key = InsertionFragmentKey {
-                    timestamp: *timestamp,
+                timestamp: anchor.timestamp,
-                    split_offset: *offset,
+                split_offset: anchor.offset,
             };
             let mut insertion_cursor = self.insertions.cursor::<InsertionFragmentKey>();
-                insertion_cursor.seek(&anchor_key, *bias, &());
+            insertion_cursor.seek(&anchor_key, anchor.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)
+                    || (anchor.bias == Bias::Left
+                        && comparison == Ordering::Equal
+                        && anchor.offset > 0)
                 {
                     insertion_cursor.prev(&());
                 }
@@ -1744,16 +1741,11 @@ impl Snapshot {
                 insertion_cursor.prev(&());
             }
             let insertion = insertion_cursor.item().expect("invalid insertion");
-                debug_assert_eq!(insertion.timestamp, *timestamp, "invalid insertion");
+            debug_assert_eq!(insertion.timestamp, anchor.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)
+            fragment_cursor.start().1 + (anchor.offset - insertion.split_offset)
-            }
-            Anchor::Max => {
-                let text = self.fragments.summary().text;
-                FullOffset(text.visible + text.deleted)
-            }
         }
     }
 
@@ -1777,15 +1769,15 @@ impl Snapshot {
     pub fn anchor_at<T: ToOffset>(&self, position: T, bias: Bias) -> Anchor {
         let offset = position.to_offset(self);
         if bias == Bias::Left && offset == 0 {
-            Anchor::Min
+            Anchor::min()
         } else if bias == Bias::Right && offset == self.len() {
-            Anchor::Max
+            Anchor::max()
         } else {
             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 {
+            Anchor {
                 timestamp: fragment.insertion_timestamp.local(),
                 offset: fragment.insertion_offset + overshoot,
                 bias,