Merge rust-lang#7250

7250: Improve analysis stats legibility r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: 2 people

crates/assists/src/handlers/extract_struct_from_enum_variant.rs

@@ -6,7 +6,7 @@ use ide_db::helpers::{
     insert_use::{insert_use, ImportScope},
     mod_path_to_ast,
 };
-use ide_db::{defs::Definition, search::Reference, RootDatabase};
+use ide_db::{defs::Definition, search::FileReference, RootDatabase};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
     algo::{find_node_at_offset, SyntaxRewriter},
@@ -59,20 +59,22 @@ pub(crate) fn extract_struct_from_enum_variant(
             let current_module = enum_hir.module(ctx.db());
             visited_modules_set.insert(current_module);
             let mut rewriters = FxHashMap::default();
-            for reference in usages {
-                let rewriter = rewriters
-                    .entry(reference.file_range.file_id)
-                    .or_insert_with(SyntaxRewriter::default);
-                let source_file = ctx.sema.parse(reference.file_range.file_id);
-                update_reference(
-                    ctx,
-                    rewriter,
-                    reference,
-                    &source_file,
-                    &enum_module_def,
-                    &variant_hir_name,
-                    &mut visited_modules_set,
-                );
+            for references in usages {
+                // FIXME: is the hashmap needed anymore?
+                let rewriter =
+                    rewriters.entry(references.file_id).or_insert_with(SyntaxRewriter::default);
+                let source_file = ctx.sema.parse(references.file_id);
+                for reference in references.refs {
+                    update_reference(
+                        ctx,
+                        rewriter,
+                        reference,
+                        &source_file,
+                        &enum_module_def,
+                        &variant_hir_name,
+                        &mut visited_modules_set,
+                    );
+                }
             }
             let mut rewriter =
                 rewriters.remove(&ctx.frange.file_id).unwrap_or_else(SyntaxRewriter::default);
@@ -205,13 +207,13 @@ fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Opti
 fn update_reference(
     ctx: &AssistContext,
     rewriter: &mut SyntaxRewriter,
-    reference: Reference,
+    reference: FileReference,
     source_file: &SourceFile,
     enum_module_def: &ModuleDef,
     variant_hir_name: &Name,
     visited_modules_set: &mut FxHashSet<Module>,
 ) -> Option<()> {
-    let offset = reference.file_range.range.start();
+    let offset = reference.range.start();
     let (segment, expr) = if let Some(path_expr) =
         find_node_at_offset::<ast::PathExpr>(source_file.syntax(), offset)
     {

crates/assists/src/handlers/inline_local_variable.rs

@@ -65,11 +65,9 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
 
     let mut wrap_in_parens = vec![true; refs.len()];
 
-    for (i, desc) in refs.iter().enumerate() {
-        let usage_node = ctx
-            .covering_node_for_range(desc.file_range.range)
-            .ancestors()
-            .find_map(ast::PathExpr::cast)?;
+    for (i, desc) in refs.iter().flat_map(|refs| &refs.refs).enumerate() {
+        let usage_node =
+            ctx.covering_node_for_range(desc.range).ancestors().find_map(ast::PathExpr::cast)?;
         let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
         let usage_parent = match usage_parent_option {
             Some(u) => u,
@@ -116,15 +114,15 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
         target,
         move |builder| {
             builder.delete(delete_range);
-            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
+            for (desc, should_wrap) in refs.iter().flat_map(|refs| &refs.refs).zip(wrap_in_parens) {
                 let replacement =
                     if should_wrap { init_in_paren.clone() } else { init_str.clone() };
                 match desc.kind {
                     ReferenceKind::FieldShorthandForLocal => {
                         mark::hit!(inline_field_shorthand);
-                        builder.insert(desc.file_range.range.end(), format!(": {}", replacement))
+                        builder.insert(desc.range.end(), format!(": {}", replacement))
                     }
-                    _ => builder.replace(desc.file_range.range, replacement),
+                    _ => builder.replace(desc.range, replacement),
                 }
             }
         },

crates/assists/src/handlers/remove_unused_param.rs

@@ -1,4 +1,4 @@
-use ide_db::{defs::Definition, search::Reference};
+use ide_db::{defs::Definition, search::FileReferences};
 use syntax::{
     algo::find_node_at_range,
     ast::{self, ArgListOwner},
@@ -58,30 +58,30 @@ pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Opt
         param.syntax().text_range(),
         |builder| {
             builder.delete(range_to_remove(param.syntax()));
-            for usage in fn_def.usages(&ctx.sema).all() {
-                process_usage(ctx, builder, usage, param_position);
+            for usages in fn_def.usages(&ctx.sema).all() {
+                process_usages(ctx, builder, usages, param_position);
             }
         },
     )
 }
 
-fn process_usage(
+fn process_usages(
     ctx: &AssistContext,
     builder: &mut AssistBuilder,
-    usage: Reference,
+    usages: FileReferences,
     arg_to_remove: usize,
 ) -> Option<()> {
-    let source_file = ctx.sema.parse(usage.file_range.file_id);
-    let call_expr: ast::CallExpr =
-        find_node_at_range(source_file.syntax(), usage.file_range.range)?;
-    let call_expr_range = call_expr.expr()?.syntax().text_range();
-    if !call_expr_range.contains_range(usage.file_range.range) {
-        return None;
+    let source_file = ctx.sema.parse(usages.file_id);
+    builder.edit_file(usages.file_id);
+    for usage in usages.refs {
+        let call_expr: ast::CallExpr = find_node_at_range(source_file.syntax(), usage.range)?;
+        let call_expr_range = call_expr.expr()?.syntax().text_range();
+        if !call_expr_range.contains_range(usage.range) {
+            return None;
+        }
+        let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
+        builder.delete(range_to_remove(arg.syntax()));
     }
-    let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
-
-    builder.edit_file(usage.file_range.file_id);
-    builder.delete(range_to_remove(arg.syntax()));
 
     Some(())
 }

crates/ide/src/call_hierarchy.rs

@@ -3,8 +3,8 @@
 use indexmap::IndexMap;
 
 use hir::Semantics;
-use ide_db::call_info::FnCallNode;
 use ide_db::RootDatabase;
+use ide_db::{call_info::FnCallNode, search::FileReferences};
 use syntax::{ast, AstNode, TextRange};
 
 use crate::{
@@ -47,22 +47,23 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
 
     let mut calls = CallLocations::default();
 
-    for reference in refs.info.references() {
-        let file_id = reference.file_range.file_id;
+    for &FileReferences { file_id, ref refs } in refs.info.references() {
         let file = sema.parse(file_id);
         let file = file.syntax();
-        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
-        let token = sema.descend_into_macros(token);
-        let syntax = token.parent();
-
-        // This target is the containing function
-        if let Some(nav) = syntax.ancestors().find_map(|node| {
-            let fn_ = ast::Fn::cast(node)?;
-            let def = sema.to_def(&fn_)?;
-            def.try_to_nav(sema.db)
-        }) {
-            let relative_range = reference.file_range.range;
-            calls.add(&nav, relative_range);
+        for reference in refs {
+            let token = file.token_at_offset(reference.range.start()).next()?;
+            let token = sema.descend_into_macros(token);
+            let syntax = token.parent();
+
+            // This target is the containing function
+            if let Some(nav) = syntax.ancestors().find_map(|node| {
+                let fn_ = ast::Fn::cast(node)?;
+                let def = sema.to_def(&fn_)?;
+                def.try_to_nav(sema.db)
+            }) {
+                let relative_range = reference.range;
+                calls.add(&nav, relative_range);
+            }
         }
     }
 

crates/ide/src/lib.rs

@@ -92,7 +92,7 @@ pub use ide_db::base_db::{
 };
 pub use ide_db::{
     call_info::CallInfo,
-    search::{Reference, ReferenceAccess, ReferenceKind},
+    search::{FileReference, ReferenceAccess, ReferenceKind},
 };
 pub use ide_db::{
     label::Label,

crates/ide/src/references.rs

@@ -14,8 +14,8 @@ pub(crate) mod rename;
 use hir::Semantics;
 use ide_db::{
     defs::{Definition, NameClass, NameRefClass},
-    search::Reference,
-    search::{ReferenceAccess, ReferenceKind, SearchScope},
+    search::FileReference,
+    search::{FileReferences, ReferenceAccess, ReferenceKind, SearchScope},
     RootDatabase,
 };
 use syntax::{
@@ -29,7 +29,7 @@ use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeI
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
     declaration: Declaration,
-    references: Vec<Reference>,
+    references: Vec<FileReferences>,
 }
 
 #[derive(Debug, Clone)]
@@ -48,7 +48,7 @@ impl ReferenceSearchResult {
         &self.declaration.nav
     }
 
-    pub fn references(&self) -> &[Reference] {
+    pub fn references(&self) -> &[FileReferences] {
         &self.references
     }
 
@@ -63,20 +63,22 @@ impl ReferenceSearchResult {
 // allow turning ReferenceSearchResult into an iterator
 // over References
 impl IntoIterator for ReferenceSearchResult {
-    type Item = Reference;
-    type IntoIter = std::vec::IntoIter<Reference>;
+    type Item = FileReferences;
+    type IntoIter = std::vec::IntoIter<FileReferences>;
 
     fn into_iter(mut self) -> Self::IntoIter {
         let mut v = Vec::with_capacity(self.len());
-        v.push(Reference {
-            file_range: FileRange {
-                file_id: self.declaration.nav.file_id,
-                range: self.declaration.nav.focus_or_full_range(),
-            },
+        v.append(&mut self.references);
+        let decl_ref = FileReference {
+            range: self.declaration.nav.focus_or_full_range(),
             kind: self.declaration.kind,
             access: self.declaration.access,
-        });
-        v.append(&mut self.references);
+        };
+        let file_id = self.declaration.nav.file_id;
+        match v.iter_mut().find(|it| it.file_id == file_id) {
+            Some(refs) => refs.refs.push(decl_ref),
+            None => v.push(FileReferences { file_id, refs: vec![decl_ref] }),
+        }
         v.into_iter()
     }
 }
@@ -109,13 +111,11 @@ pub(crate) fn find_all_refs(
 
     let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
 
-    let references = def
-        .usages(sema)
-        .set_scope(search_scope)
-        .all()
-        .into_iter()
-        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
-        .collect();
+    let mut references = def.usages(sema).set_scope(search_scope).all();
+    references.iter_mut().for_each(|it| {
+        it.refs.retain(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
+    });
+    references.retain(|r| !r.refs.is_empty());
 
     let nav = def.try_to_nav(sema.db)?;
     let decl_range = nav.focus_or_full_range();
@@ -255,7 +255,8 @@ fn try_find_self_references(
     syntax: &SyntaxNode,
     position: FilePosition,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
-    let self_token = syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])?;
+    let FilePosition { file_id, offset } = position;
+    let self_token = syntax.token_at_offset(offset).find(|t| t.kind() == T![self])?;
     let parent = self_token.parent();
     match_ast! {
         match parent {
@@ -276,7 +277,7 @@ fn try_find_self_references(
 
     let declaration = Declaration {
         nav: NavigationTarget {
-            file_id: position.file_id,
+            file_id,
             full_range: self_param.syntax().text_range(),
             focus_range: Some(param_self_token.text_range()),
             name: param_self_token.text().clone(),
@@ -295,25 +296,29 @@ fn try_find_self_references(
     let references = function
         .body()
         .map(|body| {
-            body.syntax()
-                .descendants()
-                .filter_map(ast::PathExpr::cast)
-                .filter_map(|expr| {
-                    let path = expr.path()?;
-                    if path.qualifier().is_none() {
-                        path.segment()?.self_token()
-                    } else {
-                        None
-                    }
-                })
-                .map(|token| Reference {
-                    file_range: FileRange { file_id: position.file_id, range: token.text_range() },
-                    kind: ReferenceKind::SelfKw,
-                    access: declaration.access, // FIXME: properly check access kind here instead of copying it from the declaration
-                })
-                .collect()
+            FileReferences {
+                file_id,
+                refs: body
+                    .syntax()
+                    .descendants()
+                    .filter_map(ast::PathExpr::cast)
+                    .filter_map(|expr| {
+                        let path = expr.path()?;
+                        if path.qualifier().is_none() {
+                            path.segment()?.self_token()
+                        } else {
+                            None
+                        }
+                    })
+                    .map(|token| FileReference {
+                        range: token.text_range(),
+                        kind: ReferenceKind::SelfKw,
+                        access: declaration.access, // FIXME: properly check access kind here instead of copying it from the declaration
+                    })
+                    .collect(),
+            }
         })
-        .unwrap_or_default();
+        .map_or_else(Vec::default, |it| vec![it]);
 
     Some(RangeInfo::new(
         param_self_token.text_range(),
@@ -324,7 +329,7 @@ fn try_find_self_references(
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use ide_db::base_db::FileId;
+    use ide_db::{base_db::FileId, search::FileReferences};
     use stdx::format_to;
 
     use crate::{fixture, SearchScope};
@@ -1018,12 +1023,14 @@ impl Foo {
             actual += "\n\n";
         }
 
-        for r in &refs.references {
-            format_to!(actual, "{:?} {:?} {:?}", r.file_range.file_id, r.file_range.range, r.kind);
-            if let Some(access) = r.access {
-                format_to!(actual, " {:?}", access);
+        for FileReferences { file_id, refs } in refs.references {
+            for r in refs {
+                format_to!(actual, "{:?} {:?} {:?}", file_id, r.range, r.kind);
+                if let Some(access) = r.access {
+                    format_to!(actual, " {:?}", access);
+                }
+                actual += "\n";
             }
-            actual += "\n";
         }
         expect.assert_eq(&actual)
     }