Merge #10426

10426: internal: use naming that matches intended use-case r=matklad a=matklad

bors r+
🤖

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

Author: bors[bot]

crates/ide/src/highlight_related.rs

@@ -3,7 +3,7 @@ use ide_db::{
     base_db::FilePosition,
     defs::{Definition, NameClass, NameRefClass},
     helpers::{for_each_break_expr, for_each_tail_expr, node_ext::walk_expr, pick_best_token},
-    search::{FileReference, ReferenceAccess, SearchScope},
+    search::{FileReference, ReferenceCategory, SearchScope},
     RootDatabase,
 };
 use rustc_hash::FxHashSet;
@@ -19,7 +19,10 @@ use crate::{display::TryToNav, references, NavigationTarget};
 #[derive(PartialEq, Eq, Hash)]
 pub struct HighlightedRange {
     pub range: TextRange,
-    pub access: Option<ReferenceAccess>,
+    // FIXME: This needs to be more precise. Reference category makes sense only
+    // for references, but we also have defs. And things like exit points are
+    // neither.
+    pub category: Option<ReferenceCategory>,
 }
 
 #[derive(Default, Clone)]
@@ -87,7 +90,10 @@ fn highlight_references(
                 .remove(&file_id)
         })
         .flatten()
-        .map(|FileReference { access, range, .. }| HighlightedRange { range, access });
+        .map(|FileReference { category: access, range, .. }| HighlightedRange {
+            range,
+            category: access,
+        });
 
     let declarations = defs.iter().flat_map(|def| {
         match def {
@@ -99,8 +105,12 @@ fn highlight_references(
         .filter(|decl| decl.file_id == file_id)
         .and_then(|decl| {
             let range = decl.focus_range?;
-            let access = references::decl_access(&def, syntax, range);
-            Some(HighlightedRange { range, access })
+            let category = if references::decl_mutability(&def, syntax, range) {
+                Some(ReferenceCategory::Write)
+            } else {
+                None
+            };
+            Some(HighlightedRange { range, category })
         })
     });
 
@@ -125,18 +135,20 @@ fn highlight_exit_points(
         walk_expr(&body, &mut |expr| match expr {
             ast::Expr::ReturnExpr(expr) => {
                 if let Some(token) = expr.return_token() {
-                    highlights.push(HighlightedRange { access: None, range: token.text_range() });
+                    highlights.push(HighlightedRange { category: None, range: token.text_range() });
                 }
             }
             ast::Expr::TryExpr(try_) => {
                 if let Some(token) = try_.question_mark_token() {
-                    highlights.push(HighlightedRange { access: None, range: token.text_range() });
+                    highlights.push(HighlightedRange { category: None, range: token.text_range() });
                 }
             }
             ast::Expr::MethodCallExpr(_) | ast::Expr::CallExpr(_) | ast::Expr::MacroCall(_) => {
                 if sema.type_of_expr(&expr).map_or(false, |ty| ty.original.is_never()) {
-                    highlights
-                        .push(HighlightedRange { access: None, range: expr.syntax().text_range() });
+                    highlights.push(HighlightedRange {
+                        category: None,
+                        range: expr.syntax().text_range(),
+                    });
                 }
             }
             _ => (),
@@ -154,7 +166,7 @@ fn highlight_exit_points(
                         .map_or_else(|| tail.syntax().text_range(), |tok| tok.text_range()),
                     _ => tail.syntax().text_range(),
                 };
-                highlights.push(HighlightedRange { access: None, range })
+                highlights.push(HighlightedRange { category: None, range })
             });
         }
         Some(highlights)
@@ -187,13 +199,13 @@ fn highlight_break_points(token: SyntaxToken) -> Option<Vec<HighlightedRange>> {
             token.map(|tok| tok.text_range()),
             label.as_ref().map(|it| it.syntax().text_range()),
         );
-        highlights.extend(range.map(|range| HighlightedRange { access: None, range }));
+        highlights.extend(range.map(|range| HighlightedRange { category: None, range }));
         for_each_break_expr(label, body, &mut |break_| {
             let range = cover_range(
                 break_.break_token().map(|it| it.text_range()),
                 break_.lifetime().map(|it| it.syntax().text_range()),
             );
-            highlights.extend(range.map(|range| HighlightedRange { access: None, range }));
+            highlights.extend(range.map(|range| HighlightedRange { category: None, range }));
         });
         Some(highlights)
     }
@@ -241,13 +253,13 @@ fn highlight_yield_points(token: SyntaxToken) -> Option<Vec<HighlightedRange>> {
         body: Option<ast::Expr>,
     ) -> Option<Vec<HighlightedRange>> {
         let mut highlights =
-            vec![HighlightedRange { access: None, range: async_token?.text_range() }];
+            vec![HighlightedRange { category: None, range: async_token?.text_range() }];
         if let Some(body) = body {
             walk_expr(&body, &mut |expr| {
                 if let ast::Expr::AwaitExpr(expr) = expr {
                     if let Some(token) = expr.await_token() {
                         highlights
-                            .push(HighlightedRange { access: None, range: token.text_range() });
+                            .push(HighlightedRange { category: None, range: token.text_range() });
                     }
                 }
             });
@@ -353,10 +365,10 @@ mod tests {
             .map(|hl| {
                 (
                     hl.range,
-                    hl.access.map(|it| {
+                    hl.category.map(|it| {
                         match it {
-                            ReferenceAccess::Read => "read",
-                            ReferenceAccess::Write => "write",
+                            ReferenceCategory::Read => "read",
+                            ReferenceCategory::Write => "write",
                         }
                         .to_string()
                     }),

crates/ide/src/lib.rs

@@ -108,7 +108,7 @@ pub use ide_db::{
     call_info::CallInfo,
     label::Label,
     line_index::{LineCol, LineColUtf16, LineIndex},
-    search::{ReferenceAccess, SearchScope},
+    search::{ReferenceCategory, SearchScope},
     source_change::{FileSystemEdit, SourceChange},
     symbol_index::Query,
     RootDatabase, SymbolKind,

crates/ide/src/references.rs

@@ -16,7 +16,7 @@ use hir::{PathResolution, Semantics};
 use ide_db::{
     base_db::FileId,
     defs::{Definition, NameClass, NameRefClass},
-    search::{ReferenceAccess, SearchScope, UsageSearchResult},
+    search::{ReferenceCategory, SearchScope, UsageSearchResult},
     RootDatabase,
 };
 use rustc_hash::FxHashMap;
@@ -31,13 +31,13 @@ use crate::{display::TryToNav, FilePosition, NavigationTarget};
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
     pub declaration: Option<Declaration>,
-    pub references: FxHashMap<FileId, Vec<(TextRange, Option<ReferenceAccess>)>>,
+    pub references: FxHashMap<FileId, Vec<(TextRange, Option<ReferenceCategory>)>>,
 }
 
 #[derive(Debug, Clone)]
 pub struct Declaration {
     pub nav: NavigationTarget,
-    pub access: Option<ReferenceAccess>,
+    pub is_mut: bool,
 }
 
 // Feature: Find All References
@@ -88,7 +88,7 @@ pub(crate) fn find_all_refs(
                 .map(|nav| {
                     let decl_range = nav.focus_or_full_range();
                     Declaration {
-                        access: decl_access(&def, sema.parse(nav.file_id).syntax(), decl_range),
+                        is_mut: decl_mutability(&def, sema.parse(nav.file_id).syntax(), decl_range),
                         nav,
                     }
                 });
@@ -102,7 +102,7 @@ pub(crate) fn find_all_refs(
                         (
                             file_id,
                             refs.into_iter()
-                                .map(|file_ref| (file_ref.range, file_ref.access))
+                                .map(|file_ref| (file_ref.range, file_ref.category))
                                 .collect(),
                         )
                     })
@@ -145,27 +145,19 @@ pub(crate) fn find_defs<'a>(
     })
 }
 
-pub(crate) fn decl_access(
-    def: &Definition,
-    syntax: &SyntaxNode,
-    range: TextRange,
-) -> Option<ReferenceAccess> {
+pub(crate) fn decl_mutability(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> bool {
     match def {
         Definition::Local(_) | Definition::Field(_) => {}
-        _ => return None,
+        _ => return false,
     };
 
-    let stmt = find_node_at_offset::<ast::LetStmt>(syntax, range.start())?;
-    if stmt.initializer().is_some() {
-        let pat = stmt.pat()?;
-        if let ast::Pat::IdentPat(it) = pat {
-            if it.mut_token().is_some() {
-                return Some(ReferenceAccess::Write);
-            }
-        }
+    match find_node_at_offset::<ast::LetStmt>(syntax, range.start()) {
+        Some(stmt) if stmt.initializer().is_some() => match stmt.pat() {
+            Some(ast::Pat::IdentPat(it)) => it.mut_token().is_some(),
+            _ => false,
+        },
+        _ => false,
     }
-
-    None
 }
 
 /// Filter out all non-literal usages for adt-defs
@@ -283,7 +275,7 @@ fn is_lit_name_ref(name_ref: &ast::NameRef) -> bool {
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use ide_db::base_db::FileId;
+    use ide_db::{base_db::FileId, search::ReferenceCategory};
     use stdx::format_to;
 
     use crate::{fixture, SearchScope};
@@ -1095,8 +1087,8 @@ impl Foo {
 
             if let Some(decl) = refs.declaration {
                 format_to!(actual, "{}", decl.nav.debug_render());
-                if let Some(access) = decl.access {
-                    format_to!(actual, " {:?}", access)
+                if decl.is_mut {
+                    format_to!(actual, " {:?}", ReferenceCategory::Write)
                 }
                 actual += "\n\n";
             }

crates/ide_assists/src/handlers/extract_function.rs

@@ -6,7 +6,7 @@ use hir::{HirDisplay, InFile, Local, Semantics, TypeInfo};
 use ide_db::{
     defs::{Definition, NameRefClass},
     helpers::node_ext::{preorder_expr, walk_expr, walk_pat, walk_patterns_in_expr},
-    search::{FileReference, ReferenceAccess, SearchScope},
+    search::{FileReference, ReferenceCategory, SearchScope},
     RootDatabase,
 };
 use itertools::Itertools;
@@ -877,7 +877,7 @@ fn reference_is_exclusive(
     ctx: &AssistContext,
 ) -> bool {
     // we directly modify variable with set: `n = 0`, `n += 1`
-    if reference.access == Some(ReferenceAccess::Write) {
+    if reference.category == Some(ReferenceCategory::Write) {
         return true;
     }