1 files changed, 197 insertions, 327 deletions

diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 84c2eb793..f35d835ac 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -1,13 +1,29 @@
-//! FIXME: write short doc here
-
-use hir::{Either, ModuleSource};
-use ra_db::SourceDatabase;
-use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode};
-use relative_path::{RelativePath, RelativePathBuf};
-
-use crate::{
-    db::RootDatabase, FileId, FilePosition, FileRange, FileSystemEdit, NavigationTarget, RangeInfo,
-    SourceChange, SourceFileEdit, TextRange,
+//! This module implements a reference search.
+//! First, the element at the cursor position must be either an `ast::Name`
+//! or `ast::NameRef`. If it's a `ast::NameRef`, at the classification step we
+//! try to resolve the direct tree parent of this element, otherwise we
+//! already have a definition and just need to get its HIR together with
+//! some information that is needed for futher steps of searching.
+//! After that, we collect files that might contain references and look
+//! for text occurrences of the identifier. If there's an `ast::NameRef`
+//! at the index that the match starts at and its tree parent is
+//! resolved to the search element definition, we get a reference.
+
+mod classify;
+mod name_definition;
+mod rename;
+mod search_scope;
+
+use once_cell::unsync::Lazy;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode, TextUnit};
+
+use crate::{db::RootDatabase, FilePosition, FileRange, NavigationTarget, RangeInfo};
+
+pub(crate) use self::{
+    classify::{classify_name, classify_name_ref},
+    name_definition::{NameDefinition, NameKind},
+    rename::rename,
 };
 
 #[derive(Debug, Clone)]
@@ -52,161 +68,82 @@ pub(crate) fn find_all_refs(
     position: FilePosition,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
-    let RangeInfo { range, info: (binding, analyzer) } = find_binding(db, &parse.tree(), position)?;
-    let declaration = NavigationTarget::from_bind_pat(position.file_id, &binding);
-
-    let references = analyzer
-        .find_all_refs(&binding)
-        .into_iter()
-        .map(move |ref_desc| FileRange { file_id: position.file_id, range: ref_desc.range })
-        .collect::<Vec<_>>();
-
-    return Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }));
-
-    fn find_binding<'a>(
-        db: &RootDatabase,
-        source_file: &SourceFile,
-        position: FilePosition,
-    ) -> Option<RangeInfo<(ast::BindPat, hir::SourceAnalyzer)>> {
-        let syntax = source_file.syntax();
-        if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
-            let range = binding.syntax().text_range();
-            let analyzer = hir::SourceAnalyzer::new(db, position.file_id, binding.syntax(), None);
-            return Some(RangeInfo::new(range, (binding, analyzer)));
-        };
-        let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
-        let range = name_ref.syntax().text_range();
-        let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
-        let resolved = analyzer.resolve_local_name(&name_ref)?;
-        if let Either::A(ptr) = resolved.ptr() {
-            if let ast::Pat::BindPat(binding) = ptr.to_node(source_file.syntax()) {
-                return Some(RangeInfo::new(range, (binding, analyzer)));
-            }
-        }
-        None
-    }
-}
+    let syntax = parse.tree().syntax().clone();
+    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
+
+    let declaration = match def.kind {
+        NameKind::Macro(mac) => NavigationTarget::from_macro_def(db, mac),
+        NameKind::Field(field) => NavigationTarget::from_field(db, field),
+        NameKind::AssocItem(assoc) => NavigationTarget::from_assoc_item(db, assoc),
+        NameKind::Def(def) => NavigationTarget::from_def(db, def)?,
+        NameKind::SelfType(ref ty) => match ty.as_adt() {
+            Some((def_id, _)) => NavigationTarget::from_adt_def(db, def_id),
+            None => return None,
+        },
+        NameKind::Pat((_, pat)) => NavigationTarget::from_pat(db, position.file_id, pat),
+        NameKind::SelfParam(par) => NavigationTarget::from_self_param(position.file_id, par),
+        NameKind::GenericParam(_) => return None,
+    };
 
