From ffeaee84afbb24176b9f7375dcb02c5542a8cb64 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Tue, 16 Jan 2024 19:59:55 +0100 Subject: [PATCH 1/2] Goto type actions for notable trait hovers --- crates/ide/src/hover.rs | 87 +++++++++++++++++++++------ crates/ide/src/hover/render.rs | 100 ++++++++++++++----------------- crates/ide/src/hover/tests.rs | 104 ++++++++++++++++++++++++++++++--- 3 files changed, 212 insertions(+), 79 deletions(-) diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs index d06577d3db..5ed3b2dbbc 100644 --- a/crates/ide/src/hover.rs +++ b/crates/ide/src/hover.rs @@ -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) -> Self { + fn goto_type_from_targets(db: &RootDatabase, targets: Vec) -> Option { 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::>(); + 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 { - 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::>(), + ) + }) + }) + .collect::>() + }) + .unwrap_or_default(); + + render::definition(sema.db, def, famous_defs.as_ref(), ¬able_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, ¬able_traits), ] .into_iter() .flatten() @@ -446,7 +488,11 @@ fn runnable_action( } } -fn goto_type_action_for_def(db: &RootDatabase, def: Definition) -> Option { +fn goto_type_action_for_def( + db: &RootDatabase, + def: Definition, + notable_traits: &[(hir::Trait, Vec<(Option, hir::Name)>)], +) -> Option { let mut targets: Vec = 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 Option 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( diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs index d3a9975b2b..511137f67c 100644 --- a/crates/ide/src/hover/render.rs +++ b/crates/ide/src/hover/render.rs @@ -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, Name)>)], config: &HoverConfig, ) -> Option { 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 { diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs index f8693cd1ea..09548745f6 100644 --- a/crates/ide/src/hover/tests.rs +++ b/crates/ide/src/hover/tests.rs @@ -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 + // notable traits implemented: Notable // size = 4, align = 4 notable: u32 ``` @@ -7112,10 +7112,100 @@ impl Iterator for S { ``` ```rust - // notable traits impls: Notable, Future, Iterator + // notable traits implemented: Notable, Future, Iterator // 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", + }, + }, + ], + ), + ] + "#]], + ); +} From 0a75a8c0614efbd6dfcf23870a789fd64e16618b Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Tue, 16 Jan 2024 20:15:31 +0100 Subject: [PATCH 2/2] Notable traits for type info hovers --- crates/ide/src/hover.rs | 55 ++-- crates/ide/src/hover/render.rs | 86 ++--- crates/ide/src/hover/tests.rs | 559 ++++++++++++++++++--------------- 3 files changed, 378 insertions(+), 322 deletions(-) diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs index 5ed3b2dbbc..77a06a97e2 100644 --- a/crates/ide/src/hover.rs +++ b/crates/ide/src/hover.rs @@ -393,30 +393,7 @@ pub(crate) fn hover_for_definition( 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::>(), - ) - }) - }) - .collect::>() - }) - .unwrap_or_default(); + let notable_traits = def_ty.map(|ty| notable_traits(db, &ty)).unwrap_or_default(); render::definition(sema.db, def, famous_defs.as_ref(), ¬able_traits, config).map(|markup| { HoverResult { @@ -434,6 +411,32 @@ pub(crate) fn hover_for_definition( }) } +fn notable_traits( + db: &RootDatabase, + ty: &hir::Type, +) -> Vec<(hir::Trait, Vec<(Option, hir::Name)>)> { + 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::>(), + ) + }) + }) + .collect::>() +} + fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option { fn to_action(nav_target: NavigationTarget) -> HoverAction { HoverAction::Implementation(FilePosition { @@ -583,7 +586,9 @@ fn dedupe_or_merge_hover_actions(actions: Vec) -> Vec } if !go_to_type_targets.is_empty() { - deduped_actions.push(HoverAction::GoToType(go_to_type_targets.into_iter().collect())); + deduped_actions.push(HoverAction::GoToType( + go_to_type_targets.into_iter().sorted_by(|a, b| a.mod_path.cmp(&b.mod_path)).collect(), + )); } deduped_actions diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs index 511137f67c..787b74fc62 100644 --- a/crates/ide/src/hover/render.rs +++ b/crates/ide/src/hover/render.rs @@ -3,8 +3,8 @@ use std::{mem, ops::Not}; use either::Either; use hir::{ - Adt, AsAssocItem, CaptureKind, HasSource, HirDisplay, Layout, LayoutError, Name, Semantics, - Trait, Type, TypeInfo, + Adt, AsAssocItem, CaptureKind, HasCrate, HasSource, HirDisplay, Layout, LayoutError, Name, + Semantics, Trait, Type, TypeInfo, }; use ide_db::{ base_db::SourceDatabase, @@ -25,7 +25,7 @@ use syntax::{ use crate::{ doc_links::{remove_links, rewrite_links}, - hover::walk_and_push_ty, + hover::{notable_traits, walk_and_push_ty}, HoverAction, HoverConfig, HoverResult, Markup, MemoryLayoutHoverConfig, MemoryLayoutHoverRenderKind, }; @@ -471,38 +471,8 @@ pub(super) fn definition( _ => None, }; - let notable_traits = { - let mut desc = String::new(); - let mut needs_impl_header = true; - 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 { + if let Some(notable_traits) = render_notable_trait_comment(db, notable_traits) { desc.push_str(¬able_traits); desc.push('\n'); } @@ -519,6 +489,39 @@ pub(super) fn definition( markup(docs.map(Into::into), desc, mod_path) } +fn render_notable_trait_comment( + db: &RootDatabase, + notable_traits: &[(Trait, Vec<(Option, Name)>)], +) -> Option { + let mut desc = String::new(); + let mut needs_impl_header = true; + 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) +} + fn type_info( sema: &Semantics<'_, RootDatabase>, config: &HoverConfig, @@ -536,8 +539,12 @@ fn type_info( } }; walk_and_push_ty(sema.db, &original, &mut push_new_def); - - res.markup = if let Some(adjusted_ty) = adjusted { + let mut desc = match render_notable_trait_comment(sema.db, ¬able_traits(sema.db, &original)) + { + Some(desc) => desc + "\n", + None => String::new(), + }; + desc += &if let Some(adjusted_ty) = adjusted { walk_and_push_ty(sema.db, &adjusted_ty, &mut push_new_def); let original = original.display(sema.db).to_string(); let adjusted = adjusted_ty.display(sema.db).to_string(); @@ -549,10 +556,10 @@ fn type_info( apad = static_text_diff_len + adjusted.len().max(original.len()), opad = original.len(), ) - .into() } else { - Markup::fenced_block(&original.display(sema.db)) + Markup::fenced_block(&original.display(sema.db)).into() }; + res.markup = desc.into(); if let Some(actions) = HoverAction::goto_type_from_targets(sema.db, targets) { res.actions.push(actions); } @@ -607,6 +614,9 @@ fn closure_ty( { format_to!(markup, "{layout}"); } + if let Some(trait_) = c.fn_trait(sema.db).get_id(sema.db, original.krate(sema.db).into()) { + push_new_def(hir::Trait::from(trait_).into()) + } format_to!( markup, "\n{}\n```{adjusted}\n\n## Captures\n{}", diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs index 09548745f6..d8d439c0d2 100644 --- a/crates/ide/src/hover/tests.rs +++ b/crates/ide/src/hover/tests.rs @@ -400,6 +400,20 @@ fn main() { description: "struct S", }, }, + HoverGotoTypeData { + mod_path: "core::ops::function::FnOnce", + nav: NavigationTarget { + file_id: FileId( + 1, + ), + full_range: 631..866, + focus_range: 692..698, + name: "FnOnce", + kind: Trait, + container_name: "function", + description: "pub trait FnOnce\nwhere\n Args: Tuple,", + }, + }, ], ), ] @@ -2387,39 +2401,39 @@ struct S{ f1: T } fn main() { let s$0t = S{ f1:Arg(0) }; } "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::S", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 17..37, - focus_range: 24..25, - name: "S", - kind: Struct, - description: "struct S {\n f1: T,\n}", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::Arg", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..16, + focus_range: 7..10, + name: "Arg", + kind: Struct, + description: "struct Arg(u32);", }, - HoverGotoTypeData { - mod_path: "test::Arg", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..16, - focus_range: 7..10, - name: "Arg", - kind: Struct, - description: "struct Arg(u32);", - }, + }, + HoverGotoTypeData { + mod_path: "test::S", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 17..37, + focus_range: 24..25, + name: "S", + kind: Struct, + description: "struct S {\n f1: T,\n}", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -2446,39 +2460,39 @@ struct S{ f1: T } fn main() { let s$0t = S{ f1: S{ f1: Arg(0) } }; } "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::S", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 17..37, - focus_range: 24..25, - name: "S", - kind: Struct, - description: "struct S {\n f1: T,\n}", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::Arg", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..16, + focus_range: 7..10, + name: "Arg", + kind: Struct, + description: "struct Arg(u32);", }, - HoverGotoTypeData { - mod_path: "test::Arg", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..16, - focus_range: 7..10, - name: "Arg", - kind: Struct, - description: "struct Arg(u32);", - }, + }, + HoverGotoTypeData { + mod_path: "test::S", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 17..37, + focus_range: 24..25, + name: "S", + kind: Struct, + description: "struct S {\n f1: T,\n}", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -2636,39 +2650,39 @@ fn foo() -> impl Foo + Bar {} fn main() { let s$0t = foo(); } "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::Foo", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..12, - focus_range: 6..9, - name: "Foo", - kind: Trait, - description: "trait Foo", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::Bar", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 13..25, + focus_range: 19..22, + name: "Bar", + kind: Trait, + description: "trait Bar", }, - HoverGotoTypeData { - mod_path: "test::Bar", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 13..25, - focus_range: 19..22, - name: "Bar", - kind: Trait, - description: "trait Bar", - }, + }, + HoverGotoTypeData { + mod_path: "test::Foo", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..12, + focus_range: 6..9, + name: "Foo", + kind: Trait, + description: "trait Foo", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -2686,65 +2700,65 @@ fn foo() -> impl Foo + Bar {} fn main() { let s$0t = foo(); } "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::Foo", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..15, - focus_range: 6..9, - name: "Foo", - kind: Trait, - description: "trait Foo", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::Bar", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 16..31, + focus_range: 22..25, + name: "Bar", + kind: Trait, + description: "trait Bar", }, - HoverGotoTypeData { - mod_path: "test::Bar", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 16..31, - focus_range: 22..25, - name: "Bar", - kind: Trait, - description: "trait Bar", - }, + }, + HoverGotoTypeData { + mod_path: "test::Foo", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..15, + focus_range: 6..9, + name: "Foo", + kind: Trait, + description: "trait Foo", }, - HoverGotoTypeData { - mod_path: "test::S1", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 32..44, - focus_range: 39..41, - name: "S1", - kind: Struct, - description: "struct S1 {}", - }, + }, + HoverGotoTypeData { + mod_path: "test::S1", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 32..44, + focus_range: 39..41, + name: "S1", + kind: Struct, + description: "struct S1 {}", }, - HoverGotoTypeData { - mod_path: "test::S2", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 45..57, - focus_range: 52..54, - name: "S2", - kind: Struct, - description: "struct S2 {}", - }, + }, + HoverGotoTypeData { + mod_path: "test::S2", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 45..57, + focus_range: 52..54, + name: "S2", + kind: Struct, + description: "struct S2 {}", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -2790,52 +2804,52 @@ struct S{} fn foo(ar$0g: &impl Foo + Bar) {} "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::Foo", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..12, - focus_range: 6..9, - name: "Foo", - kind: Trait, - description: "trait Foo", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::Bar", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 13..28, + focus_range: 19..22, + name: "Bar", + kind: Trait, + description: "trait Bar", }, - HoverGotoTypeData { - mod_path: "test::Bar", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 13..28, - focus_range: 19..22, - name: "Bar", - kind: Trait, - description: "trait Bar", - }, + }, + HoverGotoTypeData { + mod_path: "test::Foo", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..12, + focus_range: 6..9, + name: "Foo", + kind: Trait, + description: "trait Foo", }, - HoverGotoTypeData { - mod_path: "test::S", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 29..39, - focus_range: 36..37, - name: "S", - kind: Struct, - description: "struct S {}", - }, + }, + HoverGotoTypeData { + mod_path: "test::S", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 29..39, + focus_range: 36..37, + name: "S", + kind: Struct, + description: "struct S {}", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -3077,65 +3091,65 @@ struct S {} fn foo(a$0rg: &impl ImplTrait>>>) {} "#, expect![[r#" - [ - GoToType( - [ - HoverGotoTypeData { - mod_path: "test::ImplTrait", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 0..21, - focus_range: 6..15, - name: "ImplTrait", - kind: Trait, - description: "trait ImplTrait", - }, + [ + GoToType( + [ + HoverGotoTypeData { + mod_path: "test::B", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 43..57, + focus_range: 50..51, + name: "B", + kind: Struct, + description: "struct B {}", }, - HoverGotoTypeData { - mod_path: "test::B", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 43..57, - focus_range: 50..51, - name: "B", - kind: Struct, - description: "struct B {}", - }, + }, + HoverGotoTypeData { + mod_path: "test::DynTrait", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 22..42, + focus_range: 28..36, + name: "DynTrait", + kind: Trait, + description: "trait DynTrait", }, - HoverGotoTypeData { - mod_path: "test::DynTrait", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 22..42, - focus_range: 28..36, - name: "DynTrait", - kind: Trait, - description: "trait DynTrait", - }, + }, + HoverGotoTypeData { + mod_path: "test::ImplTrait", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 0..21, + focus_range: 6..15, + name: "ImplTrait", + kind: Trait, + description: "trait ImplTrait", }, - HoverGotoTypeData { - mod_path: "test::S", - nav: NavigationTarget { - file_id: FileId( - 0, - ), - full_range: 58..69, - focus_range: 65..66, - name: "S", - kind: Struct, - description: "struct S {}", - }, + }, + HoverGotoTypeData { + mod_path: "test::S", + nav: NavigationTarget { + file_id: FileId( + 0, + ), + full_range: 58..69, + focus_range: 65..66, + name: "S", + kind: Struct, + description: "struct S {}", }, - ], - ), - ] - "#]], + }, + ], + ), + ] + "#]], ); } @@ -7120,6 +7134,33 @@ impl Iterator for S { ); } +#[test] +fn notable_ranged() { + check_hover_range( + r#" +//- minicore: future, iterator +struct S; +#[doc(notable_trait)] +trait Notable {} +impl Notable for S {} +impl core::future::Future for S { + type Output = u32; +} +impl Iterator for S { + type Item = S; +} +fn main() { + $0S$0; +} +"#, + expect![[r#" + // notable traits implemented: Notable, Future, Iterator + ```rust + S + ```"#]], + ); +} + #[test] fn notable_actions() { check_actions( @@ -7149,19 +7190,6 @@ impl Iterator for S { ), 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 { @@ -7190,6 +7218,19 @@ impl Iterator for S { description: "pub trait Iterator", }, }, + 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: "test::S2", nav: NavigationTarget {