Merge #10108

10108: fix: make `goto_implementation` multi-token mapping aware r=Veykril a=Veykril

bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>

crates/ide/src/goto_implementation.rs

@@ -1,9 +1,11 @@
 use hir::{AsAssocItem, Impl, Semantics};
 use ide_db::{
     defs::{Definition, NameClass, NameRefClass},
+    helpers::pick_best_token,
     RootDatabase,
 };
-use syntax::{ast, AstNode};
+use itertools::Itertools;
+use syntax::{ast, AstNode, SyntaxKind::*, T};
 
 use crate::{display::TryToNav, FilePosition, NavigationTarget, RangeInfo};
 
@@ -26,29 +28,43 @@ pub(crate) fn goto_implementation(
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax().clone();
 
-    let node = sema.find_node_at_offset_with_descend(&syntax, position.offset)?;
+    let original_token =
+        pick_best_token(syntax.token_at_offset(position.offset), |kind| match kind {
+            IDENT | T![self] => 1,
+            _ => 0,
+        })?;
+    let range = original_token.text_range();
+    let navs =
+        sema.descend_into_macros_many(original_token)
+            .into_iter()
+            .filter_map(|token| token.parent().and_then(ast::NameLike::cast))
+            .filter_map(|node| {
                 let def = match &node {
-        ast::NameLike::Name(name) => NameClass::classify(&sema, name).map(|class| match class {
+                    ast::NameLike::Name(name) => {
+                        NameClass::classify(&sema, name).map(|class| match class {
                             NameClass::Definition(it) | NameClass::ConstReference(it) => it,
                             NameClass::PatFieldShorthand { local_def, field_ref: _ } => {
                                 Definition::Local(local_def)
                             }
-        }),
+                        })
-        ast::NameLike::NameRef(name_ref) => {
+                    }
-            NameRefClass::classify(&sema, name_ref).map(|class| match class {
+                    ast::NameLike::NameRef(name_ref) => NameRefClass::classify(&sema, name_ref)
+                        .map(|class| match class {
                             NameRefClass::Definition(def) => def,
                             NameRefClass::FieldShorthand { local_ref, field_ref: _ } => {
                                 Definition::Local(local_ref)
                             }
-            })
+                        }),
-        }
                     ast::NameLike::Lifetime(_) => None,
                 }?;
 
-    let def = match def {
+                match def {
-        Definition::ModuleDef(def) => def,
+                    Definition::ModuleDef(def) => Some(def),
-        _ => return None,
+                    _ => None,
-    };
+                }
+            })
+            .unique()
+            .filter_map(|def| {
                 let navs = match def {
                     hir::ModuleDef::Trait(trait_) => impls_for_trait(&sema, trait_),
                     hir::ModuleDef::Adt(adt) => impls_for_ty(&sema, adt.ty(sema.db)),
@@ -71,7 +87,12 @@ pub(crate) fn goto_implementation(
                     }
                     _ => return None,
                 };
-    Some(RangeInfo { range: node.syntax().text_range(), info: navs })
+                Some(navs)
+            })
+            .flatten()
+            .collect();
+
+    Some(RangeInfo { range, info: navs })
 }
 
 fn impls_for_ty(sema: &Semantics<RootDatabase>, ty: hir::Type) -> Vec<NavigationTarget> {

crates/ide_db/src/search.rs

@@ -442,9 +442,7 @@ impl<'a> FindUsages<'a> {
                         continue;
                     }
 
-                    if let Some(ast::NameLike::NameRef(name_ref)) =
+                    for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {
-                        sema.find_node_at_offset_with_descend(&tree, offset)
-                    {
                         if self.found_self_module_name_ref(&name_ref, sink) {
                             return;
                         }