Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-28 14:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove hover inlay tooltips, replace them with location links

Browse source
This commit is contained in:
Lukas Wirth 2023-01-14 12:19:29 +01:00
parent aafb0f1f8d
commit 60075a6625
15 changed files with 187 additions and 380 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

88
crates/ide/src/inlay_hints.rs
View file

@ -11,7 +11,7 @@ use smallvec::{smallvec, SmallVec};
use stdx::never;
use syntax::{
ast::{self, AstNode},
match_ast, NodeOrToken, SyntaxNode, TextRange, TextSize,
match_ast, NodeOrToken, SyntaxNode, TextRange,
};
use crate::{navigation_target::TryToNav, FileId};
@ -110,16 +110,21 @@ pub struct InlayHint {
pub kind: InlayKind,
/// The actual label to show in the inlay hint.
pub label: InlayHintLabel,
/// The tooltip to show when hovering over the inlay hint, this may invoke other actions like
/// hover requests to show.
pub tooltip: Option<InlayTooltip>,
}
impl InlayHint {
fn closing_paren(range: TextRange) -> InlayHint {
InlayHint { range, kind: InlayKind::ClosingParenthesis, label: InlayHintLabel::from(")") }
}
fn opening_paren(range: TextRange) -> InlayHint {
InlayHint { range, kind: InlayKind::OpeningParenthesis, label: InlayHintLabel::from("(") }
}
}
#[derive(Debug)]
pub enum InlayTooltip {
String(String),
HoverRanged(FileId, TextRange),
HoverOffset(FileId, TextSize),
Markdown(String),
}
#[derive(Default)]
@ -128,37 +133,59 @@ pub struct InlayHintLabel {
}
impl InlayHintLabel {
pub fn as_simple_str(&self) -> Option<&str> {
match &*self.parts {
[part] => part.as_simple_str(),
_ => None,
pub fn simple(
s: impl Into<String>,
tooltip: Option<InlayTooltip>,
linked_location: Option<FileRange>,
) -> InlayHintLabel {
InlayHintLabel {
parts: smallvec![InlayHintLabelPart { text: s.into(), linked_location, tooltip }],
}
}
pub fn prepend_str(&mut self, s: &str) {
match &mut *self.parts {
[part, ..] if part.as_simple_str().is_some() => part.text = format!("{s}{}", part.text),
_ => self.parts.insert(0, InlayHintLabelPart { text: s.into(), linked_location: None }),
[InlayHintLabelPart { text, linked_location: None, tooltip: None }, ..] => {
text.insert_str(0, s)
}
_ => self.parts.insert(
0,
InlayHintLabelPart { text: s.into(), linked_location: None, tooltip: None },
),
}
}
pub fn append_str(&mut self, s: &str) {
match &mut *self.parts {
[.., part] if part.as_simple_str().is_some() => part.text.push_str(s),
_ => self.parts.push(InlayHintLabelPart { text: s.into(), linked_location: None }),
[.., InlayHintLabelPart { text, linked_location: None, tooltip: None }] => {
text.push_str(s)
}
_ => self.parts.push(InlayHintLabelPart {
text: s.into(),
linked_location: None,
tooltip: None,
}),
}
}
}
impl From<String> for InlayHintLabel {
fn from(s: String) -> Self {
Self { parts: smallvec![InlayHintLabelPart { text: s, linked_location: None }] }
Self {
parts: smallvec![InlayHintLabelPart { text: s, linked_location: None, tooltip: None }],
}
}
}
impl From<&str> for InlayHintLabel {
fn from(s: &str) -> Self {
Self { parts: smallvec![InlayHintLabelPart { text: s.into(), linked_location: None }] }
Self {
parts: smallvec![InlayHintLabelPart {
text: s.into(),
linked_location: None,
tooltip: None
}],
}
}
}
@ -182,25 +209,25 @@ pub struct InlayHintLabelPart {
/// When setting this, no tooltip must be set on the containing hint, or VS Code will display
/// them both.
pub linked_location: Option<FileRange>,
}
impl InlayHintLabelPart {
pub fn as_simple_str(&self) -> Option<&str> {
match self {
Self { text, linked_location: None } => Some(text),
_ => None,
}
}
/// The tooltip to show when hovering over the inlay hint, this may invoke other actions like
/// hover requests to show.
pub tooltip: Option<InlayTooltip>,
}
impl fmt::Debug for InlayHintLabelPart {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.as_simple_str() {
Some(string) => string.fmt(f),
None => f
match self {
Self { text, linked_location: None, tooltip: None } => text.fmt(f),
Self { text, linked_location, tooltip } => f
.debug_struct("InlayHintLabelPart")
.field("text", &self.text)
.field("linked_location", &self.linked_location)
.field("text", text)
.field("linked_location", linked_location)
.field(
"tooltip",
&tooltip.as_ref().map_or("", |it| match it {
InlayTooltip::String(it) | InlayTooltip::Markdown(it) => it,
}),
)
.finish(),
}
}
@ -249,6 +276,7 @@ impl InlayHintLabelBuilder<'_> {
self.result.parts.push(InlayHintLabelPart {
text: take(&mut self.last_part),
linked_location: self.location.take(),
tooltip: None,
});
}

43
crates/ide/src/inlay_hints/adjustment.rs
View file

@ -44,27 +44,12 @@ pub(super) fn hints(
mode_and_needs_parens_for_adjustment_hints(expr, config.adjustment_hints_mode);
if needs_outer_parens {
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::OpeningParenthesis,
label: "(".into(),
tooltip: None,
});
acc.push(InlayHint::opening_paren(expr.syntax().text_range()));
}
if postfix && needs_inner_parens {
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::OpeningParenthesis,
label: "(".into(),
tooltip: None,
});
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::ClosingParenthesis,
label: ")".into(),
tooltip: None,
});
acc.push(InlayHint::opening_paren(expr.syntax().text_range()));
acc.push(InlayHint::closing_paren(expr.syntax().text_range()));
}
let (mut tmp0, mut tmp1);
@ -118,30 +103,14 @@ pub(super) fn hints(
InlayKind::AdjustmentHint
},
label: if postfix { format!(".{}", text.trim_end()).into() } else { text.into() },
tooltip: None,
});
}
if !postfix && needs_inner_parens {
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::OpeningParenthesis,
label: "(".into(),
tooltip: None,
});
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::ClosingParenthesis,
label: ")".into(),
tooltip: None,
});
acc.push(InlayHint::opening_paren(expr.syntax().text_range()));
acc.push(InlayHint::closing_paren(expr.syntax().text_range()));
}
if needs_outer_parens {
acc.push(InlayHint {
range: expr.syntax().text_range(),
kind: InlayKind::ClosingParenthesis,
label: ")".into(),
tooltip: None,
});
acc.push(InlayHint::closing_paren(expr.syntax().text_range()));
}
Some(())
}

