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

Do not track editor ranges in InlayHintCache

Browse source
This commit is contained in:
Kirill Bulatov 2023-06-19 16:48:58 +03:00
parent 70a45fc800
commit 3b9a2e3261
4 changed files with 163 additions and 365 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1385,6 +1385,7 @@ impl Editor {
} }
this.report_editor_event("open", None, cx); this.report_editor_event("open", None, cx);
this.refresh_inlays(InlayRefreshReason::VisibleExcerptsChange, cx);
this this
} }
@ -2597,19 +2598,13 @@ impl Editor {
} }
fn refresh_inlays(&mut self, reason: InlayRefreshReason, cx: &mut ViewContext<Self>) { fn refresh_inlays(&mut self, reason: InlayRefreshReason, cx: &mut ViewContext<Self>) {
if self.mode != EditorMode::Full { if self.mode != EditorMode::Full || !settings::get::<EditorSettings>(cx).inlay_hints.enabled
return; {
}
if !settings::get::<EditorSettings>(cx).inlay_hints.enabled {
let to_remove = self.inlay_hint_cache.clear();
self.splice_inlay_hints(to_remove, Vec::new(), cx);
return; return;
} }
let multi_buffer_handle = self.buffer().clone(); let multi_buffer_handle = self.buffer().clone();
let multi_buffer_snapshot = multi_buffer_handle.read(cx).snapshot(cx); let multi_buffer_snapshot = multi_buffer_handle.read(cx).snapshot(cx);
let currently_visible_ranges = self.excerpt_visible_offsets(&multi_buffer_handle, cx);
let currently_shown_inlay_hints = self.display_map.read(cx).current_inlays().fold( let currently_shown_inlay_hints = self.display_map.read(cx).current_inlays().fold(
HashMap::<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>::default(), HashMap::<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>::default(),
|mut current_hints, inlay| { |mut current_hints, inlay| {
@ -2636,61 +2631,25 @@ impl Editor {
to_remove, to_remove,
to_insert, to_insert,
}) = self.inlay_hint_cache.apply_settings( }) = self.inlay_hint_cache.apply_settings(
&multi_buffer_handle,
new_settings, new_settings,
currently_visible_ranges,
currently_shown_inlay_hints, currently_shown_inlay_hints,
cx, cx,
) { ) {
self.splice_inlay_hints(to_remove, to_insert, cx); self.splice_inlay_hints(to_remove, to_insert, cx);
} }
} }
InlayRefreshReason::Scroll(scrolled_to) => {
if let Some(updated_range_query) = currently_visible_ranges.iter().find_map(
|(buffer, excerpt_visible_offset_range, excerpt_id)| {
let buffer_id = scrolled_to.anchor.buffer_id?;
if buffer_id == buffer.read(cx).remote_id()
&& &scrolled_to.anchor.excerpt_id == excerpt_id
{
Some(inlay_hint_query(
buffer,
*excerpt_id,
excerpt_visible_offset_range,
cx,
))
} else {
None
}
},
) {
cx.spawn(|editor, mut cx| async move {
let InlaySplice {
to_remove,
to_insert,
} = editor
.update(&mut cx, |editor, cx| {
editor.inlay_hint_cache.update_hints(
multi_buffer_handle,
vec![updated_range_query],
currently_shown_inlay_hints,
false,
cx,
)
})?
.await
.context("inlay cache hint fetch")?;
editor.update(&mut cx, |editor, cx| {
editor.splice_inlay_hints(to_remove, to_insert, cx)
})
})
.detach_and_log_err(cx);
}
}
InlayRefreshReason::VisibleExcerptsChange => { InlayRefreshReason::VisibleExcerptsChange => {
let replacement_queries = currently_visible_ranges let replacement_queries = self
.iter() .excerpt_visible_offsets(&multi_buffer_handle, cx)
.map(|(buffer, excerpt_visible_offset_range, excerpt_id)| { .into_iter()
inlay_hint_query(buffer, *excerpt_id, excerpt_visible_offset_range, cx) .map(|(buffer, _, excerpt_id)| {
let buffer = buffer.read(cx);
InlayHintQuery {
buffer_id: buffer.remote_id(),
buffer_version: buffer.version.clone(),
excerpt_id,
}
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
cx.spawn(|editor, mut cx| async move { cx.spawn(|editor, mut cx| async move {
@ -2703,7 +2662,6 @@ impl Editor {
multi_buffer_handle, multi_buffer_handle,
replacement_queries, replacement_queries,
currently_shown_inlay_hints, currently_shown_inlay_hints,
true,
cx, cx,
) )
})? })?
@ -7689,32 +7647,6 @@ impl Editor {
} }
} }
fn inlay_hint_query(
buffer: &ModelHandle<Buffer>,
excerpt_id: ExcerptId,
excerpt_visible_offset_range: &Range<usize>,
cx: &mut ViewContext<'_, '_, Editor>,
) -> InlayHintQuery {
let buffer = buffer.read(cx);
let max_buffer_len = buffer.len();
let visible_offset_range_len = excerpt_visible_offset_range.len();
let query_range_start = excerpt_visible_offset_range
.start
.saturating_sub(visible_offset_range_len);
let query_range_end = max_buffer_len.min(
excerpt_visible_offset_range
.end
.saturating_add(visible_offset_range_len),
);
InlayHintQuery {
buffer_id: buffer.remote_id(),
buffer_version: buffer.version().clone(),
excerpt_id,
excerpt_offset_query_range: query_range_start..query_range_end,
}
}
fn consume_contiguous_rows( fn consume_contiguous_rows(
contiguous_row_selections: &mut Vec<Selection<Point>>, contiguous_row_selections: &mut Vec<Selection<Point>>,
selection: &Selection<Point>, selection: &Selection<Point>,

2
crates/editor/src/element.rs
View file

@ -1921,7 +1921,7 @@ impl Element<Editor> for EditorElement {
let em_advance = style.text.em_advance(cx.font_cache()); let em_advance = style.text.em_advance(cx.font_cache());
let overscroll = vec2f(em_width, 0.); let overscroll = vec2f(em_width, 0.);
let snapshot = { let snapshot = {
editor.set_visible_line_count(size.y() / line_height, cx); editor.set_visible_line_count(size.y() / line_height);
let editor_width = text_width - gutter_margin - overscroll.x() - em_width; let editor_width = text_width - gutter_margin - overscroll.x() - em_width;
let wrap_width = match editor.soft_wrap_mode(cx) { let wrap_width = match editor.soft_wrap_mode(cx) {

377
crates/editor/src/inlay_hint_cache.rs
View file

@ -1,22 +1,18 @@
use std::{cmp, ops::Range}; use std::cmp;
use crate::{ use crate::{editor_settings, Anchor, Editor, ExcerptId, InlayId, MultiBuffer};
editor_settings, scroll::ScrollAnchor, Anchor, Editor, ExcerptId, InlayId, MultiBuffer,
};
use anyhow::Context; use anyhow::Context;
use clock::Global; use clock::Global;
use gpui::{ModelHandle, Task, ViewContext}; use gpui::{ModelHandle, Task, ViewContext};
use language::Buffer;
use log::error; use log::error;
use project::{InlayHint, InlayHintKind}; use project::{InlayHint, InlayHintKind};
use collections::{hash_map, HashMap, HashSet}; use collections::{HashMap, HashSet};
use util::post_inc; use util::post_inc;
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum InlayRefreshReason { pub enum InlayRefreshReason {
SettingsChange(editor_settings::InlayHints), SettingsChange(editor_settings::InlayHints),
Scroll(ScrollAnchor),
VisibleExcerptsChange, VisibleExcerptsChange,
} }
@ -30,22 +26,7 @@ pub struct InlayHintCache {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
struct BufferHints<H> { struct BufferHints<H> {
buffer_version: Global, buffer_version: Global,
hints_per_excerpt: HashMap<ExcerptId, ExcerptHints<H>>, hints_per_excerpt: HashMap<ExcerptId, Vec<H>>,
}
#[derive(Clone, Debug)]
struct ExcerptHints<H> {
cached_excerpt_offsets: Vec<Range<usize>>,
hints: Vec<H>,
}
impl<H> Default for ExcerptHints<H> {
fn default() -> Self {
Self {
cached_excerpt_offsets: Vec::new(),
hints: Vec::new(),
}
}
} }
impl<H> BufferHints<H> { impl<H> BufferHints<H> {
@ -68,7 +49,6 @@ pub struct InlayHintQuery {
pub buffer_id: u64, pub buffer_id: u64,
pub buffer_version: Global, pub buffer_version: Global,
pub excerpt_id: ExcerptId, pub excerpt_id: ExcerptId,
pub excerpt_offset_query_range: Range<usize>,
} }
impl InlayHintCache { impl InlayHintCache {
@ -82,99 +62,108 @@ impl InlayHintCache {
pub fn apply_settings( pub fn apply_settings(
&mut self, &mut self,
multi_buffer: &ModelHandle<MultiBuffer>,
inlay_hint_settings: editor_settings::InlayHints, inlay_hint_settings: editor_settings::InlayHints,
currently_visible_ranges: Vec<(ModelHandle<Buffer>, Range<usize>, ExcerptId)>,
currently_shown_hints: HashMap<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>, currently_shown_hints: HashMap<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>,
cx: &mut ViewContext<Editor>, cx: &mut ViewContext<Editor>,
) -> Option<InlaySplice> { ) -> Option<InlaySplice> {
let mut shown_hints_to_clean = currently_shown_hints; if !inlay_hint_settings.enabled {
self.allowed_hint_kinds = allowed_hint_types(inlay_hint_settings);
if self.inlay_hints.is_empty() {
return None;
} else {
let to_remove = self.inlay_hints.keys().copied().collect();
self.inlay_hints.clear();
self.hints_in_buffers.clear();
return Some(InlaySplice {
to_remove,
to_insert: Vec::new(),
});
}
}
let new_allowed_hint_kinds = allowed_hint_types(inlay_hint_settings); let new_allowed_hint_kinds = allowed_hint_types(inlay_hint_settings);
if new_allowed_hint_kinds == self.allowed_hint_kinds { if new_allowed_hint_kinds == self.allowed_hint_kinds {
None None
} else { } else {
self.allowed_hint_kinds = new_allowed_hint_kinds; let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
let mut to_remove = Vec::new(); let mut to_remove = Vec::new();
let mut to_insert = Vec::new(); let mut to_insert = Vec::new();
let mut considered_hints = let mut shown_hints_to_remove = currently_shown_hints;
HashMap::<u64, HashMap<ExcerptId, HashSet<InlayId>>>::default();
for (visible_buffer, _, visible_excerpt_id) in currently_visible_ranges { // TODO kb move into a background task
let visible_buffer = visible_buffer.read(cx); for (buffer_id, cached_buffer_hints) in &self.hints_in_buffers {
let visible_buffer_id = visible_buffer.remote_id(); let shown_buffer_hints_to_remove =
match shown_hints_to_clean.entry(visible_buffer_id) { shown_hints_to_remove.entry(*buffer_id).or_default();
hash_map::Entry::Occupied(mut o) => { for (excerpt_id, cached_excerpt_hints) in &cached_buffer_hints.hints_per_excerpt {
let shown_hints_per_excerpt = o.get_mut(); let shown_excerpt_hints_to_remove =
for (_, shown_hint_id) in shown_hints_per_excerpt shown_buffer_hints_to_remove.entry(*excerpt_id).or_default();
.remove(&visible_excerpt_id) let mut cached_hints = cached_excerpt_hints.iter().fuse().peekable();
.unwrap_or_default() shown_excerpt_hints_to_remove.retain(|(shown_anchor, shown_hint_id)| {
loop {
match cached_hints.peek() {
Some((cached_anchor, cached_hint_id)) => {
if cached_hint_id == shown_hint_id {
return !new_allowed_hint_kinds.contains(
&self.inlay_hints.get(&cached_hint_id).unwrap().kind,
);
}
match cached_anchor.cmp(shown_anchor, &multi_buffer_snapshot) {
cmp::Ordering::Less | cmp::Ordering::Equal => {
let maybe_missed_cached_hint =
self.inlay_hints.get(&cached_hint_id).unwrap();
let cached_hint_kind = maybe_missed_cached_hint.kind;
if !self.allowed_hint_kinds.contains(&cached_hint_kind)
&& new_allowed_hint_kinds
.contains(&cached_hint_kind)
{ {
considered_hints to_insert.push((
.entry(visible_buffer_id) *cached_hint_id,
.or_default() *cached_anchor,
.entry(visible_excerpt_id) maybe_missed_cached_hint.clone(),
.or_default() ));
.insert(shown_hint_id); }
match self.inlay_hints.get(&shown_hint_id) { cached_hints.next();
Some(shown_hint) => { }
if !self.allowed_hint_kinds.contains(&shown_hint.kind) { cmp::Ordering::Greater => break,
to_remove.push(shown_hint_id);
} }
} }
None => to_remove.push(shown_hint_id), None => return true,
}
}
if shown_hints_per_excerpt.is_empty() {
o.remove();
}
}
hash_map::Entry::Vacant(_) => {}
} }
} }
let reenabled_hints = self match self.inlay_hints.get(&shown_hint_id) {
.hints_in_buffers Some(shown_hint) => !new_allowed_hint_kinds.contains(&shown_hint.kind),
.iter() None => true,
.filter_map(|(cached_buffer_id, cached_hints_per_excerpt)| { }
let considered_hints_in_excerpts = considered_hints.get(cached_buffer_id)?;
let not_considered_cached_hints = cached_hints_per_excerpt
.hints_per_excerpt
.iter()
.filter_map(|(cached_excerpt_id, cached_excerpt_hints)| {
let considered_excerpt_hints =
considered_hints_in_excerpts.get(&cached_excerpt_id)?;
let not_considered_cached_hints = cached_excerpt_hints
.hints
.iter()
.filter(|(_, cached_hint_id)| {
!considered_excerpt_hints.contains(cached_hint_id)
})
.copied();
Some(not_considered_cached_hints)
})
.flatten();
Some(not_considered_cached_hints)
})
.flatten()
.filter_map(|(cached_anchor, cached_hint_id)| {
Some((
cached_anchor,
cached_hint_id,
self.inlay_hints.get(&cached_hint_id)?,
))
})
.filter(|(_, _, cached_hint)| self.allowed_hint_kinds.contains(&cached_hint.kind))
.map(|(cached_anchor, cached_hint_id, reenabled_hint)| {
(cached_hint_id, cached_anchor, reenabled_hint.clone())
}); });
to_insert.extend(reenabled_hints);
for (cached_anchor, cached_hint_id) in cached_hints {
let maybe_missed_cached_hint =
self.inlay_hints.get(&cached_hint_id).unwrap();
let cached_hint_kind = maybe_missed_cached_hint.kind;
if !self.allowed_hint_kinds.contains(&cached_hint_kind)
&& new_allowed_hint_kinds.contains(&cached_hint_kind)
{
to_insert.push((
*cached_hint_id,
*cached_anchor,
maybe_missed_cached_hint.clone(),
));
}
}
}
}
to_remove.extend( to_remove.extend(
shown_hints_to_clean shown_hints_to_remove
.into_iter() .into_iter()
.flat_map(|(_, hints_by_excerpt)| hints_by_excerpt) .flat_map(|(_, hints_by_excerpt)| hints_by_excerpt)
.flat_map(|(_, excerpt_hints)| excerpt_hints) .flat_map(|(_, excerpt_hints)| excerpt_hints)
.map(|(_, hint_id)| hint_id), .map(|(_, hint_id)| hint_id),
); );
self.allowed_hint_kinds = new_allowed_hint_kinds;
Some(InlaySplice { Some(InlaySplice {
to_remove, to_remove,
to_insert, to_insert,
@ -182,22 +171,14 @@ impl InlayHintCache {
} }
} }
pub fn clear(&mut self) -> Vec<InlayId> {
let ids_to_remove = self.inlay_hints.drain().map(|(id, _)| id).collect();
self.hints_in_buffers.clear();
ids_to_remove
}
pub fn update_hints( pub fn update_hints(
&mut self, &mut self,
multi_buffer: ModelHandle<MultiBuffer>, multi_buffer: ModelHandle<MultiBuffer>,
range_updates: Vec<InlayHintQuery>, queries: Vec<InlayHintQuery>,
currently_shown_hints: HashMap<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>, currently_shown_hints: HashMap<u64, HashMap<ExcerptId, Vec<(Anchor, InlayId)>>>,
conflicts_invalidate_cache: bool,
cx: &mut ViewContext<Editor>, cx: &mut ViewContext<Editor>,
) -> Task<anyhow::Result<InlaySplice>> { ) -> Task<anyhow::Result<InlaySplice>> {
let conflicts_with_cache = conflicts_invalidate_cache let conflicts_with_cache = queries.iter().any(|update_query| {
&& range_updates.iter().any(|update_query| {
let Some(cached_buffer_hints) = self.hints_in_buffers.get(&update_query.buffer_id) let Some(cached_buffer_hints) = self.hints_in_buffers.get(&update_query.buffer_id)
else { return false }; else { return false };
if cached_buffer_hints if cached_buffer_hints
@ -217,11 +198,29 @@ impl InlayHintCache {
} }
}); });
let queries = filter_queries( // TODO kb remember queries that run and do not query for these ranges if the buffer version was not changed
range_updates.into_iter(), let queries = queries
&self.hints_in_buffers, .into_iter()
conflicts_with_cache, .filter_map(|query| {
); let Some(cached_buffer_hints) = self.hints_in_buffers.get(&query.buffer_id)
else { return Some(query) };
if cached_buffer_hints
.buffer_version
.changed_since(&query.buffer_version)
{
return None;
}
if conflicts_with_cache
|| !cached_buffer_hints
.hints_per_excerpt
.contains_key(&query.excerpt_id)
{
Some(query)
} else {
None
}
})
.collect::<Vec<_>>();
let task_multi_buffer = multi_buffer.clone(); let task_multi_buffer = multi_buffer.clone();
let fetch_queries_task = fetch_queries(multi_buffer, queries.into_iter(), cx); let fetch_queries_task = fetch_queries(multi_buffer, queries.into_iter(), cx);
let mut to_remove = Vec::new(); let mut to_remove = Vec::new();
@ -255,7 +254,7 @@ impl InlayHintCache {
|(excerpt_id, excerpt_hints)| { |(excerpt_id, excerpt_hints)| {
( (
*excerpt_id, *excerpt_id,
excerpt_hints.hints.iter().map(|(_, id)| *id).collect(), excerpt_hints.iter().map(|(_, id)| *id).collect(),
) )
}, },
), ),
@ -276,15 +275,14 @@ impl InlayHintCache {
.or_default(); .or_default();
let empty_shown_excerpt_hints = Vec::new(); let empty_shown_excerpt_hints = Vec::new();
let shown_excerpt_hints = shown_buffer_hints.and_then(|hints| hints.get(&new_excerpt_id)).unwrap_or(&empty_shown_excerpt_hints); let shown_excerpt_hints = shown_buffer_hints.and_then(|hints| hints.get(&new_excerpt_id)).unwrap_or(&empty_shown_excerpt_hints);
for new_hint in new_hints_per_excerpt.hints { for new_hint in new_hints_per_excerpt {
let new_hint_anchor = multi_buffer_snapshot let new_hint_anchor = multi_buffer_snapshot
.anchor_in_excerpt(new_excerpt_id, new_hint.position); .anchor_in_excerpt(new_excerpt_id, new_hint.position);
let cache_insert_ix = match cached_excerpt_hints.hints.binary_search_by(|probe| { let cache_insert_ix = match cached_excerpt_hints.binary_search_by(|probe| {
new_hint_anchor.cmp(&probe.0, &multi_buffer_snapshot) new_hint_anchor.cmp(&probe.0, &multi_buffer_snapshot)
}) { }) {
Ok(ix) => { Ok(ix) => {
let (_, cached_inlay_id) = let (_, cached_inlay_id) = cached_excerpt_hints[ix];
cached_excerpt_hints.hints[ix];
let cache_hit = editor let cache_hit = editor
.inlay_hint_cache .inlay_hint_cache
.inlay_hints .inlay_hints
@ -331,25 +329,13 @@ impl InlayHintCache {
} }
}; };
excerpt_cache_hints_to_persist.insert(hint_id); excerpt_cache_hints_to_persist.insert(hint_id);
cached_excerpt_hints cached_excerpt_hints.insert(insert_ix, (new_hint_anchor, hint_id));
.hints
.insert(insert_ix, (new_hint_anchor, hint_id));
editor editor
.inlay_hint_cache .inlay_hint_cache
.inlay_hints .inlay_hints
.insert(hint_id, new_hint); .insert(hint_id, new_hint);
} }
} }
if conflicts_with_cache {
cached_excerpt_hints.cached_excerpt_offsets.clear();
}
for new_range in new_hints_per_excerpt.cached_excerpt_offsets {
insert_and_merge_ranges(
&mut cached_excerpt_hints.cached_excerpt_offsets,
&new_range,
)
}
} }
} }
@ -373,7 +359,7 @@ impl InlayHintCache {
buffer_hints.buffer_version = buffer_hints_to_persist.0; buffer_hints.buffer_version = buffer_hints_to_persist.0;
buffer_hints.hints_per_excerpt.retain(|excerpt_id, excerpt_hints| { buffer_hints.hints_per_excerpt.retain(|excerpt_id, excerpt_hints| {
let Some(excerpt_hints_to_persist) = buffer_hints_to_persist.1.remove(&excerpt_id) else { return false; }; let Some(excerpt_hints_to_persist) = buffer_hints_to_persist.1.remove(&excerpt_id) else { return false; };
excerpt_hints.hints.retain(|(_, hint_id)| { excerpt_hints.retain(|(_, hint_id)| {
let retain = excerpt_hints_to_persist.contains(hint_id); let retain = excerpt_hints_to_persist.contains(hint_id);
if !retain { if !retain {
editor editor
@ -383,7 +369,7 @@ impl InlayHintCache {
} }
retain retain
}); });
!excerpt_hints.hints.is_empty() !excerpt_hints.is_empty()
}); });
!buffer_hints.hints_per_excerpt.is_empty() !buffer_hints.hints_per_excerpt.is_empty()
}); });
@ -398,53 +384,6 @@ impl InlayHintCache {
} }
} }
fn filter_queries(
queries: impl Iterator<Item = InlayHintQuery>,
cached_hints: &HashMap<u64, BufferHints<(Anchor, InlayId)>>,
invalidate_cache: bool,
) -> Vec<InlayHintQuery> {
// TODO kb remember queries that run and do not query for these ranges if the buffer version was not changed
queries
.filter_map(|query| {
let Some(cached_buffer_hints) = cached_hints.get(&query.buffer_id)
else { return Some(vec![query]) };
if cached_buffer_hints
.buffer_version
.changed_since(&query.buffer_version)
{
return None;
}
let Some(excerpt_hints) = cached_buffer_hints.hints_per_excerpt.get(&query.excerpt_id)
else { return Some(vec![query]) };
if invalidate_cache {
Some(vec![query])
} else {
let non_cached_ranges = missing_subranges(
&excerpt_hints.cached_excerpt_offsets,
&query.excerpt_offset_query_range,
);
if non_cached_ranges.is_empty() {
None
} else {
Some(
non_cached_ranges
.into_iter()
.map(|non_cached_range| InlayHintQuery {
buffer_id: query.buffer_id,
buffer_version: query.buffer_version.clone(),
excerpt_id: query.excerpt_id,
excerpt_offset_query_range: non_cached_range,
})
.collect(),
)
}
}
})
.flatten()
.collect()
}
fn allowed_hint_types( fn allowed_hint_types(
inlay_hint_settings: editor_settings::InlayHints, inlay_hint_settings: editor_settings::InlayHints,
) -> HashSet<Option<InlayHintKind>> { ) -> HashSet<Option<InlayHintKind>> {
@ -461,78 +400,6 @@ fn allowed_hint_types(
new_allowed_hint_types new_allowed_hint_types
} }
fn missing_subranges(cache: &[Range<usize>], input: &Range<usize>) -> Vec<Range<usize>> {
let mut missing = Vec::new();
// Find where the input range would fit in the cache
let index = match cache.binary_search_by_key(&input.start, |probe| probe.start) {
Ok(pos) | Err(pos) => pos,
};
// Check for a gap from the start of the input range to the first range in the cache
if index == 0 {
if input.start < cache[index].start {
missing.push(input.start..cache[index].start);
}
} else {
let prev_end = cache[index - 1].end;
if input.start < prev_end {
missing.push(input.start..prev_end);
}
}
// Iterate through the cache ranges starting from index
for i in index..cache.len() {
let start = if i > 0 { cache[i - 1].end } else { input.start };
let end = cache[i].start;
if start < end {
missing.push(start..end);
}
}
// Check for a gap from the last range in the cache to the end of the input range
if let Some(last_range) = cache.last() {
if last_range.end < input.end {
missing.push(last_range.end..input.end);
}
} else {
// If cache is empty, the entire input range is missing
missing.push(input.start..input.end);
}
missing
}
fn insert_and_merge_ranges(cache: &mut Vec<Range<usize>>, new_range: &Range<usize>) {
if cache.is_empty() {
cache.push(new_range.clone());
return;
}
// Find the index to insert the new range
let index = match cache.binary_search_by_key(&new_range.start, |probe| probe.start) {
Ok(pos) | Err(pos) => pos,
};
// Check if the new range overlaps with the previous range in the cache
if index > 0 && cache[index - 1].end >= new_range.start {
// Merge with the previous range
cache[index - 1].end = cmp::max(cache[index - 1].end, new_range.end);
} else {
// Insert the new range, as it doesn't overlap with the previous range
cache.insert(index, new_range.clone());
}
// Merge overlaps with subsequent ranges
let mut i = index;
while i + 1 < cache.len() && cache[i].end >= cache[i + 1].start {
cache[i].end = cmp::max(cache[i].end, cache[i + 1].end);
cache.remove(i + 1);
i += 1;
}
}
fn fetch_queries( fn fetch_queries(
multi_buffer: ModelHandle<MultiBuffer>, multi_buffer: ModelHandle<MultiBuffer>,
queries: impl Iterator<Item = InlayHintQuery>, queries: impl Iterator<Item = InlayHintQuery>,
@ -546,15 +413,23 @@ fn fetch_queries(
else { return anyhow::Ok((query, Some(Vec::new()))) }; else { return anyhow::Ok((query, Some(Vec::new()))) };
let task = editor let task = editor
.update(&mut cx, |editor, cx| { .update(&mut cx, |editor, cx| {
if let Some((_, excerpt_range)) = task_multi_buffer.read(cx)
.excerpts_for_buffer(&buffer_handle, cx)
.into_iter()
.find(|(excerpt_id, _)| excerpt_id == &query.excerpt_id)
{
editor.project.as_ref().map(|project| { editor.project.as_ref().map(|project| {
project.update(cx, |project, cx| { project.update(cx, |project, cx| {
project.query_inlay_hints_for_buffer( project.query_inlay_hints_for_buffer(
buffer_handle, buffer_handle,
query.excerpt_offset_query_range.clone(), excerpt_range.context,
cx, cx,
) )
}) })
}) })
} else {
None
}
}) })
.context("inlays fetch task spawn")?; .context("inlays fetch task spawn")?;
Ok(( Ok((
@ -587,13 +462,11 @@ fn fetch_queries(
.hints_per_excerpt .hints_per_excerpt
.entry(query.excerpt_id) .entry(query.excerpt_id)
.or_default(); .or_default();
insert_and_merge_ranges(&mut cached_excerpt_hints.cached_excerpt_offsets, &query.excerpt_offset_query_range);
let excerpt_hints = &mut cached_excerpt_hints.hints;
for inlay in response_hints { for inlay in response_hints {
match excerpt_hints.binary_search_by(|probe| { match cached_excerpt_hints.binary_search_by(|probe| {
inlay.position.cmp(&probe.position, &buffer_snapshot) inlay.position.cmp(&probe.position, &buffer_snapshot)
}) { }) {
Ok(ix) | Err(ix) => excerpt_hints.insert(ix, inlay), Ok(ix) | Err(ix) => cached_excerpt_hints.insert(ix, inlay),
} }
} }
} }

13
crates/editor/src/scroll.rs
View file

@ -18,7 +18,6 @@ use workspace::WorkspaceId;
use crate::{ use crate::{
display_map::{DisplaySnapshot, ToDisplayPoint}, display_map::{DisplaySnapshot, ToDisplayPoint},
hover_popover::hide_hover, hover_popover::hide_hover,
inlay_hint_cache::InlayRefreshReason,
persistence::DB, persistence::DB,
Anchor, DisplayPoint, Editor, EditorMode, Event, MultiBufferSnapshot, ToPoint, Anchor, DisplayPoint, Editor, EditorMode, Event, MultiBufferSnapshot, ToPoint,
}; };
@ -177,7 +176,7 @@ impl ScrollManager {
autoscroll: bool, autoscroll: bool,
workspace_id: Option<i64>, workspace_id: Option<i64>,
cx: &mut ViewContext<Editor>, cx: &mut ViewContext<Editor>,
) -> ScrollAnchor { ) {
let (new_anchor, top_row) = if scroll_position.y() <= 0. { let (new_anchor, top_row) = if scroll_position.y() <= 0. {
( (
ScrollAnchor { ScrollAnchor {
@ -206,7 +205,6 @@ impl ScrollManager {
}; };
self.set_anchor(new_anchor, top_row, local, autoscroll, workspace_id, cx); self.set_anchor(new_anchor, top_row, local, autoscroll, workspace_id, cx);
new_anchor
} }
fn set_anchor( fn set_anchor(
@ -295,12 +293,8 @@ impl Editor {
self.scroll_manager.visible_line_count self.scroll_manager.visible_line_count
} }
pub(crate) fn set_visible_line_count(&mut self, lines: f32, cx: &mut ViewContext<Self>) { pub(crate) fn set_visible_line_count(&mut self, lines: f32) {
let had_no_visibles = self.scroll_manager.visible_line_count.is_none();
self.scroll_manager.visible_line_count = Some(lines); self.scroll_manager.visible_line_count = Some(lines);
if had_no_visibles {
self.refresh_inlays(InlayRefreshReason::VisibleExcerptsChange, cx);
}
} }
pub fn set_scroll_position(&mut self, scroll_position: Vector2F, cx: &mut ViewContext<Self>) { pub fn set_scroll_position(&mut self, scroll_position: Vector2F, cx: &mut ViewContext<Self>) {
@ -318,7 +312,7 @@ impl Editor {
hide_hover(self, cx); hide_hover(self, cx);
let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1); let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
let scroll_anchor = self.scroll_manager.set_scroll_position( self.scroll_manager.set_scroll_position(
scroll_position, scroll_position,
&map, &map,
local, local,
@ -326,7 +320,6 @@ impl Editor {
workspace_id, workspace_id,
cx, cx,
); );
self.refresh_inlays(InlayRefreshReason::Scroll(scroll_anchor), cx);
} }
pub fn scroll_position(&self, cx: &mut ViewContext<Self>) -> Vector2F { pub fn scroll_position(&self, cx: &mut ViewContext<Self>) -> Vector2F {