internal: use naming that matches intended use-case

matklad · matklad · commit 46eb03d99aa6 · 2021-10-02T12:18:18.000+03:00
diff --git a/crates/ide/src/highlight_related.rs b/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,7 @@ use crate::{display::TryToNav, references, NavigationTarget};
 #[derive(PartialEq, Eq, Hash)]
 pub struct HighlightedRange {
     pub range: TextRange,
-    pub access: Option<ReferenceAccess>,
+    pub access: Option<ReferenceCategory>,
 }
 
 #[derive(Default, Clone)]
@@ -87,7 +87,7 @@ fn highlight_references(
                 .remove(&file_id)
         })
         .flatten()
-        .map(|FileReference { access, range, .. }| HighlightedRange { range, access });
+        .map(|FileReference { category: access, range, .. }| HighlightedRange { range, access });
 
     let declarations = defs.iter().flat_map(|def| {
         match def {
@@ -355,8 +355,8 @@ mod tests {
                     hl.range,
                     hl.access.map(|it| {
                         match it {
-                            ReferenceAccess::Read => "read",
-                            ReferenceAccess::Write => "write",
+                            ReferenceCategory::Read => "read",
+                            ReferenceCategory::Write => "write",
                         }
                         .to_string()
                     }),
diff --git a/crates/ide/src/lib.rs b/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,
diff --git a/crates/ide/src/references.rs b/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 access: Option<ReferenceCategory>,
 }
 
 // Feature: Find All References
@@ -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(),
                         )
                     })