28
crates/ide/src/inlay_hints/bind_pat.rs
View file

@ -12,9 +12,7 @@ use syntax::{
match_ast,
};
use crate::{
inlay_hints::closure_has_block_body, InlayHint, InlayHintsConfig, InlayKind, InlayTooltip,
};
use crate::{inlay_hints::closure_has_block_body, InlayHint, InlayHintsConfig, InlayKind};
use super::label_of_ty;
@ -22,7 +20,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig,
file_id: FileId,
_file_id: FileId,
pat: &ast::IdentPat,
) -> Option<()> {
if !config.type_hints {
@ -52,10 +50,6 @@ pub(super) fn hints(
},
kind: InlayKind::TypeHint,
label,
tooltip: pat
.name()
.map(|it| it.syntax().text_range())
.map(|it| InlayTooltip::HoverRanged(file_id, it)),
});
Some(())
@ -326,14 +320,6 @@ fn main(a: SliceIter<'_, Container>) {
label: [
"impl Iterator<Item = impl Iterator<Item = &&str>>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
484..554,
),
),
},
InlayHint {
range: 484..485,
@ -350,6 +336,7 @@ fn main(a: SliceIter<'_, Container>) {
range: 289..298,
},
),
tooltip: "",
},
"<",
InlayHintLabelPart {
@ -362,17 +349,10 @@ fn main(a: SliceIter<'_, Container>) {
range: 238..247,
},
),
tooltip: "",
},
">",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
484..485,
),
),
},
]
"#]],

18
crates/ide/src/inlay_hints/binding_mode.rs
View file

