use crate::{MultiBufferDimension, MultiBufferOffset, MultiBufferOffsetUtf16}; use super::{ExcerptId, MultiBufferSnapshot, ToOffset, ToPoint};use language::Point;use std::{    cmp::Ordering,    ops::{AddAssign, Range, Sub},};use sum_tree::Bias; #[derive(Clone, Copy, Eq, PartialEq, Hash)]pub struct Anchor {    pub excerpt_id: ExcerptId,    pub text_anchor: text::Anchor,    pub diff_base_anchor: Option<text::Anchor>,} impl std::fmt::Debug for Anchor {    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {        if self.is_min() {            return write!(f, "Anchor::min({:?})", self.text_anchor.buffer_id);        }        if self.is_max() {            return write!(f, "Anchor::max({:?})", self.text_anchor.buffer_id);        }         f.debug_struct("Anchor")            .field("excerpt_id", &self.excerpt_id)            .field("text_anchor", &self.text_anchor)            .field("diff_base_anchor", &self.diff_base_anchor)            .finish()    }} impl Anchor {    pub fn with_diff_base_anchor(self, diff_base_anchor: text::Anchor) -> Self {        Self {            diff_base_anchor: Some(diff_base_anchor),            ..self        }    }     pub fn in_buffer(excerpt_id: ExcerptId, text_anchor: text::Anchor) -> Self {        Self {            excerpt_id,            text_anchor,            diff_base_anchor: None,        }    }     pub fn range_in_buffer(excerpt_id: ExcerptId, range: Range<text::Anchor>) -> Range<Self> {        Self::in_buffer(excerpt_id, range.start)..Self::in_buffer(excerpt_id, range.end)    }     pub fn min() -> Self {        Self {            excerpt_id: ExcerptId::min(),            text_anchor: text::Anchor::MIN,            diff_base_anchor: None,        }    }     pub fn max() -> Self {        Self {            excerpt_id: ExcerptId::max(),            text_anchor: text::Anchor::MAX,            diff_base_anchor: None,        }    }     pub fn is_min(&self) -> bool {        self.excerpt_id == ExcerptId::min()            && self.text_anchor.is_min()            && self.diff_base_anchor.is_none()    }     pub fn is_max(&self) -> bool {        self.excerpt_id == ExcerptId::max()            && self.text_anchor.is_max()            && self.diff_base_anchor.is_none()    }     pub fn cmp(&self, other: &Anchor, snapshot: &MultiBufferSnapshot) -> Ordering {        if self == other {            return Ordering::Equal;        }         let self_excerpt_id = snapshot.latest_excerpt_id(self.excerpt_id);        let other_excerpt_id = snapshot.latest_excerpt_id(other.excerpt_id);         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::max()            && self.text_anchor.is_max()            && self.text_anchor.is_max()            && self.diff_base_anchor.is_none()            && other.diff_base_anchor.is_none()        {            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())                && 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            && let Some(excerpt) = snapshot.excerpt(self.excerpt_id)        {            return Self {                excerpt_id: 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())                        && 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            && let Some(excerpt) = snapshot.excerpt(self.excerpt_id)        {            return Self {                excerpt_id: 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())                        && 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: MultiBufferDimension            + Ord            + Sub<Output = D::TextDimension>            + AddAssign<D::TextDimension>,        D::TextDimension: Sub<Output = D::TextDimension> + Ord,    {        snapshot.summary_for_anchor(self)    }     pub fn is_valid(&self, snapshot: &MultiBufferSnapshot) -> bool {        if self.is_min() || self.is_max() {            true        } else if let Some(excerpt) = snapshot.excerpt(self.excerpt_id) {            (self.text_anchor == excerpt.range.context.start                || self.text_anchor == excerpt.range.context.end                || self.text_anchor.is_valid(&excerpt.buffer))                && excerpt.contains(self)        } else {            false        }    }} impl ToOffset for Anchor {    fn to_offset(&self, snapshot: &MultiBufferSnapshot) -> MultiBufferOffset {        self.summary(snapshot)    }    fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> MultiBufferOffsetUtf16 {        self.summary(snapshot)    }} impl ToPoint for Anchor {    fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {        self.summary(snapshot)    }    fn to_point_utf16(&self, snapshot: &MultiBufferSnapshot) -> rope::PointUtf16 {        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<MultiBufferOffset>;    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<MultiBufferOffset> {        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)    }}