-pub(crate) fn rename(
-    db: &RootDatabase,
-    position: FilePosition,
-    new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
-    let parse = db.parse(position.file_id);
-    if let Some((ast_name, ast_module)) =
-        find_name_and_module_at_offset(parse.tree().syntax(), position)
-    {
-        let range = ast_name.syntax().text_range();
-        rename_mod(db, &ast_name, &ast_module, position, new_name)
-            .map(|info| RangeInfo::new(range, info))
-    } else {
-        rename_reference(db, position, new_name)
-    }
+    let references = process_definition(db, def, name);
+
+    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
 }
 
-fn find_name_and_module_at_offset(
+fn find_name<'a>(
+    db: &RootDatabase,
     syntax: &SyntaxNode,
     position: FilePosition,
-) -> Option<(ast::Name, ast::Module)> {
-    let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
-    let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
-    Some((ast_name, ast_module))
-}
-
-fn source_edit_from_file_id_range(
-    file_id: FileId,
-    range: TextRange,
-    new_name: &str,
-) -> SourceFileEdit {
-    SourceFileEdit {
-        file_id,
-        edit: {
-            let mut builder = ra_text_edit::TextEditBuilder::default();
-            builder.replace(range, new_name.into());
-            builder.finish()
-        },
+) -> Option<RangeInfo<(String, NameDefinition)>> {
+    if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
+        let def = classify_name(db, position.file_id, &name)?;
+        let range = name.syntax().text_range();
+        return Some(RangeInfo::new(range, (name.text().to_string(), def)));
     }
+    let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
+    let def = classify_name_ref(db, position.file_id, &name_ref)?;
+    let range = name_ref.syntax().text_range();
+    Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
 }
 