@@ -149,7 +149,7 @@ pub(crate) fn decl_access(
     def: &Definition,
     syntax: &SyntaxNode,
     range: TextRange,
-) -> Option<ReferenceAccess> {
+) -> Option<ReferenceCategory> {
     match def {
         Definition::Local(_) | Definition::Field(_) => {}
         _ => return None,
@@ -160,7 +160,7 @@ pub(crate) fn decl_access(
         let pat = stmt.pat()?;
         if let ast::Pat::IdentPat(it) = pat {
             if it.mut_token().is_some() {
-                return Some(ReferenceAccess::Write);
+                return Some(ReferenceCategory::Write);
             }
         }
     }
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/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;
     }
 
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
@@ -58,13 +58,18 @@ impl IntoIterator for UsageSearchResult {
 pub struct FileReference {
     pub range: TextRange,
     pub name: ast::NameLike,
-    pub access: Option<ReferenceAccess>,
+    pub category: Option<ReferenceCategory>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum ReferenceAccess {
-    Read,
+pub enum ReferenceCategory {
+    // FIXME: Add this variant and delete the `retain_adt_literal_usages` function.
+    // Create
     Write,
+    Read,
+    // FIXME: Some day should be able to search in doc comments. Would probably
+    // need to switch from enum to bitflags then?
+    // DocComment
 }
 
 /// Generally, `search_scope` returns files that might contain references for the element.
@@ -472,7 +477,7 @@ impl<'a> FindUsages<'a> {
                 let reference = FileReference {
                     range,
                     name: ast::NameLike::NameRef(name_ref.clone()),
-                    access: None,
+                    category: None,
                 };
                 sink(file_id, reference)
             }
@@ -491,7 +496,7 @@ impl<'a> FindUsages<'a> {
                 let reference = FileReference {
                     range,
                     name: ast::NameLike::NameRef(name_ref.clone()),
-                    access: None,
+                    category: None,
                 };
                 sink(file_id, reference)
             }
@@ -510,7 +515,7 @@ impl<'a> FindUsages<'a> {
                 let reference = FileReference {
                     range,
                     name: ast::NameLike::Lifetime(lifetime.clone()),
-                    access: None,
+                    category: None,
                 };
                 sink(file_id, reference)
             }
@@ -529,7 +534,7 @@ impl<'a> FindUsages<'a> {
                 let reference = FileReference {
                     range,
                     name: ast::NameLike::NameRef(name_ref.clone()),
-                    access: reference_access(&def, name_ref),
+                    category: ReferenceCategory::new(&def, name_ref),
                 };
                 sink(file_id, reference)
             }
@@ -539,7 +544,7 @@ impl<'a> FindUsages<'a> {
                     let reference = FileReference {
                         range,
                         name: ast::NameLike::NameRef(name_ref.clone()),
-                        access: reference_access(&def, name_ref),
+                        category: ReferenceCategory::new(&def, name_ref),
                     };
                     sink(file_id, reference)
                 } else {
@@ -550,14 +555,19 @@ impl<'a> FindUsages<'a> {
                 let field = Definition::Field(field);
                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
                 let access = match self.def {
-                    Definition::Field(_) if field == self.def => reference_access(&field, name_ref),
+                    Definition::Field(_) if field == self.def => {
+                        ReferenceCategory::new(&field, name_ref)
+                    }
                     Definition::Local(l) if local == l => {
-                        reference_access(&Definition::Local(local), name_ref)
+                        ReferenceCategory::new(&Definition::Local(local), name_ref)
                     }
                     _ => return false,
                 };
-                let reference =
-                    FileReference { range, name: ast::NameLike::NameRef(name_ref.clone()), access };
+                let reference = FileReference {
+                    range,
+                    name: ast::NameLike::NameRef(name_ref.clone()),
+                    category: access,
+                };
                 sink(file_id, reference)
             }
             _ => false,
@@ -580,14 +590,17 @@ impl<'a> FindUsages<'a> {
                     range,
                     name: ast::NameLike::Name(name.clone()),
                     // FIXME: mutable patterns should have `Write` access
-                    access: Some(ReferenceAccess::Read),
+                    category: Some(ReferenceCategory::Read),
                 };
                 sink(file_id, reference)
             }
             Some(NameClass::ConstReference(def)) if self.def == def => {
                 let FileRange { file_id, range } = self.sema.original_range(name.syntax());
-                let reference =
-                    FileReference { range, name: ast::NameLike::Name(name.clone()), access: None };
+                let reference = FileReference {
+                    range,
+                    name: ast::NameLike::Name(name.clone()),
+                    category: None,
+                };
                 sink(file_id, reference)
             }
             // Resolve trait impl function definitions to the trait definition's version if self.def is the trait definition's
@@ -611,7 +624,7 @@ impl<'a> FindUsages<'a> {
                         let reference = FileReference {
                             range,
                             name: ast::NameLike::Name(name.clone()),
-                            access: None,
+                            category: None,
                         };
                         sink(file_id, reference)
                     })
@@ -642,32 +655,34 @@ fn def_to_ty(sema: &Semantics<RootDatabase>, def: &Definition) -> Option<hir::Ty
     }
 }
 
-fn reference_access(def: &Definition, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
-    // Only Locals and Fields have accesses for now.
-    if !matches!(def, Definition::Local(_) | Definition::Field(_)) {
-        return None;
-    }
+impl ReferenceCategory {
+    fn new(def: &Definition, r: &ast::NameRef) -> Option<ReferenceCategory> {
+        // Only Locals and Fields have accesses for now.
+        if !matches!(def, Definition::Local(_) | Definition::Field(_)) {
+            return None;
+        }
 
-    let mode = name_ref.syntax().ancestors().find_map(|node| {
+        let mode = r.syntax().ancestors().find_map(|node| {
         match_ast! {
             match (node) {
                 ast::BinExpr(expr) => {
                     if matches!(expr.op_kind()?, ast::BinaryOp::Assignment { .. }) {
                         // If the variable or field ends on the LHS's end then it's a Write (covers fields and locals).
                         // FIXME: This is not terribly accurate.
                         if let Some(lhs) = expr.lhs() {
-                            if lhs.syntax().text_range().end() == name_ref.syntax().text_range().end() {
-                                return Some(ReferenceAccess::Write);
+                            if lhs.syntax().text_range().end() == r.syntax().text_range().end() {
+                                return Some(ReferenceCategory::Write);
                             }
                         }
                     }
-                    Some(ReferenceAccess::Read)
+                    Some(ReferenceCategory::Read)
                 },
                 _ => None
             }
         }
     });
 
-    // Default Locals and Fields to read
-    mode.or(Some(ReferenceAccess::Read))
+        // Default Locals and Fields to read
+        mode.or(Some(ReferenceCategory::Read))
+    }
 }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
@@ -9,7 +9,7 @@ use ide::{
     Annotation, AnnotationKind, Assist, AssistKind, CallInfo, Cancellable, CompletionItem,
     CompletionItemKind, CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit,
     Fold, FoldKind, Highlight, HlMod, HlOperator, HlPunct, HlRange, HlTag, Indel, InlayHint,
-    InlayKind, Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity,
+    InlayKind, Markup, NavigationTarget, ReferenceCategory, RenameError, Runnable, Severity,
     SourceChange, StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
@@ -75,11 +75,11 @@ pub(crate) fn structure_node_kind(kind: StructureNodeKind) -> lsp_types::SymbolK
 }
 
 pub(crate) fn document_highlight_kind(
-    reference_access: ReferenceAccess,
+    category: ReferenceCategory,
 ) -> lsp_types::DocumentHighlightKind {
-    match reference_access {
-        ReferenceAccess::Read => lsp_types::DocumentHighlightKind::Read,
-        ReferenceAccess::Write => lsp_types::DocumentHighlightKind::Write,
+    match category {
+        ReferenceCategory::Read => lsp_types::DocumentHighlightKind::Read,
+        ReferenceCategory::Write => lsp_types::DocumentHighlightKind::Write,
     }
 }
 