@ -7,7 +7,7 @@ use ide_db::RootDatabase;
use syntax::ast::{self, AstNode};
use crate::{InlayHint, InlayHintsConfig, InlayKind, InlayTooltip};
use crate::{InlayHint, InlayHintsConfig, InlayKind};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -44,7 +44,6 @@ pub(super) fn hints(
range,
kind: InlayKind::BindingModeHint,
label: r.to_string().into(),
tooltip: Some(InlayTooltip::String("Inferred binding mode".into())),
});
});
match pat {
@ -59,22 +58,11 @@ pub(super) fn hints(
range: pat.syntax().text_range(),
kind: InlayKind::BindingModeHint,
label: bm.to_string().into(),
tooltip: Some(InlayTooltip::String("Inferred binding mode".into())),
});
}
ast::Pat::OrPat(pat) if !pattern_adjustments.is_empty() && outer_paren_pat.is_none() => {
acc.push(InlayHint {
range: pat.syntax().text_range(),
kind: InlayKind::OpeningParenthesis,
label: "(".into(),
tooltip: None,
});
acc.push(InlayHint {
range: pat.syntax().text_range(),
kind: InlayKind::ClosingParenthesis,
label: ")".into(),
tooltip: None,
});
acc.push(InlayHint::opening_paren(pat.syntax().text_range()));
acc.push(InlayHint::closing_paren(pat.syntax().text_range()));
}
_ => (),
}

158
crates/ide/src/inlay_hints/chaining.rs
View file

@ -5,7 +5,7 @@ use syntax::{
Direction, NodeOrToken, SyntaxKind, T,
};
use crate::{FileId, InlayHint, InlayHintsConfig, InlayKind, InlayTooltip};
use crate::{FileId, InlayHint, InlayHintsConfig, InlayKind};
use super::label_of_ty;
@ -13,7 +13,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig,
file_id: FileId,
_file_id: FileId,
expr: &ast::Expr,
) -> Option<()> {
if !config.chaining_hints {
@ -61,7 +61,6 @@ pub(super) fn hints(
range: expr.syntax().text_range(),
kind: InlayKind::ChainingHint,
label: label_of_ty(famous_defs, config, ty)?,
tooltip: Some(InlayTooltip::HoverRanged(file_id, expr.syntax().text_range())),
});
}
}
@ -124,17 +123,10 @@ fn main() {
range: 63..64,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
147..172,
),
),
},
InlayHint {
range: 147..154,
@ -151,17 +143,10 @@ fn main() {
range: 7..8,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
147..154,
),
),
},
]
"#]],
@ -214,14 +199,6 @@ fn main() {
label: [
"C",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
143..190,
),
),
},
InlayHint {
range: 143..179,
@ -229,14 +206,6 @@ fn main() {
label: [
"B",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
143..179,
),
),
},
]
"#]],
@ -282,17 +251,10 @@ fn main() {
range: 51..52,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
143..190,
),
),
},
InlayHint {
range: 143..179,
@ -309,17 +271,10 @@ fn main() {
range: 29..30,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
143..179,
),
),
},
]
"#]],
@ -366,6 +321,7 @@ fn main() {
range: 23..24,
},
),
tooltip: "",
},
"<",
InlayHintLabelPart {
@ -378,17 +334,10 @@ fn main() {
range: 55..56,
},
),
tooltip: "",
},
"<i32, bool>>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
246..283,
),
),
},
InlayHint {
range: 246..265,
@ -405,6 +354,7 @@ fn main() {
range: 7..8,
},
),
tooltip: "",
},
"<",
InlayHintLabelPart {
@ -417,17 +367,10 @@ fn main() {
range: 55..56,
},
),
tooltip: "",
},
"<i32, bool>>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
246..265,
),
),
},
]
"#]],
@ -467,14 +410,6 @@ fn main() {
label: [
"impl Iterator<Item = ()>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
174..241,
),
),
},
InlayHint {
range: 174..224,
@ -482,14 +417,6 @@ fn main() {
label: [
"impl Iterator<Item = ()>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
174..224,
),
),
},
InlayHint {
range: 174..206,
@ -497,14 +424,6 @@ fn main() {
label: [
"impl Iterator<Item = ()>",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
174..206,
),
),
},
InlayHint {
range: 174..189,
@ -521,17 +440,10 @@ fn main() {
range: 24..30,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
174..189,
),
),
},
]
"#]],
@ -577,17 +489,10 @@ fn main() {
range: 7..13,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
124..130,
),
),
},
InlayHint {
range: 145..185,
@ -604,17 +509,10 @@ fn main() {
range: 7..13,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
145..185,
),
),
},
InlayHint {
range: 145..168,
@ -631,32 +529,28 @@ fn main() {
range: 7..13,
},
),
tooltip: "",
},
"",
],
tooltip: Some(
HoverRanged(
FileId(
0,
),
145..168,
),
),
},
InlayHint {
range: 222..228,
kind: ParameterHint,
label: [
"self",
],
tooltip: Some(
HoverOffset(
FileId(
0,
InlayHintLabelPart {
text: "self",
linked_location: Some(
FileRange {
file_id: FileId(
0,
),
range: 42..46,
},
),
42,
),
),
tooltip: "",
},
],
},
]
"#]],

