zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2025-01-08 15:27:06 +03:00
Code Issues Packages Projects Releases Wiki Activity

Properly update inlay hints when settings are changed

Browse Source
This commit is contained in:
Kirill Bulatov 2023-06-14 00:39:51 +03:00
parent 1ed52276e0
commit c898298c5c
4 changed files with 315 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/editor/src/display_map.rs
View File

@ -303,7 +303,7 @@ impl DisplayMap {
.update(cx, |map, cx| map.sync(snapshot, edits, cx));
self.block_map.read(snapshot, edits);
let new_inlays = to_insert
let new_inlays: Vec<(InlayId, InlayProperties<String>)> = to_insert
.into_iter()
.map(|(inlay_id, hint_anchor, hint)| {
let mut text = hint.text();

236
crates/editor/src/editor.rs
View File

@ -1,4 +1,5 @@
mod blink_manager;
pub mod display_map;
mod editor_settings;
mod element;
@ -26,8 +27,8 @@ use aho_corasick::AhoCorasick;
use anyhow::{anyhow, Context, Result};
use blink_manager::BlinkManager;
use client::{ClickhouseEvent, TelemetrySettings};
use clock::{Global, ReplicaId};
use collections::{hash_map, BTreeMap, Bound, HashMap, HashSet, VecDeque};
use clock::ReplicaId;
use collections::{BTreeMap, Bound, HashMap, HashSet, VecDeque};
use copilot::Copilot;
pub use display_map::DisplayPoint;
use display_map::*;
@ -53,7 +54,7 @@ use gpui::{
};
use highlight_matching_bracket::refresh_matching_bracket_highlights;
use hover_popover::{hide_hover, HoverState};
use inlay_cache::{InlayCache, InlaysUpdate, OrderedByAnchorOffset};
use inlay_cache::{InlayCache, InlayRefreshReason, InlaysUpdate, QueryInlaysRange};
pub use items::MAX_TAB_TITLE_LEN;
use itertools::Itertools;
pub use language::{char_kind, CharKind};
@ -73,10 +74,7 @@ pub use multi_buffer::{
};
use multi_buffer::{MultiBufferChunks, ToOffsetUtf16};
use ordered_float::OrderedFloat;
use project::{
FormatTrigger, InlayHint, InlayHintKind, Location, LocationLink, Project, ProjectPath,
ProjectTransaction,
};
use project::{FormatTrigger, Location, LocationLink, Project, ProjectPath, ProjectTransaction};
use scroll::{
autoscroll::Autoscroll, OngoingScroll, ScrollAnchor, ScrollManager, ScrollbarAutoHide,
};
@ -85,7 +83,6 @@ use serde::{Deserialize, Serialize};
use settings::SettingsStore;
use smallvec::SmallVec;
use snippet::Snippet;
use std::path::PathBuf;
use std::{
any::TypeId,
borrow::Cow,
@ -1291,14 +1288,16 @@ impl Editor {
(mode == EditorMode::SingleLine).then(|| language_settings::SoftWrap::None);
let mut project_subscriptions = Vec::new();
if mode == EditorMode::Full && buffer.read(cx).is_singleton() {
if mode == EditorMode::Full {
if let Some(project) = project.as_ref() {
project_subscriptions.push(cx.observe(project, |_, _, cx| {
cx.emit(Event::TitleChanged);
}));
if buffer.read(cx).is_singleton() {
project_subscriptions.push(cx.observe(project, |_, _, cx| {
cx.emit(Event::TitleChanged);
}));
}
project_subscriptions.push(cx.subscribe(project, |editor, _, event, cx| {
if let project::Event::RefreshInlays = event {
editor.refresh_inlays(cx);
editor.refresh_inlays(InlayRefreshReason::Regular, cx);
};
}));
}
@ -1353,8 +1352,8 @@ impl Editor {
hover_state: Default::default(),
link_go_to_definition_state: Default::default(),
copilot_state: Default::default(),
// TODO kb has to live between editors
inlay_cache: InlayCache::default(),
// TODO kb has to live between editor reopens
inlay_cache: InlayCache::new(settings::get::<EditorSettings>(cx).inlay_hints),
gutter_hovered: false,
_subscriptions: vec![
cx.observe(&buffer, Self::on_buffer_changed),
@ -1379,7 +1378,7 @@ impl Editor {
}
this.report_editor_event("open", None, cx);
this.refresh_inlays(cx);
this.refresh_inlays(InlayRefreshReason::Regular, cx);
this
}
@ -2591,13 +2590,12 @@ impl Editor {
}
}
fn refresh_inlays(&mut self, cx: &mut ViewContext<Self>) {
fn refresh_inlays(&mut self, reason: InlayRefreshReason, cx: &mut ViewContext<Self>) {
if self.mode != EditorMode::Full {
return;
}
let inlay_hint_settings = settings::get::<EditorSettings>(cx).inlay_hints;
if !inlay_hint_settings.enabled {
if !settings::get::<EditorSettings>(cx).inlay_hints.enabled {
let to_remove = self.inlay_cache.clear();
self.display_map.update(cx, |display_map, cx| {
display_map.splice_inlays(to_remove, Vec::new(), cx);
@ -2605,151 +2603,63 @@ impl Editor {
return;
}
struct InlayRequestKey {
buffer_path: PathBuf,
buffer_version: Global,
excerpt_id: ExcerptId,
}
let multi_buffer = self.buffer();
let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
let inlay_fetch_tasks = multi_buffer_snapshot
.excerpts()
.filter_map(|(excerpt_id, buffer_snapshot, excerpt_range)| {
let buffer_path = buffer_snapshot.resolve_file_path(cx, true)?;
let buffer_id = buffer_snapshot.remote_id();
let buffer_version = buffer_snapshot.version().clone();
let buffer_handle = multi_buffer.read(cx).buffer(buffer_id);
let inlays_up_to_date =
self.inlay_cache
.inlays_up_to_date(&buffer_path, &buffer_version, excerpt_id);
let key = InlayRequestKey {
buffer_path,
buffer_version,
excerpt_id,
};
// TODO kb split this into 2 different steps:
// 1. cache population
// 2. cache querying + hint filters on top (needs to store previous filter settings)
let task = cx.spawn(|editor, mut cx| async move {
if inlays_up_to_date {
anyhow::Ok((key, None))
} else {
let Some(buffer_handle) = buffer_handle else { return Ok((key, Some(Vec::new()))) };
let max_buffer_offset = cx.read(|cx| buffer_handle.read(cx).len());
let excerpt_range = excerpt_range.context;
let query_start = excerpt_range.start.offset;
let query_end = excerpt_range.end.offset.min(max_buffer_offset);
let task = editor
.update(&mut cx, |editor, cx| {
editor.project.as_ref().map(|project| {
project.update(cx, |project, cx| {
project.query_inlay_hints_for_buffer(
buffer_handle,
query_start..query_end,
cx,
)
})
})
})
.context("inlays fecth task spawn")?;
Ok((key, match task {
Some(task) => {
match task.await.context("inlays for buffer task")? {
Some(mut new_inlays) => {
let mut allowed_inlay_hint_types = Vec::new();
if inlay_hint_settings.show_type_hints {
allowed_inlay_hint_types.push(Some(InlayHintKind::Type));
}
if inlay_hint_settings.show_parameter_hints {
allowed_inlay_hint_types.push(Some(InlayHintKind::Parameter));
}
if inlay_hint_settings.show_other_hints {
allowed_inlay_hint_types.push(None);
}
new_inlays.retain(|inlay| {
let inlay_offset = inlay.position.offset;
allowed_inlay_hint_types.contains(&inlay.kind)
&& query_start <= inlay_offset && inlay_offset <= query_end
});
Some(new_inlays)
},
None => None,
}
},
None => Some(Vec::new()),
}))
}
});
Some(task)
})
.collect::<Vec<_>>();
cx.spawn(|editor, mut cx| async move {
let mut inlay_updates: HashMap<
PathBuf,
(
Global,
HashMap<ExcerptId, Option<OrderedByAnchorOffset<InlayHint>>>,
),
> = HashMap::default();
let multi_buffer_snapshot =
editor.read_with(&cx, |editor, cx| editor.buffer().read(cx).snapshot(cx))?;
for task_result in futures::future::join_all(inlay_fetch_tasks).await {
match task_result {
Ok((request_key, response_inlays)) => {
let inlays_per_excerpt = HashMap::from_iter([(
request_key.excerpt_id,
response_inlays.map(|excerpt_inlays| {
excerpt_inlays.into_iter().fold(
OrderedByAnchorOffset::default(),
|mut ordered_inlays, inlay| {
let anchor = multi_buffer_snapshot.anchor_in_excerpt(
request_key.excerpt_id,
inlay.position,
);
ordered_inlays.add(anchor, inlay);
ordered_inlays
},
)
}),
)]);
match inlay_updates.entry(request_key.buffer_path) {
hash_map::Entry::Occupied(mut o) => {
o.get_mut().1.extend(inlays_per_excerpt);
}
hash_map::Entry::Vacant(v) => {
v.insert((request_key.buffer_version, inlays_per_excerpt));
}
}
}
Err(e) => error!("Failed to update inlays for buffer: {e:#}"),
}
}
if !inlay_updates.is_empty() {
match reason {
InlayRefreshReason::Settings(new_settings) => {
let InlaysUpdate {
to_remove,
to_insert,
} = editor.update(&mut cx, |editor, _| {
dbg!(editor.inlay_cache.update_inlays(inlay_updates))
})?;
editor.update(&mut cx, |editor, cx| {
editor.display_map.update(cx, |display_map, cx| {
display_map.splice_inlays(to_remove, to_insert, cx);
});
})?;
} = self.inlay_cache.apply_settings(new_settings);
self.display_map.update(cx, |display_map, cx| {
display_map.splice_inlays(to_remove, to_insert, cx);
});
}
InlayRefreshReason::Regular => {
let buffer_handle = self.buffer().clone();
let inlay_fetch_ranges = buffer_handle
.read(cx)
.snapshot(cx)
.excerpts()
.filter_map(|(excerpt_id, buffer_snapshot, excerpt_range)| {
let buffer_path = buffer_snapshot.resolve_file_path(cx, true)?;
let buffer_id = buffer_snapshot.remote_id();
let buffer_version = buffer_snapshot.version().clone();
let max_buffer_offset = buffer_snapshot.len();
let excerpt_range = excerpt_range.context;
Some(QueryInlaysRange {
buffer_path,
buffer_id,
buffer_version,
excerpt_id,
excerpt_offset_range: excerpt_range.start.offset
..excerpt_range.end.offset.min(max_buffer_offset),
})
})
.collect::<Vec<_>>();
anyhow::Ok(())
})
.detach_and_log_err(cx);
cx.spawn(|editor, mut cx| async move {
let InlaysUpdate {
to_remove,
to_insert,
} = editor
.update(&mut cx, |editor, cx| {
editor.inlay_cache.fetch_inlays(
buffer_handle,
inlay_fetch_ranges.into_iter(),
cx,
)
})?
.await
.context("inlay cache hint fetch")?;
editor.update(&mut cx, |editor, cx| {
editor.display_map.update(cx, |display_map, cx| {
display_map.splice_inlays(to_remove, to_insert, cx);
});
})
})
.detach_and_log_err(cx);
}
}
}
fn trigger_on_type_formatting(
@ -5687,6 +5597,7 @@ impl Editor {
}
}
// TODO: Handle selections that cross excerpts
// TODO: Handle selections that cross excerpts
for selection in &mut selections {
let start_column = snapshot.indent_size_for_line(selection.start.row).len;
@ -7332,7 +7243,7 @@ impl Editor {
};
if refresh_inlay_hints {
self.refresh_inlays(cx);
self.refresh_inlays(InlayRefreshReason::Regular, cx);
}
}
@ -7342,7 +7253,10 @@ impl Editor {
fn settings_changed(&mut self, cx: &mut ViewContext<Self>) {
self.refresh_copilot_suggestions(true, cx);
self.refresh_inlays(cx);
self.refresh_inlays(
InlayRefreshReason::Settings(settings::get::<EditorSettings>(cx).inlay_hints),
cx,
);
}
pub fn set_searchable(&mut self, searchable: bool) {

248
crates/editor/src/inlay_cache.rs
View File

@ -1,18 +1,29 @@
use std::{
cmp,
ops::Range,
path::{Path, PathBuf},
};
use crate::{Anchor, ExcerptId};
use crate::{editor_settings, Anchor, Editor, ExcerptId, MultiBuffer};
use anyhow::Context;
use clock::{Global, Local};
use project::InlayHint;
use gpui::{ModelHandle, Task, ViewContext};
use log::error;
use project::{InlayHint, InlayHintKind};
use util::post_inc;
use collections::{BTreeMap, HashMap};
use collections::{hash_map, BTreeMap, HashMap, HashSet};
#[derive(Clone, Debug, Default)]
#[derive(Debug, Copy, Clone)]
pub enum InlayRefreshReason {
Settings(editor_settings::InlayHints),
Regular,
}
#[derive(Debug, Clone, Default)]
pub struct InlayCache {
inlays_per_buffer: HashMap<PathBuf, BufferInlays>,
allowed_hint_kinds: HashSet<Option<InlayHintKind>>,
next_inlay_id: usize,
}
@ -37,6 +48,10 @@ impl<T> OrderedByAnchorOffset<T> {
fn into_ordered_elements(self) -> impl Iterator<Item = (Anchor, T)> {
self.0.into_values()
}
fn ordered_elements(&self) -> impl Iterator<Item = &(Anchor, T)> {
self.0.values()
}
}
impl<T> Default for OrderedByAnchorOffset<T> {
@ -54,14 +69,150 @@ struct BufferInlays {
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct InlayId(pub usize);
#[derive(Debug)]
#[derive(Debug, Default)]
pub struct InlaysUpdate {
pub to_remove: Vec<InlayId>,
pub to_insert: Vec<(InlayId, Anchor, InlayHint)>,
}
impl InlaysUpdate {
fn merge(&mut self, other: Self) {
let mut new_to_remove = other.to_remove.iter().copied().collect::<HashSet<_>>();
self.to_insert
.retain(|(inlay_id, _, _)| !new_to_remove.remove(&inlay_id));
self.to_remove.extend(new_to_remove);
self.to_insert
.extend(other.to_insert.into_iter().filter(|(inlay_id, _, _)| {
!self
.to_remove
.iter()
.any(|removed_inlay_id| removed_inlay_id == inlay_id)
}));
}
}
pub struct QueryInlaysRange {
pub buffer_id: u64,
pub buffer_path: PathBuf,
pub buffer_version: Global,
pub excerpt_id: ExcerptId,
pub excerpt_offset_range: Range<usize>,
}
impl InlayCache {
pub fn inlays_up_to_date(
pub fn new(inlay_hint_settings: editor_settings::InlayHints) -> Self {
Self {
inlays_per_buffer: HashMap::default(),
allowed_hint_kinds: allowed_inlay_hint_types(inlay_hint_settings),
next_inlay_id: 0,
}
}
pub fn fetch_inlays(
&mut self,
multi_buffer: ModelHandle<MultiBuffer>,
inlay_fetch_ranges: impl Iterator<Item = QueryInlaysRange>,
cx: &mut ViewContext<Editor>,
) -> Task<anyhow::Result<InlaysUpdate>> {
let mut inlay_fetch_tasks = Vec::new();
for inlay_fetch_range in inlay_fetch_ranges {
let inlays_up_to_date = self.inlays_up_to_date(
&inlay_fetch_range.buffer_path,
&inlay_fetch_range.buffer_version,
inlay_fetch_range.excerpt_id,
);
let task_multi_buffer = multi_buffer.clone();
let task = cx.spawn(|editor, mut cx| async move {
if inlays_up_to_date {
anyhow::Ok((inlay_fetch_range, None))
} else {
let Some(buffer_handle) = cx.read(|cx| task_multi_buffer.read(cx).buffer(inlay_fetch_range.buffer_id))
else { return Ok((inlay_fetch_range, Some(Vec::new()))) };
let task = editor
.update(&mut cx, |editor, cx| {
let max_buffer_offset = buffer_handle.read(cx).len();
let excerpt_offset_range = &inlay_fetch_range.excerpt_offset_range;
editor.project.as_ref().map(|project| {
project.update(cx, |project, cx| {
project.query_inlay_hints_for_buffer(
buffer_handle,
excerpt_offset_range.start..excerpt_offset_range.end.min(max_buffer_offset),
cx,
)
})
})
})
.context("inlays fecth task spawn")?;
Ok((inlay_fetch_range, match task {
Some(task) => task.await.context("inlays for buffer task")?,
None => Some(Vec::new()),
}))
}
});
inlay_fetch_tasks.push(task);
}
let final_task = cx.spawn(|editor, mut cx| async move {
let mut inlay_updates: HashMap<
PathBuf,
(
Global,
HashMap<ExcerptId, Option<(Range<usize>, OrderedByAnchorOffset<InlayHint>)>>,
),
> = HashMap::default();
let multi_buffer_snapshot =
editor.read_with(&cx, |editor, cx| editor.buffer().read(cx).snapshot(cx))?;
for task_result in futures::future::join_all(inlay_fetch_tasks).await {
match task_result {
Ok((request_key, response_inlays)) => {
let inlays_per_excerpt = HashMap::from_iter([(
request_key.excerpt_id,
response_inlays
.map(|excerpt_inlays| {
excerpt_inlays.into_iter().fold(
OrderedByAnchorOffset::default(),
|mut ordered_inlays, inlay| {
let anchor = multi_buffer_snapshot.anchor_in_excerpt(
request_key.excerpt_id,
inlay.position,
);
ordered_inlays.add(anchor, inlay);
ordered_inlays
},
)
})
.map(|inlays| (request_key.excerpt_offset_range, inlays)),
)]);
match inlay_updates.entry(request_key.buffer_path) {
hash_map::Entry::Occupied(mut o) => {
o.get_mut().1.extend(inlays_per_excerpt);
}
hash_map::Entry::Vacant(v) => {
v.insert((request_key.buffer_version, inlays_per_excerpt));
}
}
}
Err(e) => error!("Failed to update inlays for buffer: {e:#}"),
}
}
let updates = if !inlay_updates.is_empty() {
let inlays_update = editor.update(&mut cx, |editor, _| {
editor.inlay_cache.apply_fetch_inlays(inlay_updates)
})?;
inlays_update
} else {
InlaysUpdate::default()
};
anyhow::Ok(updates)
});
final_task
}
fn inlays_up_to_date(
&self,
buffer_path: &Path,
buffer_version: &Global,
@ -69,17 +220,17 @@ impl InlayCache {
) -> bool {
let Some(buffer_inlays) = self.inlays_per_buffer.get(buffer_path) else { return false };
let buffer_up_to_date = buffer_version == &buffer_inlays.buffer_version
|| buffer_inlays.buffer_version.changed_since(buffer_version);
|| buffer_inlays.buffer_version.changed_since(&buffer_version);
buffer_up_to_date && buffer_inlays.inlays_per_excerpts.contains_key(&excerpt_id)
}
pub fn update_inlays(
fn apply_fetch_inlays(
&mut self,
inlay_updates: HashMap<
fetched_inlays: HashMap<
PathBuf,
(
Global,
HashMap<ExcerptId, Option<OrderedByAnchorOffset<InlayHint>>>,
HashMap<ExcerptId, Option<(Range<usize>, OrderedByAnchorOffset<InlayHint>)>>,
),
>,
) -> InlaysUpdate {
@ -87,10 +238,17 @@ impl InlayCache {
let mut to_remove = Vec::new();
let mut to_insert = Vec::new();
for (buffer_path, (buffer_version, new_buffer_inlays)) in inlay_updates {
for (buffer_path, (buffer_version, new_buffer_inlays)) in fetched_inlays {
match old_inlays.remove(&buffer_path) {
Some(mut old_buffer_inlays) => {
for (excerpt_id, new_excerpt_inlays) in new_buffer_inlays {
let (_, mut new_excerpt_inlays) = match new_excerpt_inlays {
Some((excerpt_offset_range, new_inlays)) => (
excerpt_offset_range,
new_inlays.into_ordered_elements().fuse().peekable(),
),
None => continue,
};
if self.inlays_up_to_date(&buffer_path, &buffer_version, excerpt_id) {
continue;
}
@ -99,12 +257,7 @@ impl InlayCache {
.inlays_per_buffer
.get_mut(&buffer_path)
.expect("element expected: `old_inlays.remove` returned `Some`");
let mut new_excerpt_inlays = match new_excerpt_inlays {
Some(new_inlays) => {
new_inlays.into_ordered_elements().fuse().peekable()
}
None => continue,
};
if old_buffer_inlays
.inlays_per_excerpts
.remove(&excerpt_id)
@ -192,7 +345,7 @@ impl InlayCache {
OrderedByAnchorOffset<(InlayId, InlayHint)>,
> = HashMap::default();
for (new_excerpt_id, new_ordered_inlays) in new_buffer_inlays {
if let Some(new_ordered_inlays) = new_ordered_inlays {
if let Some((_, new_ordered_inlays)) = new_ordered_inlays {
for (new_anchor, new_inlay) in
new_ordered_inlays.into_ordered_elements()
{
@ -230,6 +383,49 @@ impl InlayCache {
}
}
pub fn apply_settings(
&mut self,
inlay_hint_settings: editor_settings::InlayHints,
) -> InlaysUpdate {
let new_allowed_inlay_hint_types = allowed_inlay_hint_types(inlay_hint_settings);
let new_allowed_hint_kinds = new_allowed_inlay_hint_types
.difference(&self.allowed_hint_kinds)
.copied()
.collect::<HashSet<_>>();
let removed_hint_kinds = self
.allowed_hint_kinds
.difference(&new_allowed_inlay_hint_types)
.collect::<HashSet<_>>();
let mut to_remove = Vec::new();
let mut to_insert = Vec::new();
for (anchor, (inlay_id, inlay_hint)) in self
.inlays_per_buffer
.iter()
.map(|(_, buffer_inlays)| {
buffer_inlays
.inlays_per_excerpts
.iter()
.map(|(_, excerpt_inlays)| excerpt_inlays.ordered_elements())
.flatten()
})
.flatten()
{
if removed_hint_kinds.contains(&inlay_hint.kind) {
to_remove.push(*inlay_id);
} else if new_allowed_hint_kinds.contains(&inlay_hint.kind) {
to_insert.push((*inlay_id, *anchor, inlay_hint.to_owned()));
}
}
self.allowed_hint_kinds = new_allowed_hint_kinds;
InlaysUpdate {
to_remove,
to_insert,
}
}
pub fn clear(&mut self) -> Vec<InlayId> {
self.inlays_per_buffer
.drain()
@ -248,3 +444,19 @@ impl InlayCache {
.collect()
}
}
fn allowed_inlay_hint_types(
inlay_hint_settings: editor_settings::InlayHints,
) -> HashSet<Option<InlayHintKind>> {
let mut new_allowed_inlay_hint_types = HashSet::default();
if inlay_hint_settings.show_type_hints {
new_allowed_inlay_hint_types.insert(Some(InlayHintKind::Type));
}
if inlay_hint_settings.show_parameter_hints {
new_allowed_inlay_hint_types.insert(Some(InlayHintKind::Parameter));
}
if inlay_hint_settings.show_other_hints {
new_allowed_inlay_hint_types.insert(None);
}
new_allowed_inlay_hint_types
}

18
crates/project/src/project.rs
View File

@ -321,13 +321,13 @@ pub struct DiagnosticSummary {
pub warning_count: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Location {
pub buffer: ModelHandle<Buffer>,
pub range: Range<language::Anchor>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct InlayHint {
pub buffer_id: u64,
pub position: Anchor,
@ -338,7 +338,7 @@ pub struct InlayHint {
pub tooltip: Option<InlayHintTooltip>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum InlayHintKind {
Type,
Parameter,
@ -370,32 +370,32 @@ impl InlayHint {
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum InlayHintLabel {
String(String),
LabelParts(Vec<InlayHintLabelPart>),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct InlayHintLabelPart {
pub value: String,
pub tooltip: Option<InlayHintLabelPartTooltip>,
pub location: Option<Location>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum InlayHintTooltip {
String(String),
MarkupContent(MarkupContent),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum InlayHintLabelPartTooltip {
String(String),
MarkupContent(MarkupContent),
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct MarkupContent {
pub kind: String,
pub value: String,
@ -4975,7 +4975,7 @@ impl Project {
lsp_request,
response,
project,
buffer_handle,
buffer_handle.clone(),
cx,
)
.await;