src/tools/rust-analyzer/crates/ide-db/src/search.rs

   1 //! Implementation of find-usages functionality.
   2 //!
   3 //! It is based on the standard ide trick: first, we run a fast text search to
   4 //! get a super-set of matches. Then, we we confirm each match using precise
   5 //! name resolution.
   6
   7 use std::{mem, sync::Arc};
   8
   9 use base_db::{FileId, FileRange, SourceDatabase, SourceDatabaseExt};
  10 use hir::{DefWithBody, HasAttrs, HasSource, InFile, ModuleSource, Semantics, Visibility};
  11 use memchr::memmem::Finder;
  12 use once_cell::unsync::Lazy;
  13 use parser::SyntaxKind;
  14 use stdx::hash::NoHashHashMap;
  15 use syntax::{ast, match_ast, AstNode, TextRange, TextSize};
  16
  17 use crate::{
  18     defs::{Definition, NameClass, NameRefClass},
  19     traits::{as_trait_assoc_def, convert_to_def_in_trait},
  20     RootDatabase,
  21 };
  22
  23 #[derive(Debug, Default, Clone)]
  24 pub struct UsageSearchResult {
  25     pub references: NoHashHashMap<FileId, Vec<FileReference>>,
  26 }
  27
  28 impl UsageSearchResult {
  29     pub fn is_empty(&self) -> bool {
  30         self.references.is_empty()
  31     }
  32
  33     pub fn len(&self) -> usize {
  34         self.references.len()
  35     }
  36
  37     pub fn iter(&self) -> impl Iterator<Item = (&FileId, &[FileReference])> + '_ {
  38         self.references.iter().map(|(file_id, refs)| (file_id, &**refs))
  39     }
  40
  41     pub fn file_ranges(&self) -> impl Iterator<Item = FileRange> + '_ {
  42         self.references.iter().flat_map(|(&file_id, refs)| {
  43             refs.iter().map(move |&FileReference { range, .. }| FileRange { file_id, range })
  44         })
  45     }
  46 }
  47
  48 impl IntoIterator for UsageSearchResult {
  49     type Item = (FileId, Vec<FileReference>);
  50     type IntoIter = <NoHashHashMap<FileId, Vec<FileReference>> as IntoIterator>::IntoIter;
  51
  52     fn into_iter(self) -> Self::IntoIter {
  53         self.references.into_iter()
  54     }
  55 }
  56
  57 #[derive(Debug, Clone)]
  58 pub struct FileReference {
  59     /// The range of the reference in the original file
  60     pub range: TextRange,
  61     /// The node of the reference in the (macro-)file
  62     pub name: ast::NameLike,
  63     pub category: Option<ReferenceCategory>,
  64 }
  65
  66 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
  67 pub enum ReferenceCategory {
  68     // FIXME: Add this variant and delete the `retain_adt_literal_usages` function.
  69     // Create
  70     Write,
  71     Read,
  72     Import,
  73     // FIXME: Some day should be able to search in doc comments. Would probably
  74     // need to switch from enum to bitflags then?
  75     // DocComment
  76 }
  77
  78 /// Generally, `search_scope` returns files that might contain references for the element.
  79 /// For `pub(crate)` things it's a crate, for `pub` things it's a crate and dependant crates.
  80 /// In some cases, the location of the references is known to within a `TextRange`,
  81 /// e.g. for things like local variables.
  82 #[derive(Clone, Debug)]
  83 pub struct SearchScope {
  84     entries: NoHashHashMap<FileId, Option<TextRange>>,
  85 }
  86
  87 impl SearchScope {
  88     fn new(entries: NoHashHashMap<FileId, Option<TextRange>>) -> SearchScope {
  89         SearchScope { entries }
  90     }
  91
  92     /// Build a search scope spanning the entire crate graph of files.
  93     fn crate_graph(db: &RootDatabase) -> SearchScope {
  94         let mut entries = NoHashHashMap::default();
  95
  96         let graph = db.crate_graph();
  97         for krate in graph.iter() {
  98             let root_file = graph[krate].root_file_id;
  99             let source_root_id = db.file_source_root(root_file);
 100             let source_root = db.source_root(source_root_id);
 101             entries.extend(source_root.iter().map(|id| (id, None)));
 102         }
 103         SearchScope { entries }
 104     }
 105
 106     /// Build a search scope spanning all the reverse dependencies of the given crate.
 107     fn reverse_dependencies(db: &RootDatabase, of: hir::Crate) -> SearchScope {
 108         let mut entries = NoHashHashMap::default();
 109         for rev_dep in of.transitive_reverse_dependencies(db) {
 110             let root_file = rev_dep.root_file(db);
 111             let source_root_id = db.file_source_root(root_file);
 112             let source_root = db.source_root(source_root_id);
 113             entries.extend(source_root.iter().map(|id| (id, None)));
 114         }
 115         SearchScope { entries }
 116     }
 117
 118     /// Build a search scope spanning the given crate.
 119     fn krate(db: &RootDatabase, of: hir::Crate) -> SearchScope {
 120         let root_file = of.root_file(db);
 121         let source_root_id = db.file_source_root(root_file);
 122         let source_root = db.source_root(source_root_id);
 123         SearchScope { entries: source_root.iter().map(|id| (id, None)).collect() }
 124     }
 125
 126     /// Build a search scope spanning the given module and all its submodules.
 127     fn module_and_children(db: &RootDatabase, module: hir::Module) -> SearchScope {
 128         let mut entries = NoHashHashMap::default();
 129
 130         let (file_id, range) = {
 131             let InFile { file_id, value } = module.definition_source(db);
 132             if let Some((file_id, call_source)) = file_id.original_call_node(db) {
 133                 (file_id, Some(call_source.text_range()))
 134             } else {
 135                 (
 136                     file_id.original_file(db),
 137                     match value {
 138                         ModuleSource::SourceFile(_) => None,
 139                         ModuleSource::Module(it) => Some(it.syntax().text_range()),
 140                         ModuleSource::BlockExpr(it) => Some(it.syntax().text_range()),
 141                     },
 142                 )
 143             }
 144         };
 145         entries.insert(file_id, range);
 146
 147         let mut to_visit: Vec<_> = module.children(db).collect();
 148         while let Some(module) = to_visit.pop() {
 149             if let InFile { file_id, value: ModuleSource::SourceFile(_) } =
 150                 module.definition_source(db)
 151             {
 152                 entries.insert(file_id.original_file(db), None);
 153             }
 154             to_visit.extend(module.children(db));
 155         }
 156         SearchScope { entries }
 157     }
 158
 159     /// Build an empty search scope.
 160     pub fn empty() -> SearchScope {
 161         SearchScope::new(NoHashHashMap::default())
 162     }
 163
 164     /// Build a empty search scope spanning the given file.
 165     pub fn single_file(file: FileId) -> SearchScope {
 166         SearchScope::new(std::iter::once((file, None)).collect())
 167     }
 168
 169     /// Build a empty search scope spanning the text range of the given file.
 170     pub fn file_range(range: FileRange) -> SearchScope {
 171         SearchScope::new(std::iter::once((range.file_id, Some(range.range))).collect())
 172     }
 173
 174     /// Build a empty search scope spanning the given files.
 175     pub fn files(files: &[FileId]) -> SearchScope {
 176         SearchScope::new(files.iter().map(|f| (*f, None)).collect())
 177     }
 178
 179     pub fn intersection(&self, other: &SearchScope) -> SearchScope {
 180         let (mut small, mut large) = (&self.entries, &other.entries);
 181         if small.len() > large.len() {
 182             mem::swap(&mut small, &mut large)
 183         }
 184
 185         let intersect_ranges =
 186             |r1: Option<TextRange>, r2: Option<TextRange>| -> Option<Option<TextRange>> {
 187                 match (r1, r2) {
 188                     (None, r) | (r, None) => Some(r),
 189                     (Some(r1), Some(r2)) => r1.intersect(r2).map(Some),
 190                 }
 191             };
 192         let res = small
 193             .iter()
 194             .filter_map(|(&file_id, &r1)| {
 195                 let &r2 = large.get(&file_id)?;
 196                 let r = intersect_ranges(r1, r2)?;
 197                 Some((file_id, r))
 198             })
 199             .collect();
 200
 201         SearchScope::new(res)
 202     }
 203 }
 204
 205 impl IntoIterator for SearchScope {
 206     type Item = (FileId, Option<TextRange>);
 207     type IntoIter = std::collections::hash_map::IntoIter<FileId, Option<TextRange>>;
 208
 209     fn into_iter(self) -> Self::IntoIter {
 210         self.entries.into_iter()
 211     }
 212 }
 213
 214 impl Definition {
 215     fn search_scope(&self, db: &RootDatabase) -> SearchScope {
 216         let _p = profile::span("search_scope");
 217
 218         if let Definition::BuiltinType(_) = self {
 219             return SearchScope::crate_graph(db);
 220         }
 221
 222         // def is crate root
 223         // FIXME: We don't do searches for crates currently, as a crate does not actually have a single name
 224         if let &Definition::Module(module) = self {
 225             if module.is_crate_root(db) {
 226                 return SearchScope::reverse_dependencies(db, module.krate());
 227             }
 228         }
 229
 230         let module = match self.module(db) {
 231             Some(it) => it,
 232             None => return SearchScope::empty(),
 233         };
 234         let InFile { file_id, value: module_source } = module.definition_source(db);
 235         let file_id = file_id.original_file(db);
 236
 237         if let Definition::Local(var) = self {
 238             let def = match var.parent(db) {
 239                 DefWithBody::Function(f) => f.source(db).map(|src| src.syntax().cloned()),
 240                 DefWithBody::Const(c) => c.source(db).map(|src| src.syntax().cloned()),
 241                 DefWithBody::Static(s) => s.source(db).map(|src| src.syntax().cloned()),
 242                 DefWithBody::Variant(v) => v.source(db).map(|src| src.syntax().cloned()),
 243             };
 244             return match def {
 245                 Some(def) => SearchScope::file_range(def.as_ref().original_file_range(db)),
 246                 None => SearchScope::single_file(file_id),
 247             };
 248         }
 249
 250         if let Definition::SelfType(impl_) = self {
 251             return match impl_.source(db).map(|src| src.syntax().cloned()) {
 252                 Some(def) => SearchScope::file_range(def.as_ref().original_file_range(db)),
 253                 None => SearchScope::single_file(file_id),
 254             };
 255         }
 256
 257         if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
 258             let def = match param.parent(db) {
 259                 hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
 260                 hir::GenericDef::Adt(it) => it.source(db).map(|src| src.syntax().cloned()),
 261                 hir::GenericDef::Trait(it) => it.source(db).map(|src| src.syntax().cloned()),
 262                 hir::GenericDef::TypeAlias(it) => it.source(db).map(|src| src.syntax().cloned()),
 263                 hir::GenericDef::Impl(it) => it.source(db).map(|src| src.syntax().cloned()),
 264                 hir::GenericDef::Variant(it) => it.source(db).map(|src| src.syntax().cloned()),
 265                 hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),
 266             };
 267             return match def {
 268                 Some(def) => SearchScope::file_range(def.as_ref().original_file_range(db)),
 269                 None => SearchScope::single_file(file_id),
 270             };
 271         }
 272
 273         if let Definition::Macro(macro_def) = self {
 274             return match macro_def.kind(db) {
 275                 hir::MacroKind::Declarative => {
 276                     if macro_def.attrs(db).by_key("macro_export").exists() {
 277                         SearchScope::reverse_dependencies(db, module.krate())
 278                     } else {
 279                         SearchScope::krate(db, module.krate())
 280                     }
 281                 }
 282                 hir::MacroKind::BuiltIn => SearchScope::crate_graph(db),
 283                 hir::MacroKind::Derive | hir::MacroKind::Attr | hir::MacroKind::ProcMacro => {
 284                     SearchScope::reverse_dependencies(db, module.krate())
 285                 }
 286             };
 287         }
 288
 289         if let Definition::DeriveHelper(_) = self {
 290             return SearchScope::reverse_dependencies(db, module.krate());
 291         }
 292
 293         let vis = self.visibility(db);
 294         if let Some(Visibility::Public) = vis {
 295             return SearchScope::reverse_dependencies(db, module.krate());
 296         }
 297         if let Some(Visibility::Module(module)) = vis {
 298             return SearchScope::module_and_children(db, module.into());
 299         }
 300
 301         let range = match module_source {
 302             ModuleSource::Module(m) => Some(m.syntax().text_range()),
 303             ModuleSource::BlockExpr(b) => Some(b.syntax().text_range()),
 304             ModuleSource::SourceFile(_) => None,
 305         };
 306         match range {
 307             Some(range) => SearchScope::file_range(FileRange { file_id, range }),
 308             None => SearchScope::single_file(file_id),
 309         }
 310     }
 311
 312     pub fn usages<'a>(self, sema: &'a Semantics<'_, RootDatabase>) -> FindUsages<'a> {
 313         FindUsages {
 314             local_repr: match self {
 315                 Definition::Local(local) => Some(local.representative(sema.db)),
 316                 _ => None,
 317             },
 318             def: self,
 319             trait_assoc_def: as_trait_assoc_def(sema.db, self),
 320             sema,
 321             scope: None,
 322             include_self_kw_refs: None,
 323             search_self_mod: false,
 324         }
 325     }
 326 }
 327
 328 #[derive(Clone)]
 329 pub struct FindUsages<'a> {
 330     def: Definition,
 331     /// If def is an assoc item from a trait or trait impl, this is the corresponding item of the trait definition
 332     trait_assoc_def: Option<Definition>,
 333     sema: &'a Semantics<'a, RootDatabase>,
 334     scope: Option<SearchScope>,
 335     include_self_kw_refs: Option<hir::Type>,
 336     local_repr: Option<hir::Local>,
 337     search_self_mod: bool,
 338 }
 339
 340 impl<'a> FindUsages<'a> {
 341     /// Enable searching for `Self` when the definition is a type or `self` for modules.
 342     pub fn include_self_refs(mut self) -> FindUsages<'a> {
 343         self.include_self_kw_refs = def_to_ty(self.sema, &self.def);
 344         self.search_self_mod = true;
 345         self
 346     }
 347
 348     /// Limit the search to a given [`SearchScope`].
 349     pub fn in_scope(self, scope: SearchScope) -> FindUsages<'a> {
 350         self.set_scope(Some(scope))
 351     }
 352
 353     /// Limit the search to a given [`SearchScope`].
 354     pub fn set_scope(mut self, scope: Option<SearchScope>) -> FindUsages<'a> {
 355         assert!(self.scope.is_none());
 356         self.scope = scope;
 357         self
 358     }
 359
 360     pub fn at_least_one(&self) -> bool {
 361         let mut found = false;
 362         self.search(&mut |_, _| {
 363             found = true;
 364             true
 365         });
 366         found
 367     }
 368
 369     pub fn all(self) -> UsageSearchResult {
 370         let mut res = UsageSearchResult::default();
 371         self.search(&mut |file_id, reference| {
 372             res.references.entry(file_id).or_default().push(reference);
 373             false
 374         });
 375         res
 376     }
 377
 378     fn search(&self, sink: &mut dyn FnMut(FileId, FileReference) -> bool) {
 379         let _p = profile::span("FindUsages:search");
 380         let sema = self.sema;
 381
 382         let search_scope = {
 383             let base = self.trait_assoc_def.unwrap_or(self.def).search_scope(sema.db);
 384             match &self.scope {
 385                 None => base,
 386                 Some(scope) => base.intersection(scope),
 387             }
 388         };
 389
 390         let name = match self.def {
 391             // special case crate modules as these do not have a proper name
 392             Definition::Module(module) if module.is_crate_root(self.sema.db) => {
 393                 // FIXME: This assumes the crate name is always equal to its display name when it really isn't
 394                 module
 395                     .krate()
 396                     .display_name(self.sema.db)
 397                     .map(|crate_name| crate_name.crate_name().as_smol_str().clone())
 398             }
 399             _ => {
 400                 let self_kw_refs = || {
 401                     self.include_self_kw_refs.as_ref().and_then(|ty| {
 402                         ty.as_adt()
 403                             .map(|adt| adt.name(self.sema.db))
 404                             .or_else(|| ty.as_builtin().map(|builtin| builtin.name()))
 405                     })
 406                 };
 407                 // We need to unescape the name in case it is written without "r#" in earlier
 408                 // editions of Rust where it isn't a keyword.
 409                 self.def.name(sema.db).or_else(self_kw_refs).map(|it| it.unescaped().to_smol_str())
 410             }
 411         };
 412         let name = match &name {
 413             Some(s) => s.as_str(),
 414             None => return,
 415         };
 416         let finder = &Finder::new(name);
 417         let include_self_kw_refs =
 418             self.include_self_kw_refs.as_ref().map(|ty| (ty, Finder::new("Self")));
 419
 420         // for<'a> |text: &'a str, name: &'a str, search_range: TextRange| -> impl Iterator<Item = TextSize> + 'a { ... }
 421         fn match_indices<'a>(
 422             text: &'a str,
 423             finder: &'a Finder<'a>,
 424             search_range: TextRange,
 425         ) -> impl Iterator<Item = TextSize> + 'a {
 426             finder.find_iter(text.as_bytes()).filter_map(move |idx| {
 427                 let offset: TextSize = idx.try_into().unwrap();
 428                 if !search_range.contains_inclusive(offset) {
 429                     return None;
 430                 }
 431                 Some(offset)
 432             })
 433         }
 434
 435         // for<'a> |scope: &'a SearchScope| -> impl Iterator<Item = (Arc<String>, FileId, TextRange)> + 'a { ... }
 436         fn scope_files<'a>(
 437             sema: &'a Semantics<'_, RootDatabase>,
 438             scope: &'a SearchScope,
 439         ) -> impl Iterator<Item = (Arc<String>, FileId, TextRange)> + 'a {
 440             scope.entries.iter().map(|(&file_id, &search_range)| {
 441                 let text = sema.db.file_text(file_id);
 442                 let search_range =
 443                     search_range.unwrap_or_else(|| TextRange::up_to(TextSize::of(text.as_str())));
 444
 445                 (text, file_id, search_range)
 446             })
 447         }
 448
 449         // FIXME: There should be optimization potential here
 450         // Currently we try to descend everything we find which
 451         // means we call `Semantics::descend_into_macros` on
 452         // every textual hit. That function is notoriously
 453         // expensive even for things that do not get down mapped
 454         // into macros.
 455         for (text, file_id, search_range) in scope_files(sema, &search_scope) {
 456             let tree = Lazy::new(move || sema.parse(file_id).syntax().clone());
 457
 458             // Search for occurrences of the items name
 459             for offset in match_indices(&text, finder, search_range) {
 460                 for name in sema.find_nodes_at_offset_with_descend(&tree, offset) {
 461                     if match name {
 462                         ast::NameLike::NameRef(name_ref) => self.found_name_ref(&name_ref, sink),
 463                         ast::NameLike::Name(name) => self.found_name(&name, sink),
 464                         ast::NameLike::Lifetime(lifetime) => self.found_lifetime(&lifetime, sink),
 465                     } {
 466                         return;
 467                     }
 468                 }
 469             }
 470             // Search for occurrences of the `Self` referring to our type
 471             if let Some((self_ty, finder)) = &include_self_kw_refs {
 472                 for offset in match_indices(&text, finder, search_range) {
 473                     for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {
 474                         if self.found_self_ty_name_ref(self_ty, &name_ref, sink) {
 475                             return;
 476                         }
 477                     }
 478                 }
 479             }
 480         }
 481
 482         // Search for `super` and `crate` resolving to our module
 483         match self.def {
 484             Definition::Module(module) => {
 485                 let scope = search_scope
 486                     .intersection(&SearchScope::module_and_children(self.sema.db, module));
 487
 488                 let is_crate_root =
 489                     module.is_crate_root(self.sema.db).then(|| Finder::new("crate"));
 490                 let finder = &Finder::new("super");
 491
 492                 for (text, file_id, search_range) in scope_files(sema, &scope) {
 493                     let tree = Lazy::new(move || sema.parse(file_id).syntax().clone());
 494
 495                     for offset in match_indices(&text, finder, search_range) {
 496                         for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {
 497                             if self.found_name_ref(&name_ref, sink) {
 498                                 return;
 499                             }
 500                         }
 501                     }
 502                     if let Some(finder) = &is_crate_root {
 503                         for offset in match_indices(&text, finder, search_range) {
 504                             for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {
 505                                 if self.found_name_ref(&name_ref, sink) {
 506                                     return;
 507                                 }
 508                             }
 509                         }
 510                     }
 511                 }
 512             }
 513             _ => (),
 514         }
 515
 516         // search for module `self` references in our module's definition source
 517         match self.def {
 518             Definition::Module(module) if self.search_self_mod => {
 519                 let src = module.definition_source(sema.db);
 520                 let file_id = src.file_id.original_file(sema.db);
 521                 let (file_id, search_range) = match src.value {
 522                     ModuleSource::Module(m) => (file_id, Some(m.syntax().text_range())),
 523                     ModuleSource::BlockExpr(b) => (file_id, Some(b.syntax().text_range())),
 524                     ModuleSource::SourceFile(_) => (file_id, None),
 525                 };
 526
 527                 let search_range = if let Some(&range) = search_scope.entries.get(&file_id) {
 528                     match (range, search_range) {
 529                         (None, range) | (range, None) => range,
 530                         (Some(range), Some(search_range)) => match range.intersect(search_range) {
 531                             Some(range) => Some(range),
 532                             None => return,
 533                         },
 534                     }
 535                 } else {
 536                     return;
 537                 };
 538
 539                 let text = sema.db.file_text(file_id);
 540                 let search_range =
 541                     search_range.unwrap_or_else(|| TextRange::up_to(TextSize::of(text.as_str())));
 542
 543                 let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
 544                 let finder = &Finder::new("self");
 545
 546                 for offset in match_indices(&text, finder, search_range) {
 547                     for name_ref in sema.find_nodes_at_offset_with_descend(&tree, offset) {
 548                         if self.found_self_module_name_ref(&name_ref, sink) {
 549                             return;
 550                         }
 551                     }
 552                 }
 553             }
 554             _ => {}
 555         }
 556     }
 557
 558     fn found_self_ty_name_ref(
 559         &self,
 560         self_ty: &hir::Type,
 561         name_ref: &ast::NameRef,
 562         sink: &mut dyn FnMut(FileId, FileReference) -> bool,
 563     ) -> bool {
 564         match NameRefClass::classify(self.sema, name_ref) {
 565             Some(NameRefClass::Definition(Definition::SelfType(impl_)))
 566                 if impl_.self_ty(self.sema.db) == *self_ty =>
 567             {
 568                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 569                 let reference = FileReference {
 570                     range,
 571                     name: ast::NameLike::NameRef(name_ref.clone()),
 572                     category: None,
 573                 };
 574                 sink(file_id, reference)
 575             }
 576             _ => false,
 577         }
 578     }
 579
 580     fn found_self_module_name_ref(
 581         &self,
 582         name_ref: &ast::NameRef,
 583         sink: &mut dyn FnMut(FileId, FileReference) -> bool,
 584     ) -> bool {
 585         match NameRefClass::classify(self.sema, name_ref) {
 586             Some(NameRefClass::Definition(def @ Definition::Module(_))) if def == self.def => {
 587                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 588                 let reference = FileReference {
 589                     range,
 590                     name: ast::NameLike::NameRef(name_ref.clone()),
 591                     category: is_name_ref_in_import(name_ref).then(|| ReferenceCategory::Import),
 592                 };
 593                 sink(file_id, reference)
 594             }
 595             _ => false,
 596         }
 597     }
 598
 599     fn found_lifetime(
 600         &self,
 601         lifetime: &ast::Lifetime,
 602         sink: &mut dyn FnMut(FileId, FileReference) -> bool,
 603     ) -> bool {
 604         match NameRefClass::classify_lifetime(self.sema, lifetime) {
 605             Some(NameRefClass::Definition(def)) if def == self.def => {
 606                 let FileRange { file_id, range } = self.sema.original_range(lifetime.syntax());
 607                 let reference = FileReference {
 608                     range,
 609                     name: ast::NameLike::Lifetime(lifetime.clone()),
 610                     category: None,
 611                 };
 612                 sink(file_id, reference)
 613             }
 614             _ => false,
 615         }
 616     }
 617
 618     fn found_name_ref(
 619         &self,
 620         name_ref: &ast::NameRef,
 621         sink: &mut dyn FnMut(FileId, FileReference) -> bool,
 622     ) -> bool {
 623         match NameRefClass::classify(self.sema, name_ref) {
 624             Some(NameRefClass::Definition(def @ Definition::Local(local)))
 625                 if matches!(
 626                     self.local_repr, Some(repr) if repr == local.representative(self.sema.db)
 627                 ) =>
 628             {
 629                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 630                 let reference = FileReference {
 631                     range,
 632                     name: ast::NameLike::NameRef(name_ref.clone()),
 633                     category: ReferenceCategory::new(&def, name_ref),
 634                 };
 635                 sink(file_id, reference)
 636             }
 637             Some(NameRefClass::Definition(def))
 638                 if match self.trait_assoc_def {
 639                     Some(trait_assoc_def) => {
 640                         // we have a trait assoc item, so force resolve all assoc items to their trait version
 641                         convert_to_def_in_trait(self.sema.db, def) == trait_assoc_def
 642                     }
 643                     None => self.def == def,
 644                 } =>
 645             {
 646                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 647                 let reference = FileReference {
 648                     range,
 649                     name: ast::NameLike::NameRef(name_ref.clone()),
 650                     category: ReferenceCategory::new(&def, name_ref),
 651                 };
 652                 sink(file_id, reference)
 653             }
 654             Some(NameRefClass::Definition(def)) if self.include_self_kw_refs.is_some() => {
 655                 if self.include_self_kw_refs == def_to_ty(self.sema, &def) {
 656                     let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 657                     let reference = FileReference {
 658                         range,
 659                         name: ast::NameLike::NameRef(name_ref.clone()),
 660                         category: ReferenceCategory::new(&def, name_ref),
 661                     };
 662                     sink(file_id, reference)
 663                 } else {
 664                     false
 665                 }
 666             }
 667             Some(NameRefClass::FieldShorthand { local_ref: local, field_ref: field }) => {
 668                 let field = Definition::Field(field);
 669                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
 670                 let access = match self.def {
 671                     Definition::Field(_) if field == self.def => {
 672                         ReferenceCategory::new(&field, name_ref)
 673                     }
 674                     Definition::Local(_) if matches!(self.local_repr, Some(repr) if repr == local.representative(self.sema.db)) => {
 675                         ReferenceCategory::new(&Definition::Local(local), name_ref)
 676                     }
 677                     _ => return false,
 678                 };
 679                 let reference = FileReference {
 680                     range,
 681                     name: ast::NameLike::NameRef(name_ref.clone()),
 682                     category: access,
 683                 };
 684                 sink(file_id, reference)
 685             }
 686             _ => false,
 687         }
 688     }
 689
 690     fn found_name(
 691         &self,
 692         name: &ast::Name,
 693         sink: &mut dyn FnMut(FileId, FileReference) -> bool,
 694     ) -> bool {
 695         match NameClass::classify(self.sema, name) {
 696             Some(NameClass::PatFieldShorthand { local_def: _, field_ref })
 697                 if matches!(
 698                     self.def, Definition::Field(_) if Definition::Field(field_ref) == self.def
 699                 ) =>
 700             {
 701                 let FileRange { file_id, range } = self.sema.original_range(name.syntax());
 702                 let reference = FileReference {
 703                     range,
 704                     name: ast::NameLike::Name(name.clone()),
 705                     // FIXME: mutable patterns should have `Write` access
 706                     category: Some(ReferenceCategory::Read),
 707                 };
 708                 sink(file_id, reference)
 709             }
 710             Some(NameClass::ConstReference(def)) if self.def == def => {
 711                 let FileRange { file_id, range } = self.sema.original_range(name.syntax());
 712                 let reference = FileReference {
 713                     range,
 714                     name: ast::NameLike::Name(name.clone()),
 715                     category: None,
 716                 };
 717                 sink(file_id, reference)
 718             }
 719             Some(NameClass::Definition(def @ Definition::Local(local))) if def != self.def => {
 720                 if matches!(
 721                     self.local_repr,
 722                     Some(repr) if local.representative(self.sema.db) == repr
 723                 ) {
 724                     let FileRange { file_id, range } = self.sema.original_range(name.syntax());
 725                     let reference = FileReference {
 726                         range,
 727                         name: ast::NameLike::Name(name.clone()),
 728                         category: None,
 729                     };
 730                     return sink(file_id, reference);
 731                 }
 732                 false
 733             }
 734             Some(NameClass::Definition(def)) if def != self.def => {
 735                 // if the def we are looking for is a trait (impl) assoc item, we'll have to resolve the items to trait definition assoc item
 736                 if !matches!(
 737                     self.trait_assoc_def,
 738                     Some(trait_assoc_def)
 739                         if convert_to_def_in_trait(self.sema.db, def) == trait_assoc_def
 740                 ) {
 741                     return false;
 742                 }
 743                 let FileRange { file_id, range } = self.sema.original_range(name.syntax());
 744                 let reference = FileReference {
 745                     range,
 746                     name: ast::NameLike::Name(name.clone()),
 747                     category: None,
 748                 };
 749                 sink(file_id, reference)
 750             }
 751             _ => false,
 752         }
 753     }
 754 }
 755
 756 fn def_to_ty(sema: &Semantics<'_, RootDatabase>, def: &Definition) -> Option<hir::Type> {
 757     match def {
 758         Definition::Adt(adt) => Some(adt.ty(sema.db)),
 759         Definition::TypeAlias(it) => Some(it.ty(sema.db)),
 760         Definition::BuiltinType(it) => Some(it.ty(sema.db)),
 761         Definition::SelfType(it) => Some(it.self_ty(sema.db)),
 762         _ => None,
 763     }
 764 }
 765
 766 impl ReferenceCategory {
 767     fn new(def: &Definition, r: &ast::NameRef) -> Option<ReferenceCategory> {
 768         // Only Locals and Fields have accesses for now.
 769         if !matches!(def, Definition::Local(_) | Definition::Field(_)) {
 770             return is_name_ref_in_import(r).then(|| ReferenceCategory::Import);
 771         }
 772
 773         let mode = r.syntax().ancestors().find_map(|node| {
 774         match_ast! {
 775             match node {
 776                 ast::BinExpr(expr) => {
 777                     if matches!(expr.op_kind()?, ast::BinaryOp::Assignment { .. }) {
 778                         // If the variable or field ends on the LHS's end then it's a Write (covers fields and locals).
 779                         // FIXME: This is not terribly accurate.
 780                         if let Some(lhs) = expr.lhs() {
 781                             if lhs.syntax().text_range().end() == r.syntax().text_range().end() {
 782                                 return Some(ReferenceCategory::Write);
 783                             }
 784                         }
 785                     }
 786                     Some(ReferenceCategory::Read)
 787                 },
 788                 _ => None
 789             }
 790         }
 791     });
 792
 793         // Default Locals and Fields to read
 794         mode.or(Some(ReferenceCategory::Read))
 795     }
 796 }
 797
 798 fn is_name_ref_in_import(name_ref: &ast::NameRef) -> bool {
 799     name_ref
 800         .syntax()
 801         .parent()
 802         .and_then(ast::PathSegment::cast)
 803         .and_then(|it| it.parent_path().top_path().syntax().parent())
 804         .map_or(false, |it| it.kind() == SyntaxKind::USE_TREE)
 805 }