From 8a57c736404abac81a6de20b0e90c19021e040b9 Mon Sep 17 00:00:00 2001 From: Jade Date: Tue, 1 Jun 2021 16:16:59 -0700 Subject: feat: goto definition on an impl fn goes to that fn in the trait e.g. if you have a trait T and `impl T for S` for some struct, if you goto definition on some function name inside the impl, it will go to the definition of that function inside the `trait T` block, rather than the current behaviour of not going anywhere at all. --- crates/hir/src/lib.rs | 9 ++++--- crates/ide/src/goto_definition.rs | 51 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 53 insertions(+), 7 deletions(-) (limited to 'crates') diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs index b43d61d0e..c2b68a853 100644 --- a/crates/hir/src/lib.rs +++ b/crates/hir/src/lib.rs @@ -50,7 +50,6 @@ use hir_def::{ per_ns::PerNs, resolver::{HasResolver, Resolver}, src::HasSource as _, - type_ref::TraitRef, AdtId, AssocContainerId, AssocItemId, AssocItemLoc, AttrDefId, ConstId, ConstParamId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, ImplId, LifetimeParamId, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StaticId, StructId, TraitId, TypeAliasId, @@ -1797,9 +1796,11 @@ impl Impl { } // FIXME: the return type is wrong. This should be a hir version of - // `TraitRef` (ie, resolved `TypeRef`). - pub fn trait_(self, db: &dyn HirDatabase) -> Option { - db.impl_data(self.id).target_trait.as_deref().cloned() + // `TraitRef` (to account for parameters and qualifiers) + pub fn trait_(self, db: &dyn HirDatabase) -> Option { + let trait_ref = db.impl_trait(self.id)?.skip_binders().clone(); + let id = hir_ty::from_chalk_trait_id(trait_ref.trait_id); + Some(Trait { id }) } pub fn self_ty(self, db: &dyn HirDatabase) -> Type { diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs index b0bfd646e..c236039f4 100644 --- a/crates/ide/src/goto_definition.rs +++ b/crates/ide/src/goto_definition.rs @@ -1,10 +1,10 @@ use std::convert::TryInto; use either::Either; -use hir::{InFile, Semantics}; +use hir::{AsAssocItem, InFile, ModuleDef, Semantics}; use ide_db::{ base_db::{AnchoredPath, FileId, FileLoader}, - defs::{NameClass, NameRefClass}, + defs::{Definition, NameClass, NameRefClass}, RootDatabase, }; use syntax::{ @@ -57,7 +57,8 @@ pub(crate) fn goto_definition( }, ast::Name(name) => { let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db); - def.try_to_nav(sema.db) + try_find_trait_fn_definition(&sema.db, &def) + .or_else(|| def.try_to_nav(sema.db)) }, ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, <) { let def = name_class.referenced_or_defined(sema.db); @@ -99,6 +100,32 @@ fn try_lookup_include_path( }) } +/// finds the trait definition of an impl'd function +/// e.g. +/// ```rust +/// trait A { fn a(); } +/// struct S; +/// impl A for S { fn a(); } // <-- on this function, will get the location of a() in the trait +/// ``` +fn try_find_trait_fn_definition(db: &RootDatabase, def: &Definition) -> Option { + match def { + Definition::ModuleDef(ModuleDef::Function(f)) => { + let name = def.name(db)?; + let assoc = f.as_assoc_item(db)?; + let imp = match assoc.container(db) { + hir::AssocItemContainer::Impl(imp) => imp, + _ => return None, + }; + let trait_ = imp.trait_(db)?; + trait_ + .items(db) + .iter() + .find_map(|itm| (itm.name(db)? == name).then(|| itm.try_to_nav(db)).flatten()) + } + _ => None, + } +} + fn pick_best(tokens: TokenAtOffset) -> Option { return tokens.max_by_key(priority); fn priority(n: &SyntaxToken) -> usize { @@ -1259,6 +1286,24 @@ fn main() { //- /foo.txt // empty //^ file +"#, + ); + } + + #[test] + fn goto_def_of_trait_impl_fn() { + check( + r#" +trait Twait { + fn a(); + // ^ +} + +struct Stwuct; + +impl Twait for Stwuct { + fn a$0(); +} "#, ); } -- cgit v1.2.3 From 34ce05781fbca1bc6b717cce3bee6bd9923248b2 Mon Sep 17 00:00:00 2001 From: Jade Date: Sun, 6 Jun 2021 21:48:06 -0700 Subject: feat: goto def on impl items also goes to the defn in the trait It was trivial to extend this to associated consts/associated types and I just didn't think of it. --- crates/ide/src/goto_definition.rs | 74 +++++++++++++++++++++++++++++---------- 1 file changed, 56 insertions(+), 18 deletions(-) (limited to 'crates') diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs index c236039f4..2d36c34e9 100644 --- a/crates/ide/src/goto_definition.rs +++ b/crates/ide/src/goto_definition.rs @@ -57,7 +57,7 @@ pub(crate) fn goto_definition( }, ast::Name(name) => { let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db); - try_find_trait_fn_definition(&sema.db, &def) + try_find_trait_item_definition(&sema.db, &def) .or_else(|| def.try_to_nav(sema.db)) }, ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, <) { @@ -100,30 +100,32 @@ fn try_lookup_include_path( }) } -/// finds the trait definition of an impl'd function +/// finds the trait definition of an impl'd item /// e.g. /// ```rust /// trait A { fn a(); } /// struct S; /// impl A for S { fn a(); } // <-- on this function, will get the location of a() in the trait /// ``` -fn try_find_trait_fn_definition(db: &RootDatabase, def: &Definition) -> Option { - match def { - Definition::ModuleDef(ModuleDef::Function(f)) => { - let name = def.name(db)?; - let assoc = f.as_assoc_item(db)?; - let imp = match assoc.container(db) { - hir::AssocItemContainer::Impl(imp) => imp, - _ => return None, - }; - let trait_ = imp.trait_(db)?; - trait_ - .items(db) - .iter() - .find_map(|itm| (itm.name(db)? == name).then(|| itm.try_to_nav(db)).flatten()) - } +fn try_find_trait_item_definition(db: &RootDatabase, def: &Definition) -> Option { + let name = def.name(db)?; + let assoc = match def { + Definition::ModuleDef(ModuleDef::Function(f)) => f.as_assoc_item(db), + Definition::ModuleDef(ModuleDef::Const(c)) => c.as_assoc_item(db), + Definition::ModuleDef(ModuleDef::TypeAlias(ty)) => ty.as_assoc_item(db), _ => None, - } + }?; + + let imp = match assoc.container(db) { + hir::AssocItemContainer::Impl(imp) => imp, + _ => return None, + }; + + let trait_ = imp.trait_(db)?; + trait_ + .items(db) + .iter() + .find_map(|itm| (itm.name(db)? == name).then(|| itm.try_to_nav(db)).flatten()) } fn pick_best(tokens: TokenAtOffset) -> Option { @@ -1304,6 +1306,42 @@ struct Stwuct; impl Twait for Stwuct { fn a$0(); } +"#, + ); + } + + #[test] + fn goto_def_of_trait_impl_const() { + check( + r#" +trait Twait { + const NOMS: bool; + // ^^^^ +} + +struct Stwuct; + +impl Twait for Stwuct { + const NOMS$0: bool = true; +} +"#, + ); + } + + #[test] + fn goto_def_of_trait_impl_type_alias() { + check( + r#" +trait Twait { + type IsBad; + // ^^^^^ +} + +struct Stwuct; + +impl Twait for Stwuct { + type IsBad$0 = !; +} "#, ); } -- cgit v1.2.3