-fn rename_mod(
-    db: &RootDatabase,
-    ast_name: &ast::Name,
-    ast_module: &ast::Module,
-    position: FilePosition,
-    new_name: &str,
-) -> Option<SourceChange> {
-    let mut source_file_edits = Vec::new();
-    let mut file_system_edits = Vec::new();
-    let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
-    if let Some(module) = hir::Module::from_declaration(db, module_src) {
-        let src = module.definition_source(db);
-        let file_id = src.file_id.as_original_file();
-        match src.ast {
-            ModuleSource::SourceFile(..) => {
-                let mod_path: RelativePathBuf = db.file_relative_path(file_id);
-                // mod is defined in path/to/dir/mod.rs
-                let dst_path = if mod_path.file_stem() == Some("mod") {
-                    mod_path
-                        .parent()
-                        .and_then(|p| p.parent())
-                        .or_else(|| Some(RelativePath::new("")))
-                        .map(|p| p.join(new_name).join("mod.rs"))
-                } else {
-                    Some(mod_path.with_file_name(new_name).with_extension("rs"))
-                };
-                if let Some(path) = dst_path {
-                    let move_file = FileSystemEdit::MoveFile {
-                        src: file_id,
-                        dst_source_root: db.file_source_root(position.file_id),
-                        dst_path: path,
-                    };
-                    file_system_edits.push(move_file);
+fn process_definition(db: &RootDatabase, def: NameDefinition, name: String) -> Vec<FileRange> {
+    let pat = name.as_str();
+    let scope = def.search_scope(db);
+    let mut refs = vec![];
+
+    for (file_id, search_range) in scope {
+        let text = db.file_text(file_id);
+        let parse = Lazy::new(|| SourceFile::parse(&text));
+
+        for (idx, _) in text.match_indices(pat) {
+            let offset = TextUnit::from_usize(idx);
+
+            if let Some(name_ref) =
+                find_node_at_offset::<ast::NameRef>(parse.tree().syntax(), offset)
+            {
+                let range = name_ref.syntax().text_range();
+                if let Some(search_range) = search_range {
+                    if !range.is_subrange(&search_range) {
+                        continue;
+                    }
+                }
+                if let Some(d) = classify_name_ref(db, file_id, &name_ref) {
+                    if d == def {
+                        refs.push(FileRange { file_id, range });
+                    }
                 }
             }
-            ModuleSource::Module(..) => {}
         }
     }
-
-    let edit = SourceFileEdit {
-        file_id: position.file_id,
-        edit: {
-            let mut builder = ra_text_edit::TextEditBuilder::default();
-            builder.replace(ast_name.syntax().text_range(), new_name.into());
-            builder.finish()
-        },
-    };
-    source_file_edits.push(edit);
-
-    Some(SourceChange::from_edits("rename", source_file_edits, file_system_edits))
-}
-
-fn rename_reference(
-    db: &RootDatabase,
-    position: FilePosition,
-    new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
-    let RangeInfo { range, info: refs } = find_all_refs(db, position)?;
-
-    let edit = refs
-        .into_iter()
-        .map(|range| source_edit_from_file_id_range(range.file_id, range.range, new_name))
-        .collect::<Vec<_>>();
-
-    if edit.is_empty() {
-        return None;
-    }
-
-    Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
+    refs
 }
 
 #[cfg(test)]
 mod tests {
     use crate::{
-        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
+        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position,
         ReferenceSearchResult,
     };
-    use insta::assert_debug_snapshot;
-    use test_utils::assert_eq_text;
 
     #[test]
     fn test_find_all_refs_for_local() {
@@ -249,211 +186,144 @@ mod tests {
         assert_eq!(refs.len(), 2);
     }
 
-    fn get_all_refs(text: &str) -> ReferenceSearchResult {
-        let (analysis, position) = single_file_with_position(text);
-        analysis.find_all_refs(position).unwrap().unwrap()
-    }
-
     #[test]
-    fn test_rename_for_local() {
-        test_rename(
-            r#"
-    fn main() {
-        let mut i = 1;
-        let j = 1;
-        i = i<|> + j;
-
-        {
-            i = 0;
-        }
-
-        i = 5;
-    }"#,
-            "k",
-            r#"
-    fn main() {
-        let mut k = 1;
-        let j = 1;
-        k = k + j;
+    fn test_find_all_refs_field_name() {
+        let code = r#"
+            //- /lib.rs
+            struct Foo {
+                pub spam<|>: u32,
+            }
 
-        {
-            k = 0;
-        }
+            fn main(s: Foo) {
+                let f = s.spam;
+            }
+        "#;
 
-        k = 5;
-    }"#,
-        );
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 2);
     }
 
     #[test]
-    fn test_rename_for_param_inside() {
-        test_rename(
-            r#"
-    fn foo(i : u32) -> u32 {
-        i<|>
-    }"#,
-            "j",
-            r#"
-    fn foo(j : u32) -> u32 {
-        j
-    }"#,
-        );
-    }
+    fn test_find_all_refs_impl_item_name() {
+        let code = r#"
+            //- /lib.rs
+            struct Foo;
+            impl Foo {
+                fn f<|>(&self) {  }
+            }
+        "#;
 
-    #[test]
-    fn test_rename_refs_for_fn_param() {
-        test_rename(
-            r#"
-    fn foo(i<|> : u32) -> u32 {
-        i
-    }"#,
-            "new_name",
-            r#"
-    fn foo(new_name : u32) -> u32 {
-        new_name
-    }"#,
-        );
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 1);
     }
 
     #[test]
-    fn test_rename_for_mut_param() {
-        test_rename(
-            r#"
-    fn foo(mut i<|> : u32) -> u32 {
-        i
-    }"#,
-            "new_name",
-            r#"
-    fn foo(mut new_name : u32) -> u32 {
-        new_name
-    }"#,
-        );
+    fn test_find_all_refs_enum_var_name() {
+        let code = r#"
+            //- /lib.rs
+            enum Foo {
+                A,
+                B<|>,
+                C,
+            }
+        "#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 1);
     }
 
     #[test]
-    fn test_rename_mod() {
-        let (analysis, position) = analysis_and_position(
-            "
+    fn test_find_all_refs_two_modules() {
+        let code = r#"
             //- /lib.rs
-            mod bar;
+            pub mod foo;
+            pub mod bar;
+
+            fn f() {
+                let i = foo::Foo { n: 5 };
+            }
+
+            //- /foo.rs
+            use crate::bar;
+
+            pub struct Foo {
+                pub n: u32,
+            }
+
+            fn f() {
+                let i = bar::Bar { n: 5 };
+            }
 
             //- /bar.rs
+            use crate::foo;
+
+            pub struct Bar {
+                pub n: u32,
+            }
+
+            fn f() {
+                let i = foo::Foo<|> { n: 5 };
+            }
+        "#;
+
+        let (analysis, pos) = analysis_and_position(code);
+        let refs = analysis.find_all_refs(pos).unwrap().unwrap();
+        assert_eq!(refs.len(), 3);
+    }
+
+    // `mod foo;` is not in the results because `foo` is an `ast::Name`.
+    // So, there are two references: the first one is a definition of the `foo` module,
+    // which is the whole `foo.rs`, and the second one is in `use foo::Foo`.
+    #[test]
+    fn test_find_all_refs_decl_module() {
+        let code = r#"
+            //- /lib.rs
             mod foo<|>;
 
-            //- /bar/foo.rs
-            // emtpy
-            ",
-        );
-        let new_name = "foo2";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert_debug_snapshot!(&source_change,
-@r###"
-        Some(
-            RangeInfo {
-                range: [4; 7),
-                info: SourceChange {
-                    label: "rename",
-                    source_file_edits: [
-                        SourceFileEdit {
-                            file_id: FileId(
-                                2,
-                            ),
-                            edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: [4; 7),
-                                        insert: "foo2",
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                    file_system_edits: [
-                        MoveFile {
-                            src: FileId(
-                                3,
-                            ),
-                            dst_source_root: SourceRootId(
-                                0,
-                            ),
-                            dst_path: "bar/foo2.rs",
-                        },
-                    ],
-                    cursor_position: None,
-                },
-            },
-        )
-        "###);
+            use foo::Foo;
+
+            fn f() {
+                let i = Foo { n: 5 };
+            }
+
+            //- /foo.rs
+            pub struct Foo {
+                pub n: u32,
+            }
+        "#;
+
+        let (analysis, pos) = analysis_and_position(code);
+        let refs = analysis.find_all_refs(pos).unwrap().unwrap();
+        assert_eq!(refs.len(), 2);
     }
 
     #[test]
-    fn test_rename_mod_in_dir() {
-        let (analysis, position) = analysis_and_position(
-            "
+    fn test_find_all_refs_super_mod_vis() {
+        let code = r#"
             //- /lib.rs
-            mod fo<|>o;
-            //- /foo/mod.rs
-            // emtpy
-            ",
-        );
-        let new_name = "foo2";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert_debug_snapshot!(&source_change,
-        @r###"
-        Some(
-            RangeInfo {
-                range: [4; 7),
-                info: SourceChange {
-                    label: "rename",
-                    source_file_edits: [
-                        SourceFileEdit {
-                            file_id: FileId(
-                                1,
-                            ),
-                            edit: TextEdit {
-                                atoms: [
-                                    AtomTextEdit {
-                                        delete: [4; 7),
-                                        insert: "foo2",
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                    file_system_edits: [
-                        MoveFile {
-                            src: FileId(
-                                2,
-                            ),
-                            dst_source_root: SourceRootId(
-                                0,
-                            ),
-                            dst_path: "foo2/mod.rs",
-                        },
-                    ],
-                    cursor_position: None,
-                },
-            },
-        )
-        "###
-               );
+            mod foo;
+
+            //- /foo.rs
+            mod some;
+            use some::Foo;
+
+            fn f() {
+                let i = Foo { n: 5 };
+            }
+
+            //- /foo/some.rs
+            pub(super) struct Foo<|> {
+                pub n: u32,
+            }
+        "#;
+
+        let (analysis, pos) = analysis_and_position(code);
+        let refs = analysis.find_all_refs(pos).unwrap().unwrap();
+        assert_eq!(refs.len(), 3);
     }
 
-    fn test_rename(text: &str, new_name: &str, expected: &str) {
+    fn get_all_refs(text: &str) -> ReferenceSearchResult {
         let (analysis, position) = single_file_with_position(text);
-        let source_change = analysis.rename(position, new_name).unwrap();
-        let mut text_edit_builder = ra_text_edit::TextEditBuilder::default();
-        let mut file_id: Option<FileId> = None;
-        if let Some(change) = source_change {
-            for edit in change.info.source_file_edits {
-                file_id = Some(edit.file_id);
-                for atom in edit.edit.as_atoms() {
-                    text_edit_builder.replace(atom.delete, atom.insert.clone());
-                }
-            }
-        }
-        let result =
-            text_edit_builder.finish().apply(&*analysis.file_text(file_id.unwrap()).unwrap());
-        assert_eq_text!(expected, &*result);
+        analysis.find_all_refs(position).unwrap().unwrap()
     }
 }