10
crates/ide/src/inlay_hints/closing_brace.rs
View file

@ -5,15 +5,12 @@
//! ```
use hir::{HirDisplay, Semantics};
use ide_db::{base_db::FileRange, RootDatabase};
use smallvec::smallvec;
use syntax::{
ast::{self, AstNode, HasName},
match_ast, SyntaxKind, SyntaxNode, T,
};
use crate::{
inlay_hints::InlayHintLabelPart, FileId, InlayHint, InlayHintLabel, InlayHintsConfig, InlayKind,
};
use crate::{FileId, InlayHint, InlayHintLabel, InlayHintsConfig, InlayKind};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -117,10 +114,7 @@ pub(super) fn hints(
acc.push(InlayHint {
range: closing_token.text_range(),
kind: InlayKind::ClosingBraceHint,
label: InlayHintLabel {
parts: smallvec![InlayHintLabelPart { text: label, linked_location }],
},
tooltip: None, // provided by label part location
label: InlayHintLabel::simple(label, None, linked_location),
});
None

5
crates/ide/src/inlay_hints/closure_ret.rs
View file

@ -4,7 +4,7 @@ use syntax::ast::{self, AstNode};
use crate::{
inlay_hints::closure_has_block_body, ClosureReturnTypeHints, InlayHint, InlayHintsConfig,
InlayKind, InlayTooltip,
InlayKind,
};
use super::label_of_ty;
@ -13,7 +13,7 @@ pub(super) fn hints(
acc: &mut Vec<InlayHint>,
famous_defs @ FamousDefs(sema, _): &FamousDefs<'_, '_>,
config: &InlayHintsConfig,
file_id: FileId,
_file_id: FileId,
closure: ast::ClosureExpr,
) -> Option<()> {
if config.closure_return_type_hints == ClosureReturnTypeHints::Never {
@ -43,7 +43,6 @@ pub(super) fn hints(
range: param_list.syntax().text_range(),
kind: InlayKind::ClosureReturnTypeHint,
label: label_of_ty(famous_defs, config, ty)?,
tooltip: Some(InlayTooltip::HoverRanged(file_id, param_list.syntax().text_range())),
});
Some(())
}

23
crates/ide/src/inlay_hints/discriminant.rs
View file

@ -7,7 +7,9 @@
use ide_db::{base_db::FileId, famous_defs::FamousDefs};
use syntax::ast::{self, AstNode, HasName};
use crate::{DiscriminantHints, InlayHint, InlayHintsConfig, InlayKind, InlayTooltip};
use crate::{
DiscriminantHints, InlayHint, InlayHintLabel, InlayHintsConfig, InlayKind, InlayTooltip,
};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -42,14 +44,17 @@ pub(super) fn hints(
None => name.syntax().text_range(),
},
kind: InlayKind::DiscriminantHint,
label: match &d {
Ok(v) => format!("{}", v).into(),
Err(_) => "?".into(),
},
tooltip: Some(InlayTooltip::String(match &d {
Ok(_) => "enum variant discriminant".into(),
Err(e) => format!("{e:?}").into(),
})),
label: InlayHintLabel::simple(
match &d {
Ok(v) => format!("{}", v),
Err(_) => "?".into(),
},
Some(InlayTooltip::String(match &d {
Ok(_) => "enum variant discriminant".into(),
Err(e) => format!("{e:?}").into(),
})),
None,
),
});
Some(())

