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

Properly handle inlay highlights in the InlayMap

Browse source 
Co-Authored-By: Antonio Scandurra <antonio@zed.dev>
This commit is contained in:
Kirill Bulatov 2023-09-14 17:01:36 +03:00
parent 80b96eb05b
commit a9de6c3dba
6 changed files with 114 additions and 147 deletions
Download patch file Download diff file Expand all files Collapse all files

11
crates/editor/src/display_map.rs
View file

@ -5,7 +5,7 @@ mod tab_map;
mod wrap_map;
use crate::{
link_go_to_definition::InlayRange, Anchor, AnchorRangeExt, InlayId, MultiBuffer,
link_go_to_definition::InlayHighlight, Anchor, AnchorRangeExt, InlayId, MultiBuffer,
MultiBufferSnapshot, ToOffset, ToPoint,
};
pub use block_map::{BlockMap, BlockPoint};
@ -44,7 +44,7 @@ pub trait ToDisplayPoint {
}
type TextHighlights = TreeMap<Option<TypeId>, Arc<(HighlightStyle, Vec<Range<Anchor>>)>>;
type InlayHighlights = TreeMap<Option<TypeId>, Arc<(HighlightStyle, Vec<InlayRange>)>>;
type InlayHighlights = TreeMap<Option<TypeId>, Arc<(HighlightStyle, Vec<InlayHighlight>)>>;
pub struct DisplayMap {
buffer: ModelHandle<MultiBuffer>,
@ -226,7 +226,7 @@ impl DisplayMap {
pub fn highlight_inlays(
&mut self,
type_id: TypeId,
ranges: Vec<InlayRange>,
ranges: Vec<InlayHighlight>,
style: HighlightStyle,
) {
self.inlay_highlights
@ -308,8 +308,9 @@ impl DisplayMap {
pub struct Highlights<'a> {
pub text_highlights: Option<&'a TextHighlights>,
pub inlay_highlights: Option<&'a InlayHighlights>,
// TODO kb remove, backgrounds are not handled in the *Map codegi
pub inlay_background_highlights:
Option<TreeMap<Option<TypeId>, Arc<(HighlightStyle, &'a [InlayRange])>>>,
Option<TreeMap<Option<TypeId>, Arc<(HighlightStyle, &'a [InlayHighlight])>>>,
pub inlay_highlight_style: Option<HighlightStyle>,
pub suggestion_highlight_style: Option<HighlightStyle>,
}
@ -482,7 +483,7 @@ impl DisplaySnapshot {
display_rows: Range<u32>,
language_aware: bool,
inlay_background_highlights: Option<
TreeMap<Option<TypeId>, Arc<(HighlightStyle, &'a [InlayRange])>>,
TreeMap<Option<TypeId>, Arc<(HighlightStyle, &'a [InlayHighlight])>>,
>,
inlay_highlight_style: Option<HighlightStyle>,
suggestion_highlight_style: Option<HighlightStyle>,

224
crates/editor/src/display_map/inlay_map.rs
View file

@ -1,5 +1,5 @@
use crate::{
link_go_to_definition::InlayRange,
link_go_to_definition::InlayHighlight,
multi_buffer::{MultiBufferChunks, MultiBufferRows},
Anchor, InlayId, MultiBufferSnapshot, ToOffset,
};
@ -219,6 +219,7 @@ pub struct InlayChunks<'a> {
suggestion_highlight_style: Option<HighlightStyle>,
highlight_endpoints: Peekable<vec::IntoIter<HighlightEndpoint>>,
active_highlights: BTreeMap<Option<TypeId>, HighlightStyle>,
highlights: Highlights<'a>,
snapshot: &'a InlaySnapshot,
}
@ -294,6 +295,44 @@ impl<'a> Iterator for InlayChunks<'a> {
prefix
}
Transform::Inlay(inlay) => {
let mut inlay_highlight_style_and_range = None;
if let Some(inlay_highlights) = self.highlights.inlay_highlights {
for (_, style_and_ranges) in inlay_highlights.iter() {
let highlight_style: &HighlightStyle = &style_and_ranges.0;
let inlay_ranges: &Vec<InlayHighlight> = &style_and_ranges.1;
// TODO kb: turn into a map.
if let Some(range) =
inlay_ranges.iter().find(|range| range.inlay == inlay.id)
{
inlay_highlight_style_and_range = Some((highlight_style, range));
break;
}
}
}
let mut highlight_style = match inlay.id {
InlayId::Suggestion(_) => self.suggestion_highlight_style,
InlayId::Hint(_) => self.inlay_highlight_style,
};
let next_inlay_highlight_endpoint;
if let Some((style, inlay_range)) = inlay_highlight_style_and_range {
let offset_in_inlay = (self.output_offset - self.transforms.start().0).0;
let range = inlay_range.highlight_start..inlay_range.highlight_end;
if offset_in_inlay < range.start {
next_inlay_highlight_endpoint = range.start;
} else if offset_in_inlay >= range.end {
next_inlay_highlight_endpoint = usize::MAX;
} else {
next_inlay_highlight_endpoint = range.end;
highlight_style
.get_or_insert_with(|| Default::default())
.highlight(style.clone());
}
} else {
next_inlay_highlight_endpoint = usize::MAX;
}
//
let inlay_chunks = self.inlay_chunks.get_or_insert_with(|| {
let start = self.output_offset - self.transforms.start().0;
let end = cmp::min(self.max_output_offset, self.transforms.end(&()).0)
@ -303,21 +342,15 @@ impl<'a> Iterator for InlayChunks<'a> {
let inlay_chunk = self
.inlay_chunk
.get_or_insert_with(|| inlay_chunks.next().unwrap());
let (chunk, remainder) = inlay_chunk.split_at(
inlay_chunk
.len()
.min(next_highlight_endpoint.0 - self.output_offset.0),
);
let (chunk, remainder) =
inlay_chunk.split_at(inlay_chunk.len().min(next_inlay_highlight_endpoint));
*inlay_chunk = remainder;
if inlay_chunk.is_empty() {
self.inlay_chunk = None;
}
self.output_offset.0 += chunk.len();
let mut highlight_style = match inlay.id {
InlayId::Suggestion(_) => self.suggestion_highlight_style,
InlayId::Hint(_) => self.inlay_highlight_style,
};
if !self.active_highlights.is_empty() {
for active_highlight in self.active_highlights.values() {
highlight_style
@ -626,18 +659,20 @@ impl InlayMap {
.filter(|ch| *ch != '\r')
.take(len)
.collect::<String>();
log::info!(
"creating inlay at buffer offset {} with bias {:?} and text {:?}",
position,
bias,
text
);
let inlay_id = if i % 2 == 0 {
InlayId::Hint(post_inc(next_inlay_id))
} else {
InlayId::Suggestion(post_inc(next_inlay_id))
};
log::info!(
"creating inlay {:?} at buffer offset {} with bias {:?} and text {:?}",
inlay_id,
position,
bias,
text
);
to_insert.push(Inlay {
id: inlay_id,
position: snapshot.buffer.anchor_at(position, bias),
@ -1012,38 +1047,39 @@ impl InlaySnapshot {
cursor.seek(&range.start, Bias::Right, &());
}
}
if let Some(inlay_highlights) = highlights.inlay_highlights {
let adjusted_highlights = TreeMap::from_ordered_entries(inlay_highlights.iter().map(
|(type_id, styled_ranges)| {
(
*type_id,
Arc::new((styled_ranges.0, styled_ranges.1.as_slice())),
)
},
));
if !inlay_highlights.is_empty() {
self.apply_inlay_highlights(
&mut cursor,
&range,
&adjusted_highlights,
&mut highlight_endpoints,
);
cursor.seek(&range.start, Bias::Right, &());
}
}
if let Some(inlay_background_highlights) = highlights.inlay_background_highlights.as_ref() {
if !inlay_background_highlights.is_empty() {
self.apply_inlay_highlights(
&mut cursor,
&range,
inlay_background_highlights,
&mut highlight_endpoints,
);
cursor.seek(&range.start, Bias::Right, &());
}
}
highlight_endpoints.sort();
// if let Some(inlay_highlights) = highlights.inlay_highlights {
// let adjusted_highlights = TreeMap::from_ordered_entries(inlay_highlights.iter().map(
// |(type_id, styled_ranges)| {
// (
// *type_id,
// Arc::new((styled_ranges.0, styled_ranges.1.as_slice())),
// )
// },
// ));
// if !inlay_highlights.is_empty() {
// self.apply_inlay_highlights(
// &mut cursor,
// &range,
// &adjusted_highlights,
// &mut highlight_endpoints,
// );
// cursor.seek(&range.start, Bias::Right, &());
// }
// }
// if let Some(inlay_background_highlights) = highlights.inlay_background_highlights.as_ref() {
// if !inlay_background_highlights.is_empty() {
// self.apply_inlay_highlights(
// &mut cursor,
// &range,
// inlay_background_highlights,
// &mut highlight_endpoints,
// );
// cursor.seek(&range.start, Bias::Right, &());
// }
// }
let buffer_range = self.to_buffer_offset(range.start)..self.to_buffer_offset(range.end);
let buffer_chunks = self.buffer.chunks(buffer_range, language_aware);
@ -1059,6 +1095,7 @@ impl InlaySnapshot {
suggestion_highlight_style: highlights.suggestion_highlight_style,
highlight_endpoints: highlight_endpoints.into_iter().peekable(),
active_highlights: Default::default(),
highlights,
snapshot: self,
}
}
@ -1121,79 +1158,6 @@ impl InlaySnapshot {
}
}
fn apply_inlay_highlights(
&self,
cursor: &mut Cursor<'_, Transform, (InlayOffset, usize)>,
range: &Range<InlayOffset>,
inlay_highlights: &TreeMap<Option<TypeId>, Arc<(HighlightStyle, &[InlayRange])>>,
highlight_endpoints: &mut Vec<HighlightEndpoint>,
) {
while cursor.start().0 < range.end {
let transform_start = self
.buffer
.anchor_after(self.to_buffer_offset(cmp::max(range.start, cursor.start().0)));
let transform_start = self.to_inlay_offset(transform_start.to_offset(&self.buffer));
let transform_end =
{
let overshoot = InlayOffset(range.end.0 - cursor.start().0 .0);
self.buffer.anchor_before(self.to_buffer_offset(cmp::min(
cursor.end(&()).0,
cursor.start().0 + overshoot,
)))
};
let transform_end = self.to_inlay_offset(transform_end.to_offset(&self.buffer));
// TODO kb add a map
let hint_for_id = |id| self.inlays.iter().find(|inlay| inlay.id == id);
for (tag, inlay_highlights) in inlay_highlights.iter() {
let style = inlay_highlights.0;
let ranges = inlay_highlights
.1
.iter()
.filter_map(|range| Some((hint_for_id(range.inlay)?, range)))
.map(|(hint, range)| {
let hint_start =
self.to_inlay_offset(hint.position.to_offset(&self.buffer));
let highlight_start = InlayOffset(hint_start.0 + range.highlight_start);
let highlight_end = InlayOffset(hint_start.0 + range.highlight_end);
highlight_start..highlight_end
})
.collect::<Vec<_>>();
let start_ix = match ranges.binary_search_by(|probe| {
if probe.end > transform_start {
cmp::Ordering::Greater
} else {
cmp::Ordering::Less
}
}) {
Ok(i) | Err(i) => i,
};
for range in &ranges[start_ix..] {
if range.start >= transform_end {
break;
}
highlight_endpoints.push(HighlightEndpoint {
offset: range.start,
is_start: true,
tag: *tag,
style,
});
highlight_endpoints.push(HighlightEndpoint {
offset: range.end,
is_start: false,
tag: *tag,
style,
});
}
}
cursor.next(&());
}
}
#[cfg(test)]
pub fn text(&self) -> String {
self.chunks(Default::default()..self.len(), false, Highlights::default())
@ -1752,7 +1716,7 @@ mod tests {
let mut text_highlights = TextHighlights::default();
let mut inlay_highlights = InlayHighlights::default();
let highlight_count = rng.gen_range(0_usize..10);
if rng.gen_bool(0.5) {
if false && rng.gen_bool(0.5) {
let mut highlight_ranges = (0..highlight_count)
.map(|_| buffer_snapshot.random_byte_range(0, &mut rng))
.collect::<Vec<_>>();
@ -1783,7 +1747,7 @@ mod tests {
let inlay_text_len = inlay.text.len();
match inlay_text_len {
0 => None,
1 => Some(InlayRange {
1 => Some(InlayHighlight {
inlay: inlay.id,
inlay_position: inlay.position,
highlight_start: 0,
@ -1791,17 +1755,17 @@ mod tests {
}),
n => {
let inlay_text = inlay.text.to_string();
let mut highlight_end_offset_increment = rng.gen_range(1..n);
while !inlay_text.is_char_boundary(highlight_end_offset_increment) {
highlight_end_offset_increment += 1;
let mut highlight_end = rng.gen_range(1..n);
while !inlay_text.is_char_boundary(highlight_end) {
highlight_end += 1;
}
Some(InlayRange {
Some(InlayHighlight {
inlay: inlay.id,
inlay_position: inlay.position,
highlight_start: 0,
// TODO kb
// highlight_end_offset_increment: highlight_end_offset_increment,
highlight_end: inlay.text.len(),
// highlight_end
highlight_end: inlay_text.len(),
})
}
}
@ -1821,9 +1785,11 @@ mod tests {
let mut start = rng.gen_range(0..=end);
start = expected_text.clip_offset(start, Bias::Right);
let range = InlayOffset(start)..InlayOffset(end);
log::info!("calling inlay_snapshot.chunks({:?})", range);
let actual_text = inlay_snapshot
.chunks(
InlayOffset(start)..InlayOffset(end),
range,
false,
Highlights {
text_highlights: Some(&text_highlights),

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

@ -66,7 +66,7 @@ use language::{
TransactionId,
};
use link_go_to_definition::{
hide_link_definition, show_link_definition, GoToDefinitionLink, InlayRange,
hide_link_definition, show_link_definition, GoToDefinitionLink, InlayHighlight,
LinkGoToDefinitionState,
};
use log::error;
@ -550,7 +550,7 @@ type GetFieldEditorTheme = dyn Fn(&theme::Theme) -> theme::FieldEditor;
type OverrideTextStyle = dyn Fn(&EditorStyle) -> Option<HighlightStyle>;
type BackgroundHighlight = (fn(&Theme) -> Color, Vec<Range<Anchor>>);
type InlayBackgroundHighlight = (fn(&Theme) -> Color, Vec<InlayRange>);
type InlayBackgroundHighlight = (fn(&Theme) -> Color, Vec<InlayHighlight>);
pub struct Editor {
handle: WeakViewHandle<Self>,
@ -7819,7 +7819,7 @@ impl Editor {
pub fn highlight_inlay_background<T: 'static>(
&mut self,
ranges: Vec<InlayRange>,
ranges: Vec<InlayHighlight>,
color_fetcher: fn(&Theme) -> Color,
cx: &mut ViewContext<Self>,
) {
@ -8019,7 +8019,7 @@ impl Editor {
pub fn highlight_inlays<T: 'static>(
&mut self,
ranges: Vec<InlayRange>,
ranges: Vec<InlayHighlight>,
style: HighlightStyle,
cx: &mut ViewContext<Self>,
) {

4
crates/editor/src/hover_popover.rs
View file

@ -1,6 +1,6 @@
use crate::{
display_map::{InlayOffset, ToDisplayPoint},
link_go_to_definition::{InlayRange, RangeInEditor},
link_go_to_definition::{InlayHighlight, RangeInEditor},
Anchor, AnchorRangeExt, DisplayPoint, Editor, EditorSettings, EditorSnapshot, EditorStyle,
ExcerptId, RangeToAnchorExt,
};
@ -50,7 +50,7 @@ pub fn hover_at(editor: &mut Editor, point: Option<DisplayPoint>, cx: &mut ViewC
pub struct InlayHover {
pub excerpt: ExcerptId,
pub range: InlayRange,
pub range: InlayHighlight,
pub tooltip: HoverBlock,
}

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

@ -26,7 +26,7 @@ pub struct LinkGoToDefinitionState {
#[derive(Debug, Eq, PartialEq, Clone)]
pub enum RangeInEditor {
Text(Range<Anchor>),
Inlay(InlayRange),
Inlay(InlayHighlight),
}
impl RangeInEditor {
@ -57,7 +57,7 @@ impl RangeInEditor {
#[derive(Debug)]
pub enum GoToDefinitionTrigger {
Text(DisplayPoint),
InlayHint(InlayRange, lsp::Location, LanguageServerId),
InlayHint(InlayHighlight, lsp::Location, LanguageServerId),
}
#[derive(Debug, Clone)]
@ -67,9 +67,10 @@ pub enum GoToDefinitionLink {
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InlayRange {
pub struct InlayHighlight {
pub inlay: InlayId,
pub inlay_position: Anchor,
// TODO kb turn into Range<usize>
pub highlight_start: usize,
pub highlight_end: usize,
}
@ -77,7 +78,7 @@ pub struct InlayRange {
#[derive(Debug, Clone)]
pub enum TriggerPoint {
Text(Anchor),
InlayHint(InlayRange, lsp::Location, LanguageServerId),
InlayHint(InlayHighlight, lsp::Location, LanguageServerId),
}
impl TriggerPoint {
@ -248,7 +249,7 @@ pub fn update_inlay_link_and_hover_points(
}
}
},
range: InlayRange {
range: InlayHighlight {
inlay: hovered_hint.id,
inlay_position: hovered_hint.position,
highlight_start: extra_shift_left,
@ -271,7 +272,7 @@ pub fn update_inlay_link_and_hover_points(
hovered_offset,
)
{
let range = InlayRange {
let range = InlayHighlight {
inlay: hovered_hint.id,
inlay_position: hovered_hint.position,
highlight_start: (part_range.start - hint_start).0

1
crates/vim/src/state.rs
View file

@ -186,7 +186,6 @@ impl EditorState {
if self.active_operator().is_none() && self.pre_count.is_some()
|| self.active_operator().is_some() && self.post_count.is_some()
{
dbg!("VimCount");
context.add_identifier("VimCount");
}