use super::{ExcerptId, MultiBufferSnapshot, ToOffset, ToOffsetUtf16, ToPoint};use language::{OffsetUtf16, Point, TextDimension};use std::{    cmp::Ordering,    ops::{Range, Sub},};use sum_tree::Bias;use text::BufferId; #[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]pub struct Anchor {    pub buffer_id: Option<BufferId>,    pub excerpt_id: ExcerptId,    pub text_anchor: text::Anchor,    pub diff_base_anchor: Option<text::Anchor>,} impl Anchor {    pub fn in_buffer(        excerpt_id: ExcerptId,        buffer_id: BufferId,        text_anchor: text::Anchor,    ) -> Self {        Self {            buffer_id: Some(buffer_id),            excerpt_id,            text_anchor,            diff_base_anchor: None,        }    }     pub fn range_in_buffer(        excerpt_id: ExcerptId,        buffer_id: BufferId,        range: Range<text::Anchor>,    ) -> Range<Self> {        Self::in_buffer(excerpt_id, buffer_id, range.start)            ..Self::in_buffer(excerpt_id, buffer_id, range.end)    }     pub fn min() -> Self {        Self {            buffer_id: None,            excerpt_id: ExcerptId::min(),            text_anchor: text::Anchor::MIN,            diff_base_anchor: None,        }    }     pub fn max() -> Self {        Self {            buffer_id: None,            excerpt_id: ExcerptId::max(),            text_anchor: text::Anchor::MAX,            diff_base_anchor: None,        }    }     pub fn cmp(&self, other: &Anchor, snapshot: &MultiBufferSnapshot) -> Ordering {        let excerpt_id_cmp = self.excerpt_id.cmp(&other.excerpt_id, snapshot);        if excerpt_id_cmp.is_ne() {            return excerpt_id_cmp;        }        if self.excerpt_id == ExcerptId::min() || self.excerpt_id == ExcerptId::max() {            return Ordering::Equal;        }        if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {            let text_cmp = self.text_anchor.cmp(&other.text_anchor, &excerpt.buffer);            if text_cmp.is_ne() {                return text_cmp;            }            if self.diff_base_anchor.is_some() || other.diff_base_anchor.is_some() {                if let Some(base_text) = snapshot                    .diffs                    .get(&excerpt.buffer_id)                    .map(|diff| diff.base_text())                {                    let self_anchor = self.diff_base_anchor.filter(|a| base_text.can_resolve(a));                    let other_anchor = other.diff_base_anchor.filter(|a| base_text.can_resolve(a));                    return match (self_anchor, other_anchor) {                        (Some(a), Some(b)) => a.cmp(&b, base_text),                        (Some(_), None) => match other.text_anchor.bias {                            Bias::Left => Ordering::Greater,                            Bias::Right => Ordering::Less,                        },                        (None, Some(_)) => match self.text_anchor.bias {                            Bias::Left => Ordering::Less,                            Bias::Right => Ordering::Greater,                        },                        (None, None) => Ordering::Equal,                    };                }            }        }        Ordering::Equal    }     pub fn bias(&self) -> Bias {        self.text_anchor.bias    }     pub fn bias_left(&self, snapshot: &MultiBufferSnapshot) -> Anchor {        if self.text_anchor.bias != Bias::Left {            if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {                return Self {                    buffer_id: self.buffer_id,                    excerpt_id: self.excerpt_id,                    text_anchor: self.text_anchor.bias_left(&excerpt.buffer),                    diff_base_anchor: self.diff_base_anchor.map(|a| {                        if let Some(base_text) = snapshot                            .diffs                            .get(&excerpt.buffer_id)                            .map(|diff| diff.base_text())                        {                            if a.buffer_id == Some(base_text.remote_id()) {                                return a.bias_left(base_text);                            }                        }                        a                    }),                };            }        }        *self    }     pub fn bias_right(&self, snapshot: &MultiBufferSnapshot) -> Anchor {        if self.text_anchor.bias != Bias::Right {            if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {                return Self {                    buffer_id: self.buffer_id,                    excerpt_id: self.excerpt_id,                    text_anchor: self.text_anchor.bias_right(&excerpt.buffer),                    diff_base_anchor: self.diff_base_anchor.map(|a| {                        if let Some(base_text) = snapshot                            .diffs                            .get(&excerpt.buffer_id)                            .map(|diff| diff.base_text())                        {                            if a.buffer_id == Some(base_text.remote_id()) {                                return a.bias_right(&base_text);                            }                        }                        a                    }),                };            }        }        *self    }     pub fn summary<D>(&self, snapshot: &MultiBufferSnapshot) -> D    where        D: TextDimension + Ord + Sub<D, Output = D>,    {        snapshot.summary_for_anchor(self)    }     pub fn is_valid(&self, snapshot: &MultiBufferSnapshot) -> bool {        if *self == Anchor::min() || *self == Anchor::max() {            true        } else if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {            excerpt.contains(self)                && (self.text_anchor == excerpt.range.context.start                    || self.text_anchor == excerpt.range.context.end                    || self.text_anchor.is_valid(&excerpt.buffer))        } else {            false        }    }} impl ToOffset for Anchor {    fn to_offset(&self, snapshot: &MultiBufferSnapshot) -> usize {        self.summary(snapshot)    }} impl ToOffsetUtf16 for Anchor {    fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {        self.summary(snapshot)    }} impl ToPoint for Anchor {    fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {        self.summary(snapshot)    }} pub trait AnchorRangeExt {    fn cmp(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> Ordering;    fn includes(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> bool;    fn overlaps(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> bool;    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) -> Ordering {        match self.start.cmp(&other.start, buffer) {            Ordering::Equal => other.end.cmp(&self.end, buffer),            ord => ord,        }    }     fn includes(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> bool {        self.start.cmp(&other.start, &buffer).is_le() && other.end.cmp(&self.end, &buffer).is_le()    }     fn overlaps(&self, other: &Range<Anchor>, buffer: &MultiBufferSnapshot) -> bool {        self.end.cmp(&other.start, buffer).is_ge() && self.start.cmp(&other.end, buffer).is_le()    }     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)    }} #[derive(Clone, Copy, Eq, PartialEq, Debug, Hash, Ord, PartialOrd)]pub struct Offset(pub usize);