5
crates/ide/src/inlay_hints/fn_lifetime_fn.rs
View file

@ -10,7 +10,7 @@ use syntax::{
SyntaxToken,
};
use crate::{InlayHint, InlayHintsConfig, InlayKind, InlayTooltip, LifetimeElisionHints};
use crate::{InlayHint, InlayHintsConfig, InlayKind, LifetimeElisionHints};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -25,7 +25,6 @@ pub(super) fn hints(
range: t.text_range(),
kind: InlayKind::LifetimeHint,
label: label.into(),
tooltip: Some(InlayTooltip::String("Elided lifetime".into())),
};
let param_list = func.param_list()?;
@ -190,14 +189,12 @@ pub(super) fn hints(
if is_empty { "" } else { ", " }
)
.into(),
tooltip: Some(InlayTooltip::String("Elided lifetimes".into())),
});
}
(None, allocated_lifetimes) => acc.push(InlayHint {
range: func.name()?.syntax().text_range(),
kind: InlayKind::GenericParamListHint,
label: format!("<{}>", allocated_lifetimes.iter().format(", "),).into(),
tooltip: Some(InlayTooltip::String("Elided lifetimes".into())),
}),
}
Some(())

3
crates/ide/src/inlay_hints/implicit_static.rs
View file

@ -8,7 +8,7 @@ use syntax::{
SyntaxKind,
};
use crate::{InlayHint, InlayHintsConfig, InlayKind, InlayTooltip, LifetimeElisionHints};
use crate::{InlayHint, InlayHintsConfig, InlayKind, LifetimeElisionHints};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -34,7 +34,6 @@ pub(super) fn hints(
range: t.text_range(),
kind: InlayKind::LifetimeHint,
label: "'static".to_owned().into(),
tooltip: Some(InlayTooltip::String("Elided static lifetime".into())),
});
}
}

9
crates/ide/src/inlay_hints/param_name.rs
View file

