Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-11-11 07:34:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

Goto type actions for notable trait hovers

Browse source
This commit is contained in:
Lukas Wirth 2024-01-16 19:59:55 +01:00
parent 82e8355492
commit ffeaee84af
3 changed files with 212 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

87
crates/ide/src/hover.rs
View file

@ -3,10 +3,10 @@ mod render;
#[cfg(test)]
mod tests;
use std::iter;
use std::{iter, ops::Not};
use either::Either;
use hir::{db::DefDatabase, DescendPreference, HasSource, LangItem, Semantics};
use hir::{db::DefDatabase, DescendPreference, HasCrate, HasSource, LangItem, Semantics};
use ide_db::{
base_db::FileRange,
defs::{Definition, IdentClass, NameRefClass, OperatorClass},
@ -64,7 +64,7 @@ pub enum HoverAction {
}
impl HoverAction {
fn goto_type_from_targets(db: &RootDatabase, targets: Vec<hir::ModuleDef>) -> Self {
fn goto_type_from_targets(db: &RootDatabase, targets: Vec<hir::ModuleDef>) -> Option<Self> {
let targets = targets
.into_iter()
.filter_map(|it| {
@ -77,8 +77,8 @@ impl HoverAction {
nav: it.try_to_nav(db)?.call_site(),
})
})
.collect();
HoverAction::GoToType(targets)
.collect::<Vec<_>>();
targets.is_empty().not().then_some(HoverAction::GoToType(targets))
}
}
@ -315,7 +315,7 @@ fn hover_simple(
ast::IntNumber(num) => {
res.markup = match num.value() {
Ok(num) => {
Markup::fenced_block_text(format_args!("{num} (0x{num:X}|0x{num:b})"))
Markup::fenced_block_text(format_args!("{num} (0x{num:X}|0b{num:b})"))
},
Err(e) => {
Markup::fenced_block_text(format_args!("{e}"))
@ -365,25 +365,67 @@ fn hover_ranged(
})
}
// FIXME: Why is this pub(crate)?
pub(crate) fn hover_for_definition(
sema: &Semantics<'_, RootDatabase>,
file_id: FileId,
definition: Definition,
def: Definition,
scope_node: &SyntaxNode,
config: &HoverConfig,
) -> Option<HoverResult> {
let famous_defs = match &definition {
let famous_defs = match &def {
Definition::BuiltinType(_) => Some(FamousDefs(sema, sema.scope(scope_node)?.krate())),
_ => None,
};
render::definition(sema.db, definition, famous_defs.as_ref(), config).map(|markup| {
let db = sema.db;
let def_ty = match def {
Definition::Local(it) => Some(it.ty(db)),
Definition::GenericParam(hir::GenericParam::ConstParam(it)) => Some(it.ty(db)),
Definition::GenericParam(hir::GenericParam::TypeParam(it)) => Some(it.ty(db)),
Definition::Field(field) => Some(field.ty(db)),
Definition::TupleField(it) => Some(it.ty(db)),
Definition::Function(it) => Some(it.ty(db)),
Definition::Adt(it) => Some(it.ty(db)),
Definition::Const(it) => Some(it.ty(db)),
Definition::Static(it) => Some(it.ty(db)),
Definition::TypeAlias(it) => Some(it.ty(db)),
Definition::BuiltinType(it) => Some(it.ty(db)),
_ => None,
};
let notable_traits = def_ty
.map(|ty| {
db.notable_traits_in_deps(ty.krate(db).into())
.iter()
.flat_map(|it| &**it)
.filter_map(move |&trait_| {
let trait_ = trait_.into();
ty.impls_trait(db, trait_, &[]).then(|| {
(
trait_,
trait_
.items(db)
.into_iter()
.filter_map(hir::AssocItem::as_type_alias)
.map(|alias| {
(ty.normalize_trait_assoc_type(db, &[], alias), alias.name(db))
})
.collect::<Vec<_>>(),
)
})
})
.collect::<Vec<_>>()
})
.unwrap_or_default();
render::definition(sema.db, def, famous_defs.as_ref(), &notable_traits, config).map(|markup| {
HoverResult {
markup: render::process_markup(sema.db, definition, &markup, config),
markup: render::process_markup(sema.db, def, &markup, config),
actions: [
show_implementations_action(sema.db, definition),
show_fn_references_action(sema.db, definition),
runnable_action(sema, definition, file_id),
goto_type_action_for_def(sema.db, definition),
show_implementations_action(sema.db, def),
show_fn_references_action(sema.db, def),
runnable_action(sema, def, file_id),
goto_type_action_for_def(sema.db, def, &notable_traits),
]
.into_iter()
.flatten()
@ -446,7 +488,11 @@ fn runnable_action(
}
}
fn goto_type_action_for_def(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
fn goto_type_action_for_def(
db: &RootDatabase,
def: Definition,
notable_traits: &[(hir::Trait, Vec<(Option<hir::Type>, hir::Name)>)],
) -> Option<HoverAction> {
let mut targets: Vec<hir::ModuleDef> = Vec::new();
let mut push_new_def = |item: hir::ModuleDef| {
if !targets.contains(&item) {
@ -454,6 +500,13 @@ fn goto_type_action_for_def(db: &RootDatabase, def: Definition) -> Option<HoverA
}
};
for &(trait_, ref assocs) in notable_traits {
push_new_def(trait_.into());
assocs.iter().filter_map(|(ty, _)| ty.as_ref()).for_each(|ty| {
walk_and_push_ty(db, ty, &mut push_new_def);
});
}
if let Definition::GenericParam(hir::GenericParam::TypeParam(it)) = def {
let krate = it.module(db).krate();
let sized_trait =
@ -469,13 +522,13 @@ fn goto_type_action_for_def(db: &RootDatabase, def: Definition) -> Option<HoverA
Definition::GenericParam(hir::GenericParam::ConstParam(it)) => it.ty(db),
Definition::Field(field) => field.ty(db),
Definition::Function(function) => function.ret_type(db),
_ => return None,
_ => return HoverAction::goto_type_from_targets(db, targets),
};
walk_and_push_ty(db, &ty, &mut push_new_def);
}
Some(HoverAction::goto_type_from_targets(db, targets))
HoverAction::goto_type_from_targets(db, targets)
}
fn walk_and_push_ty(

100
crates/ide/src/hover/render.rs
View file

@ -3,8 +3,8 @@ use std::{mem, ops::Not};
use either::Either;
use hir::{
db::DefDatabase, Adt, AsAssocItem, AssocItem, CaptureKind, HasCrate, HasSource, HirDisplay,
Layout, LayoutError, Semantics, TypeInfo,
Adt, AsAssocItem, CaptureKind, HasSource, HirDisplay, Layout, LayoutError, Name, Semantics,
Trait, Type, TypeInfo,
};
use ide_db::{
base_db::SourceDatabase,
@ -117,7 +117,9 @@ pub(super) fn try_expr(
};
walk_and_push_ty(sema.db, &inner_ty, &mut push_new_def);
walk_and_push_ty(sema.db, &body_ty, &mut push_new_def);
res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) {
res.actions.push(actions);
}
let inner_ty = inner_ty.display(sema.db).to_string();
let body_ty = body_ty.display(sema.db).to_string();
@ -195,7 +197,9 @@ pub(super) fn deref_expr(
)
.into()
};
res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) {
res.actions.push(actions);
}
Some(res)
}
@ -302,7 +306,9 @@ pub(super) fn struct_rest_pat(
Markup::fenced_block(&s)
};
res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) {
res.actions.push(actions);
}
res
}
@ -388,6 +394,7 @@ pub(super) fn definition(
db: &RootDatabase,
def: Definition,
famous_defs: Option<&FamousDefs<'_, '_>>,
notable_traits: &[(Trait, Vec<(Option<Type>, Name)>)],
config: &HoverConfig,
) -> Option<Markup> {
let mod_path = definition_mod_path(db, &def);
@ -464,58 +471,35 @@ pub(super) fn definition(
_ => None,
};
let def_ty = match def {
Definition::Local(it) => Some(it.ty(db)),
Definition::GenericParam(hir::GenericParam::ConstParam(it)) => Some(it.ty(db)),
Definition::GenericParam(hir::GenericParam::TypeParam(it)) => Some(it.ty(db)),
Definition::Field(field) => Some(field.ty(db)),
Definition::TupleField(it) => Some(it.ty(db)),
Definition::Function(it) => Some(it.ty(db)),
Definition::Adt(it) => Some(it.ty(db)),
Definition::Const(it) => Some(it.ty(db)),
Definition::Static(it) => Some(it.ty(db)),
Definition::TypeAlias(it) => Some(it.ty(db)),
Definition::BuiltinType(it) => Some(it.ty(db)),
_ => None,
};
let notable_traits = def_ty.and_then(|ty| {
let notable_traits = {
let mut desc = String::new();
let mut needs_impl_header = true;
for &trait_ in db.notable_traits_in_deps(ty.krate(db).into()).iter().flat_map(|it| &**it) {
let trait_ = trait_.into();
if ty.impls_trait(db, trait_, &[]) {
let aliases: Vec<_> = trait_
.items(db)
.into_iter()
.filter_map(AssocItem::as_type_alias)
.map(|alias| (ty.normalize_trait_assoc_type(db, &[], alias), alias.name(db)))
.collect();
desc.push_str(if mem::take(&mut needs_impl_header) {
" // notable traits impls: "
} else {
", "
});
format_to!(desc, "{}", trait_.name(db).display(db),);
if !aliases.is_empty() {
desc.push('<');
format_to!(
desc,
"{}",
aliases.into_iter().format_with(", ", |(ty, name), f| {
f(&name.display(db))?;
f(&" = ")?;
match ty {
Some(ty) => f(&ty.display(db)),
None => f(&"?"),
}
})
);
desc.push('>');
}
for (trait_, assoc_types) in notable_traits {
desc.push_str(if mem::take(&mut needs_impl_header) {
" // notable traits implemented: "
} else {
", "
});
format_to!(desc, "{}", trait_.name(db).display(db),);
if !assoc_types.is_empty() {
desc.push('<');
format_to!(
desc,
"{}",
assoc_types.into_iter().format_with(", ", |(ty, name), f| {
f(&name.display(db))?;
f(&" = ")?;
match ty {
Some(ty) => f(&ty.display(db)),
None => f(&"?"),
}
})
);
desc.push('>');
}
}
desc.is_empty().not().then(|| desc)
});
};
let mut desc = String::new();
if let Some(notable_traits) = notable_traits {
@ -569,7 +553,9 @@ fn type_info(
} else {
Markup::fenced_block(&original.display(sema.db))
};
res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) {
res.actions.push(actions);
}
Some(res)
}
@ -629,7 +615,9 @@ fn closure_ty(
);
let mut res = HoverResult::default();
res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) {
res.actions.push(actions);
}
res.markup = markup.into();
Some(res)
}
@ -783,7 +771,9 @@ fn keyword_hints(
KeywordHint {
description,
keyword_mod,
actions: vec![HoverAction::goto_type_from_targets(sema.db, targets)],
actions: HoverAction::goto_type_from_targets(sema.db, targets)
.into_iter()
.collect(),
}
}
_ => KeywordHint {

104
crates/ide/src/hover/tests.rs
View file

@ -6989,7 +6989,7 @@ fn main() {
expect![[r#"
*34325236457856836345234*
```text
34325236457856836345234 (0x744C659178614489D92|0x111010001001100011001011001000101111000011000010100010010001001110110010010)
34325236457856836345234 (0x744C659178614489D92|0b111010001001100011001011001000101111000011000010100010010001001110110010010)
```
"#]],
);
@ -7002,7 +7002,7 @@ fn main() {
expect![[r#"
*134_123424_21*
```text
13412342421 (0x31F701A95|0x1100011111011100000001101010010101)
13412342421 (0x31F701A95|0b1100011111011100000001101010010101)
```
"#]],
);
@ -7015,7 +7015,7 @@ fn main() {
expect![[r#"
*0x12423423*
```text
306328611 (0x12423423|0x10010010000100011010000100011)
306328611 (0x12423423|0b10010010000100011010000100011)
```
"#]],
);
@ -7028,7 +7028,7 @@ fn main() {
expect![[r#"
*0b1111_1111*
```text
255 (0xFF|0x11111111)
255 (0xFF|0b11111111)
```
"#]],
);
@ -7041,7 +7041,7 @@ fn main() {
expect![[r#"
*0o12345*
```text
5349 (0x14E5|0x1010011100101)
5349 (0x14E5|0b1010011100101)
```
"#]],
);
@ -7080,7 +7080,7 @@ fn main(notable$0: u32) {}
*notable*
```rust
// notable traits impls: Notable<Assoc = &str, Assoc2 = char>
// notable traits implemented: Notable<Assoc = &str, Assoc2 = char>
// size = 4, align = 4
notable: u32
```
@ -7112,10 +7112,100 @@ impl Iterator for S {
```
```rust
// notable traits impls: Notable, Future<Output = u32>, Iterator<Item = S>
// notable traits implemented: Notable, Future<Output = u32>, Iterator<Item = S>
// size = 0, align = 1
struct S
```
"#]],
);
}
#[test]
fn notable_actions() {
check_actions(
r#"
//- minicore: future, iterator
struct S;
struct S2;
#[doc(notable_trait)]
trait Notable {}
impl Notable for S$0 {}
impl core::future::Future for S {
type Output = u32;
}
impl Iterator for S {
type Item = S2;
}
"#,
expect![[r#"
[
Implementation(
FilePosition {
file_id: FileId(
0,
),
offset: 7,
},
),
GoToType(
[
HoverGotoTypeData {
mod_path: "test::Notable",
nav: NavigationTarget {
file_id: FileId(
0,
),
full_range: 21..59,
focus_range: 49..56,
name: "Notable",
kind: Trait,
description: "trait Notable",
},
},
HoverGotoTypeData {
mod_path: "core::future::Future",
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 6012..6220,
focus_range: 6077..6083,
name: "Future",
kind: Trait,
container_name: "future",
description: "pub trait Future",
},
},
HoverGotoTypeData {
mod_path: "core::iter::traits::iterator::Iterator",
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 6850..7316,
focus_range: 6894..6902,
name: "Iterator",
kind: Trait,
container_name: "iterator",
description: "pub trait Iterator",
},
},
HoverGotoTypeData {
mod_path: "test::S2",
nav: NavigationTarget {
file_id: FileId(
0,
),
full_range: 10..20,
focus_range: 17..19,
name: "S2",
kind: Struct,
description: "struct S2",
},
},
],
),
]
"#]],
);
}