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

Merge branch 'fragment-locators' into HEAD

Browse source
This commit is contained in:
Max Brunsfeld 2021-12-09 14:49:04 -08:00
commit 5e516f59c0
22 changed files with 1317 additions and 1280 deletions
Download patch file Download diff file Expand all files Collapse all files

88
crates/editor/src/editor.rs
View file

@ -407,7 +407,7 @@ struct SelectNextState {
#[derive(Debug)]
struct BracketPairState {
ranges: AnchorRangeSet,
ranges: Vec<Range<Anchor>>,
pair: BracketPair,
}
@ -1292,10 +1292,9 @@ impl Editor {
}
fn autoclose_pairs(&mut self, cx: &mut ViewContext<Self>) {
let selections = self.selections::<usize>(cx);
let new_autoclose_pair_state = self.buffer.update(cx, |buffer, cx| {
let buffer_snapshot = buffer.snapshot(cx);
let autoclose_pair = buffer_snapshot.language().and_then(|language| {
let selections = self.selections::<usize>(cx).collect::<Vec<_>>();
let new_autoclose_pair = self.buffer.update(cx, |buffer, cx| {
let autoclose_pair = buffer.language().and_then(|language| {
let first_selection_start = selections.first().unwrap().start;
let pair = language.brackets().iter().find(|pair| {
buffer_snapshot.contains_str_at(
@ -1333,15 +1332,14 @@ impl Editor {
if pair.end.len() == 1 {
let mut delta = 0;
Some(BracketPairState {
ranges: buffer.anchor_range_set(
Bias::Left,
Bias::Right,
selections.iter().map(move |selection| {
ranges: selections
.iter()
.map(move |selection| {
let offset = selection.start + delta;
delta += 1;
offset..offset
}),
),
buffer.anchor_before(offset)..buffer.anchor_after(offset)
})
.collect(),
pair,
})
} else {
@ -1349,26 +1347,26 @@ impl Editor {
}
})
});
self.autoclose_stack.extend(new_autoclose_pair_state);
self.autoclose_stack.extend(new_autoclose_pair);
}
fn skip_autoclose_end(&mut self, text: &str, cx: &mut ViewContext<Self>) -> bool {
let old_selections = self.selections::<usize>(cx);
let autoclose_pair_state = if let Some(autoclose_pair_state) = self.autoclose_stack.last() {
autoclose_pair_state
let old_selections = self.selections::<usize>(cx).collect::<Vec<_>>();
let autoclose_pair = if let Some(autoclose_pair) = self.autoclose_stack.last() {
autoclose_pair
} else {
return false;
};
if text != autoclose_pair_state.pair.end {
if text != autoclose_pair.pair.end {
return false;
}
debug_assert_eq!(old_selections.len(), autoclose_pair_state.ranges.len());
debug_assert_eq!(old_selections.len(), autoclose_pair.ranges.len());
let buffer = self.buffer.read(cx).snapshot(cx);
if old_selections
.iter()
.zip(autoclose_pair_state.ranges.ranges::<usize>(&buffer))
.zip(autoclose_pair.ranges.iter().map(|r| r.to_offset(&buffer)))
.all(|(selection, autoclose_range)| {
let autoclose_range_end = autoclose_range.end.to_offset(&buffer);
selection.is_empty() && selection.start == autoclose_range_end
@ -2832,12 +2830,12 @@ impl Editor {
loop {
let next_group = buffer
.diagnostics_in_range::<_, usize>(search_start..buffer.len())
.find_map(|(range, diagnostic)| {
if diagnostic.is_primary
&& !range.is_empty()
&& Some(range.end) != active_primary_range.as_ref().map(|r| *r.end())
.find_map(|entry| {
if entry.diagnostic.is_primary
&& !entry.range.is_empty()
&& Some(entry.range.end) != active_primary_range.as_ref().map(|r| *r.end())
{
Some((range, diagnostic.group_id))
Some((entry.range, entry.diagnostic.group_id))
} else {
None
}
@ -2872,11 +2870,11 @@ impl Editor {
let primary_range_start = active_diagnostics.primary_range.start.to_offset(&buffer);
let is_valid = buffer
.diagnostics_in_range::<_, usize>(active_diagnostics.primary_range.clone())
.any(|(range, diagnostic)| {
diagnostic.is_primary
&& !range.is_empty()
&& range.start == primary_range_start
&& diagnostic.message == active_diagnostics.primary_message
.any(|entry| {
entry.diagnostic.is_primary
&& !entry.range.is_empty()
&& entry.range.start == primary_range_start
&& entry.diagnostic.message == active_diagnostics.primary_message
});
if is_valid != active_diagnostics.is_valid {
@ -2907,15 +2905,15 @@ impl Editor {
let mut group_end = Point::zero();
let diagnostic_group = buffer
.diagnostic_group::<Point>(group_id)
.map(|(range, diagnostic)| {
if range.end > group_end {
group_end = range.end;
.map(|entry| {
if entry.range.end > group_end {
group_end = entry.range.end;
}
if diagnostic.is_primary {
primary_range = Some(range.clone());
primary_message = Some(diagnostic.message.clone());
if entry.diagnostic.is_primary {
primary_range = Some(entry.range.clone());
primary_message = Some(entry.diagnostic.message.clone());
}
(range, diagnostic.clone())
entry
})
.collect::<Vec<_>>();
let primary_range = primary_range.unwrap();
@ -2925,13 +2923,13 @@ impl Editor {
let blocks = display_map
.insert_blocks(
diagnostic_group.iter().map(|(range, diagnostic)| {
diagnostic_group.iter().map(|entry| {
let build_settings = self.build_settings.clone();
let diagnostic = diagnostic.clone();
let diagnostic = entry.diagnostic.clone();
let message_height = diagnostic.message.lines().count() as u8;
BlockProperties {
position: range.start,
position: entry.range.start,
height: message_height,
render: Arc::new(move |cx| {
let settings = build_settings.borrow()(cx.cx);
@ -2944,11 +2942,7 @@ impl Editor {
cx,
)
.into_iter()
.zip(
diagnostic_group
.into_iter()
.map(|(_, diagnostic)| diagnostic),
)
.zip(diagnostic_group.into_iter().map(|entry| entry.diagnostic))
.collect();
Some(ActiveDiagnosticGroup {
@ -3171,12 +3165,12 @@ impl Editor {
self.add_selections_state = None;
self.select_next_state = None;
self.select_larger_syntax_node_stack.clear();
while let Some(autoclose_pair_state) = self.autoclose_stack.last() {
while let Some(autoclose_pair) = self.autoclose_stack.last() {
let all_selections_inside_autoclose_ranges =
if selections.len() == autoclose_pair_state.ranges.len() {
if selections.len() == autoclose_pair.ranges.len() {
selections
.iter()
.zip(autoclose_pair_state.ranges.ranges::<Point>(&buffer))
.zip(autoclose_pair.ranges.iter().map(|r| r.to_point(buffer)))
.all(|(selection, autoclose_range)| {
let head = selection.head().to_point(&buffer);
autoclose_range.start <= head && autoclose_range.end >= head