@ -10,7 +10,7 @@ use ide_db::{base_db::FileRange, RootDatabase};
use stdx::to_lower_snake_case;
use syntax::ast::{self, AstNode, HasArgList, HasName, UnaryOp};
use crate::{InlayHint, InlayHintsConfig, InlayKind, InlayTooltip};
use crate::{InlayHint, InlayHintLabel, InlayHintsConfig, InlayKind};
pub(super) fn hints(
acc: &mut Vec<InlayHint>,
@ -43,12 +43,12 @@ pub(super) fn hints(
!should_hide_param_name_hint(sema, &callable, param_name, arg)
})
.map(|(param, param_name, _, FileRange { range, .. })| {
let mut tooltip = None;
let mut linked_location = None;
if let Some(name) = param {
if let hir::CallableKind::Function(f) = callable.kind() {
// assert the file is cached so we can map out of macros
if let Some(_) = sema.source(f) {
tooltip = sema.original_range_opt(name.syntax());
linked_location = sema.original_range_opt(name.syntax());
}
}
}
@ -56,8 +56,7 @@ pub(super) fn hints(
InlayHint {
range,
kind: InlayKind::ParameterHint,
label: param_name.into(),
tooltip: tooltip.map(|it| InlayTooltip::HoverOffset(it.file_id, it.range.start())),
label: InlayHintLabel::simple(param_name, None, linked_location),
}
});

3
crates/ide/src/lib.rs
View file

@ -82,7 +82,8 @@ pub use crate::{
hover::{HoverAction, HoverConfig, HoverDocFormat, HoverGotoTypeData, HoverResult},
inlay_hints::{
AdjustmentHints, AdjustmentHintsMode, ClosureReturnTypeHints, DiscriminantHints, InlayHint,
InlayHintLabel, InlayHintsConfig, InlayKind, InlayTooltip, LifetimeElisionHints,
InlayHintLabel, InlayHintLabelPart, InlayHintsConfig, InlayKind, InlayTooltip,
LifetimeElisionHints,
},
join_lines::JoinLinesConfig,
markup::Markup,

50
crates/rust-analyzer/src/handlers.rs
View file

@ -29,7 +29,6 @@ use project_model::{ManifestPath, ProjectWorkspace, TargetKind};
use serde_json::json;
use stdx::{format_to, never};
use syntax::{algo, ast, AstNode, TextRange, TextSize};
use tracing::error;
use vfs::AbsPathBuf;
use crate::{
@ -1360,55 +1359,10 @@ pub(crate) fn handle_inlay_hints(
}
pub(crate) fn handle_inlay_hints_resolve(
snap: GlobalStateSnapshot,
mut hint: InlayHint,
_snap: GlobalStateSnapshot,
hint: InlayHint,
) -> Result<InlayHint> {
let _p = profile::span("handle_inlay_hints_resolve");
let data = match hint.data.take() {
Some(it) => it,
None => return Ok(hint),
};
let resolve_data: lsp_ext::InlayHintResolveData = serde_json::from_value(data)?;
match snap.url_file_version(&resolve_data.text_document.uri) {
Some(version) if version == resolve_data.text_document.version => {}
Some(version) => {
error!(
"attempted inlayHints/resolve of '{}' at version {} while server version is {}",
resolve_data.text_document.uri, resolve_data.text_document.version, version,
);
return Ok(hint);
}
None => {
error!(
"attempted inlayHints/resolve of unknown file '{}' at version {}",
resolve_data.text_document.uri, resolve_data.text_document.version,
);
return Ok(hint);
}
}
let file_range = from_proto::file_range_uri(
&snap,
&resolve_data.text_document.uri,
match resolve_data.position {
PositionOrRange::Position(pos) => Range::new(pos, pos),
PositionOrRange::Range(range) => range,
},
)?;
let info = match snap.analysis.hover(&snap.config.hover(), file_range)? {
None => return Ok(hint),
Some(info) => info,
};
let markup_kind =
snap.config.hover().documentation.map_or(ide::HoverDocFormat::Markdown, |kind| kind);
// FIXME: hover actions?
hint.tooltip = Some(lsp_types::InlayHintTooltip::MarkupContent(to_proto::markup_content(
info.info.markup,
markup_kind,
)));
Ok(hint)
}

7
crates/rust-analyzer/src/lsp_ext.rs
View file

@ -3,11 +3,11 @@
use std::{collections::HashMap, path::PathBuf};
use lsp_types::request::Request;
use lsp_types::PositionEncodingKind;
use lsp_types::{
notification::Notification, CodeActionKind, DocumentOnTypeFormattingParams,
PartialResultParams, Position, Range, TextDocumentIdentifier, WorkDoneProgressParams,
};
use lsp_types::{PositionEncodingKind, VersionedTextDocumentIdentifier};
use serde::{Deserialize, Serialize};
pub enum AnalyzerStatus {}
@ -568,10 +568,7 @@ pub struct CompletionResolveData {
}
#[derive(Debug, Serialize, Deserialize)]
pub struct InlayHintResolveData {
pub text_document: VersionedTextDocumentIdentifier,
pub position: PositionOrRange,
}
pub struct InlayHintResolveData {}
#[derive(Debug, Serialize, Deserialize)]
pub struct CompletionImport {

117
crates/rust-analyzer/src/to_proto.rs
View file

@ -9,9 +9,9 @@ use ide::{
Annotation, AnnotationKind, Assist, AssistKind, Cancellable, CompletionItem,
CompletionItemKind, CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit,
Fold, FoldKind, Highlight, HlMod, HlOperator, HlPunct, HlRange, HlTag, Indel, InlayHint,
InlayHintLabel, InlayKind, Markup, NavigationTarget, ReferenceCategory, RenameError, Runnable,
Severity, SignatureHelp, SourceChange, StructureNodeKind, SymbolKind, TextEdit, TextRange,
TextSize,
InlayHintLabel, InlayHintLabelPart, InlayKind, Markup, NavigationTarget, ReferenceCategory,
RenameError, Runnable, Severity, SignatureHelp, SourceChange, StructureNodeKind, SymbolKind,
TextEdit, TextRange, TextSize,
};
use itertools::Itertools;
use serde_json::to_value;
@ -438,6 +438,8 @@ pub(crate) fn inlay_hint(
_ => {}
}
let (label, tooltip) = inlay_hint_label(snap, inlay_hint.label)?;
Ok(lsp_types::InlayHint {
position: match inlay_hint.kind {
// before annotated thing
@ -481,7 +483,9 @@ pub(crate) fn inlay_hint(
| InlayKind::TypeHint
| InlayKind::DiscriminantHint
| InlayKind::ClosingBraceHint => false,
InlayKind::BindingModeHint => inlay_hint.label.as_simple_str() != Some("&"),
InlayKind::BindingModeHint => {
matches!(&label, lsp_types::InlayHintLabel::String(s) if s != "&")
}
InlayKind::ParameterHint | InlayKind::LifetimeHint => true,
}),
kind: match inlay_hint.kind {
@ -500,68 +504,67 @@ pub(crate) fn inlay_hint(
| InlayKind::ClosingBraceHint => None,
},
text_edits: None,
data: (|| match inlay_hint.tooltip {
Some(ide::InlayTooltip::HoverOffset(file_id, offset)) => {
let uri = url(snap, file_id);
let line_index = snap.file_line_index(file_id).ok()?;
let text_document = lsp_types::VersionedTextDocumentIdentifier {
version: snap.url_file_version(&uri)?,
uri,
};
to_value(lsp_ext::InlayHintResolveData {
text_document,
position: lsp_ext::PositionOrRange::Position(position(&line_index, offset)),
})
.ok()
}
Some(ide::InlayTooltip::HoverRanged(file_id, text_range)) => {
let uri = url(snap, file_id);
let text_document = lsp_types::VersionedTextDocumentIdentifier {
version: snap.url_file_version(&uri)?,
uri,
};
let line_index = snap.file_line_index(file_id).ok()?;
to_value(lsp_ext::InlayHintResolveData {
text_document,
position: lsp_ext::PositionOrRange::Range(range(&line_index, text_range)),
})
.ok()
}
_ => None,
})(),
tooltip: Some(match inlay_hint.tooltip {
Some(ide::InlayTooltip::String(s)) => lsp_types::InlayHintTooltip::String(s),
_ => lsp_types::InlayHintTooltip::String(inlay_hint.label.to_string()),
}),
label: inlay_hint_label(snap, inlay_hint.label)?,
data: None,
tooltip,
label,
})
}
fn inlay_hint_label(
snap: &GlobalStateSnapshot,
label: InlayHintLabel,
) -> Cancellable<lsp_types::InlayHintLabel> {
Ok(match label.as_simple_str() {
Some(s) => lsp_types::InlayHintLabel::String(s.into()),
None => lsp_types::InlayHintLabel::LabelParts(
label
mut label: InlayHintLabel,
) -> Cancellable<(lsp_types::InlayHintLabel, Option<lsp_types::InlayHintTooltip>)> {
let res = match &*label.parts {
[InlayHintLabelPart { linked_location: None, .. }] => {
let InlayHintLabelPart { text, tooltip, .. } = label.parts.pop().unwrap();
(
lsp_types::InlayHintLabel::String(text),
match tooltip {
Some(ide::InlayTooltip::String(s)) => {
Some(lsp_types::InlayHintTooltip::String(s))
}
Some(ide::InlayTooltip::Markdown(s)) => {
Some(lsp_types::InlayHintTooltip::MarkupContent(lsp_types::MarkupContent {
kind: lsp_types::MarkupKind::Markdown,
value: s,
}))
}
None => None,
},
)
}
_ => {
let parts = label
.parts
.into_iter()
.map(|part| {
Ok(lsp_types::InlayHintLabelPart {
value: part.text,
tooltip: None,
location: part
.linked_location
.map(|range| location(snap, range))
.transpose()?,
command: None,
})
part.linked_location.map(|range| location(snap, range)).transpose().map(
|location| lsp_types::InlayHintLabelPart {
value: part.text,
tooltip: match part.tooltip {
Some(ide::InlayTooltip::String(s)) => {
Some(lsp_types::InlayHintLabelPartTooltip::String(s))
}
Some(ide::InlayTooltip::Markdown(s)) => {
Some(lsp_types::InlayHintLabelPartTooltip::MarkupContent(
lsp_types::MarkupContent {
kind: lsp_types::MarkupKind::Markdown,
value: s,
},
))
}
None => None,
},
location,
command: None,
},
)
})
.collect::<Cancellable<Vec<_>>>()?,
),
})
.collect::<Cancellable<_>>()?;
(lsp_types::InlayHintLabel::LabelParts(parts), None)
}
};
Ok(res)
}
static TOKEN_RESULT_COUNTER: AtomicU32 = AtomicU32::new(1);