Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Start fixing compilation errors on Editor

Browse source 
Co-Authored-By: Max Brunsfeld <max@zed.dev>
This commit is contained in:
Antonio Scandurra 2021-10-28 19:36:43 +02:00
parent 1a92a19954
commit 9c74be3bf2
4 changed files with 117 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

32
crates/buffer/src/anchor.rs
View file

@ -87,6 +87,16 @@ impl Anchor {
} }
impl<T> AnchorMap<T> { impl<T> AnchorMap<T> {
pub fn offsets<'a>(
&'a self,
content: impl Into<Content<'a>> + 'a,
) -> impl Iterator<Item = (usize, &'a T)> + 'a {
let content = content.into();
content
.summaries_for_anchors(self)
.map(move |(sum, value)| (sum.bytes, value))
}
pub fn points<'a>( pub fn points<'a>(
&'a self, &'a self,
content: impl Into<Content<'a>> + 'a, content: impl Into<Content<'a>> + 'a,
@ -103,6 +113,13 @@ impl<T> AnchorMap<T> {
} }
impl AnchorSet { impl AnchorSet {
pub fn offsets<'a>(
&'a self,
content: impl Into<Content<'a>> + 'a,
) -> impl Iterator<Item = usize> + 'a {
self.0.offsets(content).map(move |(offset, _)| offset)
}
pub fn points<'a>( pub fn points<'a>(
&'a self, &'a self,
content: impl Into<Content<'a>> + 'a, content: impl Into<Content<'a>> + 'a,
@ -120,6 +137,10 @@ impl<T> AnchorRangeMap<T> {
&self.entries &self.entries
} }
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn point_ranges<'a>( pub fn point_ranges<'a>(
&'a self, &'a self,
content: impl Into<Content<'a>> + 'a, content: impl Into<Content<'a>> + 'a,
@ -165,6 +186,17 @@ impl<T: Debug> Debug for AnchorRangeMap<T> {
} }
impl AnchorRangeSet { impl AnchorRangeSet {
pub fn len(&self) -> usize {
self.0.len()
}
pub fn to_offset_ranges<'a>(
&'a self,
content: impl Into<Content<'a>> + 'a,
) -> impl Iterator<Item = Range<usize>> + 'a {
self.0.offset_ranges(content).map(|(range, _)| range)
}
pub fn to_point_ranges<'a>( pub fn to_point_ranges<'a>(
&'a self, &'a self,
content: impl Into<Content<'a>> + 'a, content: impl Into<Content<'a>> + 'a,

46
crates/buffer/src/lib.rs
View file

@ -539,6 +539,13 @@ impl Buffer {
self.content().anchor_at(position, bias) self.content().anchor_at(position, bias)
} }
pub fn anchor_range_set<E>(&self, entries: E) -> AnchorRangeSet
where
E: IntoIterator<Item = Range<(usize, Bias)>>,
{
self.content().anchor_range_set(entries)
}
pub fn point_for_offset(&self, offset: usize) -> Result<Point> { pub fn point_for_offset(&self, offset: usize) -> Result<Point> {
self.content().point_for_offset(offset) self.content().point_for_offset(offset)
} }
@ -2264,19 +2271,6 @@ impl<'a> Into<proto::operation::Edit> for &'a EditOperation {
} }
} }
impl<'a> Into<proto::Anchor> for &'a Anchor {
fn into(self) -> proto::Anchor {
proto::Anchor {
version: (&self.version).into(),
offset: self.offset as u64,
bias: match self.bias {
Bias::Left => proto::anchor::Bias::Left as i32,
Bias::Right => proto::anchor::Bias::Right as i32,
},
}
}
}
impl TryFrom<proto::Operation> for Operation { impl TryFrom<proto::Operation> for Operation {
type Error = anyhow::Error; type Error = anyhow::Error;
@ -2397,32 +2391,6 @@ impl From<proto::operation::Edit> for EditOperation {
} }
} }
impl TryFrom<proto::Anchor> for Anchor {
type Error = anyhow::Error;
fn try_from(message: proto::Anchor) -> Result<Self, Self::Error> {
let mut version = clock::Global::new();
for entry in message.version {
version.observe(clock::Local {
replica_id: entry.replica_id as ReplicaId,
value: entry.timestamp,
});
}
Ok(Self {
offset: message.offset as usize,
bias: if message.bias == proto::anchor::Bias::Left as i32 {
Bias::Left
} else if message.bias == proto::anchor::Bias::Right as i32 {
Bias::Right
} else {
Err(anyhow!("invalid anchor bias {}", message.bias))?
},
version,
})
}
}
pub trait ToOffset { pub trait ToOffset {
fn to_offset<'a>(&self, content: impl Into<Content<'a>>) -> usize; fn to_offset<'a>(&self, content: impl Into<Content<'a>>) -> usize;
} }

4
crates/buffer/src/selection.rs
View file

@ -91,6 +91,10 @@ impl<T: ToOffset + ToPoint + Copy + Ord> Selection<T> {
} }
impl SelectionSet { impl SelectionSet {
pub fn len(&self) -> usize {
self.selections.len()
}
pub fn offset_selections<'a>( pub fn offset_selections<'a>(
&'a self, &'a self,
content: impl Into<Content<'a>> + 'a, content: impl Into<Content<'a>> + 'a,

149
crates/editor/src/lib.rs
View file

@ -293,11 +293,11 @@ pub struct Editor {
buffer: ModelHandle<Buffer>, buffer: ModelHandle<Buffer>,
display_map: ModelHandle<DisplayMap>, display_map: ModelHandle<DisplayMap>,
selection_set_id: SelectionSetId, selection_set_id: SelectionSetId,
pending_selection: Option<Selection>, pending_selection: Option<Selection<Point>>,
next_selection_id: usize, next_selection_id: usize,
add_selections_state: Option<AddSelectionsState>, add_selections_state: Option<AddSelectionsState>,
autoclose_stack: Vec<BracketPairState>, autoclose_stack: Vec<BracketPairState>,
select_larger_syntax_node_stack: Vec<Arc<[Selection]>>, select_larger_syntax_node_stack: Vec<Arc<[Selection<Point>]>>,
scroll_position: Vector2F, scroll_position: Vector2F,
scroll_top_anchor: Anchor, scroll_top_anchor: Anchor,
autoscroll_requested: bool, autoscroll_requested: bool,
@ -325,7 +325,7 @@ struct AddSelectionsState {
} }
struct BracketPairState { struct BracketPairState {
ranges: SmallVec<[Range<Anchor>; 32]>, ranges: AnchorRangeSet,
pair: BracketPair, pair: BracketPair,
} }
@ -396,10 +396,10 @@ impl Editor {
let mut next_selection_id = 0; let mut next_selection_id = 0;
let selection_set_id = buffer.update(cx, |buffer, cx| { let selection_set_id = buffer.update(cx, |buffer, cx| {
buffer.add_selection_set( buffer.add_selection_set(
vec![Selection { &[Selection {
id: post_inc(&mut next_selection_id), id: post_inc(&mut next_selection_id),
start: buffer.anchor_before(0), start: 0,
end: buffer.anchor_before(0), end: 0,
reversed: false, reversed: false,
goal: SelectionGoal::None, goal: SelectionGoal::None,
}], }],
@ -512,9 +512,9 @@ impl Editor {
return false; return false;
} }
let selections = self.selections(cx); let selections = self.point_selections(cx).peekable();
let first_cursor_top = selections let first_cursor_top = selections
.first() .peek()
.unwrap() .unwrap()
.head() .head()
.to_display_point(&display_map, Bias::Left) .to_display_point(&display_map, Bias::Left)
@ -563,11 +563,11 @@ impl Editor {
layouts: &[text_layout::Line], layouts: &[text_layout::Line],
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) -> bool { ) -> bool {
let selections = self.selections(cx);
let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx)); let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
let selections = self.point_selections(cx);
let mut target_left = std::f32::INFINITY; let mut target_left = std::f32::INFINITY;
let mut target_right = 0.0_f32; let mut target_right = 0.0_f32;
for selection in selections.iter() { for selection in selections {
let head = selection.head().to_display_point(&display_map, Bias::Left); let head = selection.head().to_display_point(&display_map, Bias::Left);
let start_column = head.column().saturating_sub(3); let start_column = head.column().saturating_sub(3);
let end_column = cmp::min(display_map.line_len(head.row()), head.column() + 3); let end_column = cmp::min(display_map.line_len(head.row()), head.column() + 3);
@ -617,17 +617,17 @@ impl Editor {
} }
let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx)); let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
let cursor = display_map.anchor_before(position, Bias::Left); let cursor = position.to_buffer_point(&display_map, Bias::Left);
let selection = Selection { let selection = Selection {
id: post_inc(&mut self.next_selection_id), id: post_inc(&mut self.next_selection_id),
start: cursor.clone(), start: cursor,
end: cursor, end: cursor,
reversed: false, reversed: false,
goal: SelectionGoal::None, goal: SelectionGoal::None,
}; };
if !add { if !add {
self.update_selections(Vec::new(), false, cx); self.update_selections::<usize>(Vec::new(), false, cx);
} }
self.pending_selection = Some(selection); self.pending_selection = Some(selection);
@ -642,9 +642,9 @@ impl Editor {
) { ) {
let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx)); let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
let buffer = self.buffer.read(cx); let buffer = self.buffer.read(cx);
let cursor = display_map.anchor_before(position, Bias::Left); let cursor = position.to_buffer_point(&display_map, Bias::Left);
if let Some(selection) = self.pending_selection.as_mut() { if let Some(selection) = self.pending_selection.as_mut() {
selection.set_head(buffer, cursor); selection.set_head(cursor);
} else { } else {
log::error!("update_selection dispatched with no pending selection"); log::error!("update_selection dispatched with no pending selection");
return; return;
@ -656,8 +656,8 @@ impl Editor {
fn end_selection(&mut self, cx: &mut ViewContext<Self>) { fn end_selection(&mut self, cx: &mut ViewContext<Self>) {
if let Some(selection) = self.pending_selection.take() { if let Some(selection) = self.pending_selection.take() {
let mut selections = self.selections(cx).to_vec(); let mut selections = self.point_selections(cx).collect::<Vec<_>>();
let ix = self.selection_insertion_index(&selections, &selection.start, cx.as_ref()); let ix = self.selection_insertion_index(&selections, selection.start, cx.as_ref());
selections.insert(ix, selection); selections.insert(ix, selection);
self.update_selections(selections, false, cx); self.update_selections(selections, false, cx);
} }
@ -669,14 +669,14 @@ impl Editor {
pub fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) { pub fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
if let Some(pending_selection) = self.pending_selection.take() { if let Some(pending_selection) = self.pending_selection.take() {
let selections = self.selections(cx); if self.point_selections(cx).next().is_none() {
if selections.is_empty() {
self.update_selections(vec![pending_selection], true, cx); self.update_selections(vec![pending_selection], true, cx);
} }
} else { } else {
let selections = self.selections(cx); let selection_count = self.selection_count(cx);
let mut oldest_selection = selections.iter().min_by_key(|s| s.id).unwrap().clone(); let selections = self.point_selections(cx);
if selections.len() == 1 { let mut oldest_selection = selections.min_by_key(|s| s.id).unwrap().clone();
if selection_count == 1 {
oldest_selection.start = oldest_selection.head().clone(); oldest_selection.start = oldest_selection.head().clone();
oldest_selection.end = oldest_selection.head().clone(); oldest_selection.end = oldest_selection.head().clone();
} }
@ -758,10 +758,10 @@ impl Editor {
self.start_transaction(cx); self.start_transaction(cx);
let mut old_selections = SmallVec::<[_; 32]>::new(); let mut old_selections = SmallVec::<[_; 32]>::new();
{ {
let selections = self.selections(cx); let selections = self.point_selections(cx).collect::<Vec<_>>();
let buffer = self.buffer.read(cx); let buffer = self.buffer.read(cx);
for selection in selections.iter() { for selection in selections.iter() {
let start_point = selection.start.to_point(buffer); let start_point = selection.start;
let indent = buffer let indent = buffer
.indent_column_for_line(start_point.row) .indent_column_for_line(start_point.row)
.min(start_point.column); .min(start_point.column);
@ -880,35 +880,25 @@ impl Editor {
fn insert(&mut self, text: &str, cx: &mut ViewContext<Self>) { fn insert(&mut self, text: &str, cx: &mut ViewContext<Self>) {
self.start_transaction(cx); self.start_transaction(cx);
let mut old_selections = SmallVec::<[_; 32]>::new(); let old_selections = self.offset_selections(cx).collect::<SmallVec<[_; 32]>>();
{
let selections = self.selections(cx);
let buffer = self.buffer.read(cx);
for selection in selections.iter() {
let start = selection.start.to_offset(buffer);
let end = selection.end.to_offset(buffer);
old_selections.push((selection.id, start..end));
}
}
let mut new_selections = Vec::new(); let mut new_selections = Vec::new();
self.buffer.update(cx, |buffer, cx| { self.buffer.update(cx, |buffer, cx| {
let edit_ranges = old_selections.iter().map(|(_, range)| range.clone()); let edit_ranges = old_selections.iter().map(|s| s.start..s.end);
buffer.edit_with_autoindent(edit_ranges, text, cx); buffer.edit_with_autoindent(edit_ranges, text, cx);
let text_len = text.len() as isize; let text_len = text.len() as isize;
let mut delta = 0_isize; let mut delta = 0_isize;
new_selections = old_selections new_selections = old_selections
.into_iter() .into_iter()
.map(|(id, range)| { .map(|selection| {
let start = range.start as isize; let start = selection.start as isize;
let end = range.end as isize; let end = selection.end as isize;
let anchor = buffer.anchor_before((start + delta + text_len) as usize); let cursor = (start + delta + text_len) as usize;
let deleted_count = end - start; let deleted_count = end - start;
delta += text_len - deleted_count; delta += text_len - deleted_count;
Selection { Selection {
id, id: selection.id,
start: anchor.clone(), start: cursor,
end: anchor, end: cursor,
reversed: false, reversed: false,
goal: SelectionGoal::None, goal: SelectionGoal::None,
} }
@ -921,10 +911,10 @@ impl Editor {
} }
fn autoclose_pairs(&mut self, cx: &mut ViewContext<Self>) { fn autoclose_pairs(&mut self, cx: &mut ViewContext<Self>) {
let selections = self.selections(cx); let selections = self.offset_selections(cx).collect::<Vec<_>>();
let new_autoclose_pair_state = self.buffer.update(cx, |buffer, cx| { let new_autoclose_pair_state = self.buffer.update(cx, |buffer, cx| {
let autoclose_pair = buffer.language().and_then(|language| { let autoclose_pair = buffer.language().and_then(|language| {
let first_selection_start = selections.first().unwrap().start.to_offset(&*buffer); let first_selection_start = selections.first().unwrap().start;
let pair = language.brackets().iter().find(|pair| { let pair = language.brackets().iter().find(|pair| {
buffer.contains_str_at( buffer.contains_str_at(
first_selection_start.saturating_sub(pair.start.len()), first_selection_start.saturating_sub(pair.start.len()),
@ -933,9 +923,8 @@ impl Editor {
}); });
pair.and_then(|pair| { pair.and_then(|pair| {
let should_autoclose = selections[1..].iter().all(|selection| { let should_autoclose = selections[1..].iter().all(|selection| {
let selection_start = selection.start.to_offset(&*buffer);
buffer.contains_str_at( buffer.contains_str_at(
selection_start.saturating_sub(pair.start.len()), selection.start.saturating_sub(pair.start.len()),
&pair.start, &pair.start,
) )
}); });
@ -961,13 +950,9 @@ impl Editor {
if pair.end.len() == 1 { if pair.end.len() == 1 {
Some(BracketPairState { Some(BracketPairState {
ranges: selections ranges: buffer.anchor_range_set(selections.iter().map(|selection| {
.iter() (selection.start, Bias::Left)..(selection.start, Bias::Right)
.map(|selection| { })),
selection.start.bias_left(buffer)
..selection.start.bias_right(buffer)
})
.collect(),
pair, pair,
}) })
} else { } else {
@ -979,7 +964,8 @@ impl Editor {
} }
fn skip_autoclose_end(&mut self, text: &str, cx: &mut ViewContext<Self>) -> bool { fn skip_autoclose_end(&mut self, text: &str, cx: &mut ViewContext<Self>) -> bool {
let old_selections = self.selections(cx); let old_selection_count = self.selection_count(cx);
let old_selections = self.offset_selections(cx);
let autoclose_pair_state = if let Some(autoclose_pair_state) = self.autoclose_stack.last() { let autoclose_pair_state = if let Some(autoclose_pair_state) = self.autoclose_stack.last() {
autoclose_pair_state autoclose_pair_state
} else { } else {
@ -989,16 +975,11 @@ impl Editor {
return false; return false;
} }
debug_assert_eq!(old_selections.len(), autoclose_pair_state.ranges.len()); debug_assert_eq!(old_selection_count, autoclose_pair_state.ranges.len());
let buffer = self.buffer.read(cx); let buffer = self.buffer.read(cx);
let old_selection_ranges: SmallVec<[_; 32]> = old_selections if old_selections
.iter() .zip(&autoclose_pair_state.ranges.to_offset_ranges(buffer))
.map(|selection| (selection.id, selection.offset_range(buffer)))
.collect();
if old_selection_ranges
.iter()
.zip(&autoclose_pair_state.ranges)
.all(|((_, selection_range), autoclose_range)| { .all(|((_, selection_range), autoclose_range)| {
let autoclose_range_end = autoclose_range.end.to_offset(buffer); let autoclose_range_end = autoclose_range.end.to_offset(buffer);
selection_range.is_empty() && selection_range.start == autoclose_range_end selection_range.is_empty() && selection_range.start == autoclose_range_end
@ -2273,7 +2254,7 @@ impl Editor {
row: u32, row: u32,
columns: &Range<u32>, columns: &Range<u32>,
reversed: bool, reversed: bool,
) -> Option<Selection> { ) -> Option<Selection<Point>> {
let is_empty = columns.start == columns.end; let is_empty = columns.start == columns.end;
let line_len = display_map.line_len(row); let line_len = display_map.line_len(row);
if columns.start < line_len || (is_empty && columns.start == line_len) { if columns.start < line_len || (is_empty && columns.start == line_len) {
@ -2340,17 +2321,15 @@ impl Editor {
fn selection_insertion_index( fn selection_insertion_index(
&self, &self,
selections: &[Selection], selections: &[Selection<Point>],
start: &Anchor, start: Point,
cx: &AppContext, cx: &AppContext,
) -> usize { ) -> usize {
let buffer = self.buffer.read(cx); let buffer = self.buffer.read(cx);
match selections.binary_search_by(|probe| probe.start.cmp(&start, buffer).unwrap()) { match selections.binary_search_by_key(&start, |probe| probe.start) {
Ok(index) => index, Ok(index) => index,
Err(index) => { Err(index) => {
if index > 0 if index > 0 && selections[index - 1].end > start {
&& selections[index - 1].end.cmp(&start, buffer).unwrap() == Ordering::Greater
{
index - 1 index - 1
} else { } else {
index index
@ -2359,19 +2338,39 @@ impl Editor {
} }
} }
fn selections(&mut self, cx: &mut ViewContext<Self>) -> Arc<[Selection]> { fn point_selections<'a>(
&mut self,
cx: &'a mut ViewContext<Self>,
) -> impl 'a + Iterator<Item = Selection<Point>> {
self.end_selection(cx); self.end_selection(cx);
let buffer = self.buffer.read(cx); let buffer = self.buffer.read(cx);
buffer buffer
.selection_set(self.selection_set_id) .selection_set(self.selection_set_id)
.unwrap() .unwrap()
.selections .point_selections(buffer)
.clone()
} }
fn update_selections( fn offset_selections<'a>(
&mut self, &mut self,
mut selections: Vec<Selection>, cx: &'a mut ViewContext<Self>,
) -> impl 'a + Iterator<Item = Selection<usize>> {
self.end_selection(cx);
let buffer = self.buffer.read(cx);
buffer
.selection_set(self.selection_set_id)
.unwrap()
.offset_selections(buffer)
}
fn selection_count(&mut self, cx: &mut ViewContext<Self>) -> usize {
self.end_selection(cx);
let buffer = self.buffer.read(cx);
buffer.selection_set(self.selection_set_id).unwrap().len()
}
fn update_selections<T: ToOffset>(
&mut self,
mut selections: Vec<Selection<T>>,
autoscroll: bool, autoscroll: bool,
cx: &mut ViewContext<Self>, cx: &mut ViewContext<Self>,
) { ) {