Merge #437

437: refactor goto defenition r=matklad a=matklad



Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

crates/ra_analysis/src/goto_defenition.rs

@@ -1,73 +1,138 @@
-use ra_db::FileId;
+use ra_db::{FileId, Cancelable, SyntaxDatabase};
-use ra_syntax::ast;
+use ra_syntax::{TextRange, AstNode, ast, SyntaxKind::{NAME, MODULE}};
 
-use crate::db::RootDatabase;
+use ra_editor::find_node_at_offset;
 
-pub fn goto_defenition(db: &RootDatabase, position: FilePosition,
+use crate::{FilePosition, NavigationTarget, db::RootDatabase};
+
+pub(crate) fn goto_defenition(
+    db: &RootDatabase,
+    position: FilePosition,
 ) -> Cancelable<Option<Vec<NavigationTarget>>> {
     let file = db.source_file(position.file_id);
     let syntax = file.syntax();
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-        return Ok(Some(reference_defenition(db, position.file_id, name_ref)));
+        return Ok(Some(reference_defenition(db, position.file_id, name_ref)?));
     }
-    if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset)  {
+    if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
-        return Ok(Some(name_defenition(db, position.file_idname)));
+        return name_defenition(db, position.file_id, name);
     }
     Ok(None)
 }
 
-fn reference_defenition(db: &RootDatabase, file_id: FileId, name_ref: ast::NameRef) -> Cancelable<Vec<Nav>> {
+pub(crate) fn reference_defenition(
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+    db: &RootDatabase,
-        let mut rr = ReferenceResolution::new(name_ref.syntax().range());
+    file_id: FileId,
-        if let Some(fn_descr) =
+    name_ref: ast::NameRef,
-            source_binder::function_from_child_node(self, position.file_id, name_ref.syntax())?
+) -> Cancelable<Vec<NavigationTarget>> {
-        {
+    if let Some(fn_descr) =
-            let scope = fn_descr.scopes(self);
+        hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())?
-            // First try to resolve the symbol locally
+    {
-            if let Some(entry) = scope.resolve_local_name(name_ref) {
+        let scope = fn_descr.scopes(db);
-                rr.resolves_to.push(NavigationTarget {
+        // First try to resolve the symbol locally
-                    file_id: position.file_id,
+        if let Some(entry) = scope.resolve_local_name(name_ref) {
-                    name: entry.name().to_string().into(),
+            let nav = NavigationTarget {
-                    range: entry.ptr().range(),
+                file_id,
-                    kind: NAME,
+                name: entry.name().to_string().into(),
-                    ptr: None,
+                range: entry.ptr().range(),
-                });
+                kind: NAME,
-                return Ok(Some(rr));
+                ptr: None,
             };
-        }
+            return Ok(vec![nav]);
-        // If that fails try the index based approach.
+        };
-        rr.resolves_to.extend(
-            self.index_resolve(name_ref)?
-                .into_iter()
-                .map(NavigationTarget::from_symbol),
-        );
-        return Ok(Some(rr));
     }
-        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
+    // If that fails try the index based approach.
-            let mut rr = ReferenceResolution::new(name.syntax().range());
+    let navs = db
-            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
+        .index_resolve(name_ref)?
-                if module.has_semi() {
+        .into_iter()
-                    if let Some(child_module) =
+        .map(NavigationTarget::from_symbol)
-                        source_binder::module_from_declaration(self, position.file_id, module)?
+        .collect();
-                    {
+    Ok(navs)
-                        let file_id = child_module.file_id();
+}
-                        let name = match child_module.name() {
+
-                            Some(name) => name.to_string().into(),
+fn name_defenition(
-                            None => "".into(),
+    db: &RootDatabase,
-                        };
+    file_id: FileId,
-                        let symbol = NavigationTarget {
+    name: ast::Name,
-                            file_id,
+) -> Cancelable<Option<Vec<NavigationTarget>>> {
-                            name,
+    if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
-                            range: TextRange::offset_len(0.into(), 0.into()),
+        if module.has_semi() {
-                            kind: MODULE,
+            if let Some(child_module) =
-                            ptr: None,
+                hir::source_binder::module_from_declaration(db, file_id, module)?
-                        };
+            {
-                        rr.resolves_to.push(symbol);
+                let file_id = child_module.file_id();
-                        return Ok(Some(rr));
+                let name = match child_module.name() {
-                    }
+                    Some(name) => name.to_string().into(),
-                }
+                    None => "".into(),
+                };
+                let nav = NavigationTarget {
+                    file_id,
+                    name,
+                    range: TextRange::offset_len(0.into(), 0.into()),
+                    kind: MODULE,
+                    ptr: None,
+                };
+                return Ok(Some(vec![nav]));
             }
         }
-        Ok(None)
+    }
-
+    Ok(None)
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::assert_eq_dbg;
+    use crate::mock_analysis::analysis_and_position;
+
+    #[test]
+    fn goto_defenition_works_in_items() {
+        let (analysis, pos) = analysis_and_position(
+            "
+            //- /lib.rs
+            struct Foo;
+            enum E { X(Foo<|>) }
+            ",
+        );
+
+        let symbols = analysis.goto_defenition(pos).unwrap().unwrap();
+        assert_eq_dbg(
+            r#"[NavigationTarget { file_id: FileId(1), name: "Foo",
+                                   kind: STRUCT_DEF, range: [0; 11),
+                                   ptr: Some(LocalSyntaxPtr { range: [0; 11), kind: STRUCT_DEF }) }]"#,
+            &symbols,
+        );
+    }
+
+    #[test]
+    fn goto_defenition_works_for_module_declaration() {
+        let (analysis, pos) = analysis_and_position(
+            "
+            //- /lib.rs
+            mod <|>foo;
+            //- /foo.rs
+            // empty
+        ",
+        );
+
+        let symbols = analysis.goto_defenition(pos).unwrap().unwrap();
+        assert_eq_dbg(
+            r#"[NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]"#,
+            &symbols,
+        );
+
+        let (analysis, pos) = analysis_and_position(
+            "
+            //- /lib.rs
+            mod <|>foo;
+            //- /foo/mod.rs
+            // empty
+        ",
+        );
+
+        let symbols = analysis.goto_defenition(pos).unwrap().unwrap();
+        assert_eq_dbg(
+            r#"[NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]"#,
+            &symbols,
+        );
+    }
 }

crates/ra_analysis/src/hover.rs

@@ -1,4 +1,5 @@
 use ra_db::{Cancelable, SyntaxDatabase};
+use ra_editor::find_node_at_offset;
 use ra_syntax::{
     AstNode, SyntaxNode,
     ast::{self, NameOwner},
@@ -11,18 +12,18 @@ pub(crate) fn hover(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Cancelable<Option<RangeInfo<String>>> {
+    let file = db.source_file(position.file_id);
     let mut res = Vec::new();
-    let range = if let Some(rr) = db.approximately_resolve_symbol(position)? {
+    let range = if let Some(name_ref) =
-        for nav in rr.resolves_to {
+        find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset)
+    {
+        let navs = crate::goto_defenition::reference_defenition(db, position.file_id, name_ref)?;
+        for nav in navs {
             res.extend(doc_text_for(db, nav)?)
         }
-        rr.reference_range
+        name_ref.syntax().range()
     } else {
-        let file = db.source_file(position.file_id);
+        let expr: ast::Expr = ctry!(find_node_at_offset(file.syntax(), position.offset));
-        let expr: ast::Expr = ctry!(ra_editor::find_node_at_offset(
-            file.syntax(),
-            position.offset
-        ));
         let frange = FileRange {
             file_id: position.file_id,
             range: expr.syntax().range(),

crates/ra_analysis/src/imp.rs

@@ -18,7 +18,7 @@ use crate::{
     AnalysisChange,
     Cancelable, NavigationTarget,
     CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
-    Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
+    Query, RootChange, SourceChange, SourceFileEdit,
     symbol_index::{LibrarySymbolsQuery, FileSymbol},
 };
 
@@ -139,66 +139,6 @@ impl db::RootDatabase {
     pub(crate) fn crate_root(&self, crate_id: CrateId) -> FileId {
         self.crate_graph().crate_root(crate_id)
     }
-    pub(crate) fn approximately_resolve_symbol(
-        &self,
-        position: FilePosition,
-    ) -> Cancelable<Option<ReferenceResolution>> {
-        let file = self.source_file(position.file_id);
-        let syntax = file.syntax();
-        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-            let mut rr = ReferenceResolution::new(name_ref.syntax().range());
-            if let Some(fn_descr) =
-                source_binder::function_from_child_node(self, position.file_id, name_ref.syntax())?
-            {
-                let scope = fn_descr.scopes(self);
-                // First try to resolve the symbol locally
-                if let Some(entry) = scope.resolve_local_name(name_ref) {
-                    rr.resolves_to.push(NavigationTarget {
-                        file_id: position.file_id,
-                        name: entry.name().to_string().into(),
-                        range: entry.ptr().range(),
-                        kind: NAME,
-                        ptr: None,
-                    });
-                    return Ok(Some(rr));
-                };
-            }
-            // If that fails try the index based approach.
-            rr.resolves_to.extend(
-                self.index_resolve(name_ref)?
-                    .into_iter()
-                    .map(NavigationTarget::from_symbol),
-            );
-            return Ok(Some(rr));
-        }
-        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
-            let mut rr = ReferenceResolution::new(name.syntax().range());
-            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
-                if module.has_semi() {
-                    if let Some(child_module) =
-                        source_binder::module_from_declaration(self, position.file_id, module)?
-                    {
-                        let file_id = child_module.file_id();
-                        let name = match child_module.name() {
-                            Some(name) => name.to_string().into(),
-                            None => "".into(),
-                        };
-                        let symbol = NavigationTarget {
-                            file_id,
-                            name,
-                            range: TextRange::offset_len(0.into(), 0.into()),
-                            kind: MODULE,
-                            ptr: None,
-                        };
-                        rr.resolves_to.push(symbol);
-                        return Ok(Some(rr));
-                    }
-                }
-            }
-        }
-        Ok(None)
-    }
-
     pub(crate) fn find_all_refs(
         &self,
         position: FilePosition,
@@ -416,7 +356,7 @@ impl db::RootDatabase {
             .collect::<Vec<_>>();
         Ok(res)
     }
-    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
+    pub(crate) fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
         query.exact();

crates/ra_analysis/src/lib.rs

@@ -15,6 +15,7 @@ macro_rules! ctry {
 mod db;
 mod imp;
 mod completion;
+mod goto_defenition;
 mod symbol_index;
 pub mod mock_analysis;
 mod runnables;
@@ -273,26 +274,6 @@ impl<T> RangeInfo<T> {
     }
 }
 
-/// Result of "goto def" query.
-#[derive(Debug)]
-pub struct ReferenceResolution {
-    /// The range of the reference itself. Client does not know what constitutes
-    /// a reference, it handles us only the offset. It's helpful to tell the
-    /// client where the reference was.
-    pub reference_range: TextRange,
-    /// What this reference resolves to.
-    pub resolves_to: Vec<NavigationTarget>,
-}
-
-impl ReferenceResolution {
-    fn new(reference_range: TextRange) -> ReferenceResolution {
-        ReferenceResolution {
-            reference_range,
-            resolves_to: Vec::new(),
-        }
-    }
-}
-
 /// `AnalysisHost` stores the current state of the world.
 #[derive(Debug, Default)]
 pub struct AnalysisHost {
@@ -392,12 +373,11 @@ impl Analysis {
             .collect();
         Ok(res)
     }
-    /// Resolves reference to definition, but does not gurantee correctness.
+    pub fn goto_defenition(
-    pub fn approximately_resolve_symbol(
         &self,
         position: FilePosition,
-    ) -> Cancelable<Option<ReferenceResolution>> {
+    ) -> Cancelable<Option<Vec<NavigationTarget>>> {
-        self.db.approximately_resolve_symbol(position)
+        goto_defenition::goto_defenition(&*self.db, position)
     }
     /// Finds all usages of the reference at point.
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {

crates/ra_analysis/tests/test/main.rs

@@ -14,65 +14,6 @@ fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
     analysis.resolve_callable(position).unwrap().unwrap()
 }
 
-#[test]
-fn approximate_resolve_works_in_items() {
-    let (analysis, pos) = analysis_and_position(
-        "
-        //- /lib.rs
-        struct Foo;
-        enum E { X(Foo<|>) }
-    ",
-    );
-
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"ReferenceResolution {
-            reference_range: [23; 26),
-            resolves_to: [NavigationTarget { file_id: FileId(1), name: "Foo", kind: STRUCT_DEF, range: [0; 11), ptr: Some(LocalSyntaxPtr { range: [0; 11), kind: STRUCT_DEF }) }]
-        }"#,
-        &symbols,
-    );
-}
-
-#[test]
-fn test_resolve_module() {
-    let (analysis, pos) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod <|>foo;
-        //- /foo.rs
-        // empty
-    ",
-    );
-
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"ReferenceResolution {
-            reference_range: [4; 7),
-            resolves_to: [NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]
-        }"#,
-        &symbols,
-    );
-
-    let (analysis, pos) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod <|>foo;
-        //- /foo/mod.rs
-        // empty
-    ",
-    );
-
-    let symbols = analysis.approximately_resolve_symbol(pos).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"ReferenceResolution {
-            reference_range: [4; 7),
-            resolves_to: [NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]
-        }"#,
-        &symbols,
-    );
-}
-
 #[test]
 fn test_unresolved_module_diagnostic() {
     let (analysis, file_id) = single_file("mod foo;");

crates/ra_lsp_server/src/main_loop/handlers.rs

@@ -207,12 +207,11 @@ pub fn handle_goto_definition(
     params: req::TextDocumentPositionParams,
 ) -> Result<Option<req::GotoDefinitionResponse>> {
     let position = params.try_conv_with(&world)?;
-    let rr = match world.analysis().approximately_resolve_symbol(position)? {
+    let navs = match world.analysis().goto_defenition(position)? {
         None => return Ok(None),
         Some(it) => it,
     };
-    let res = rr
+    let res = navs
-        .resolves_to
         .into_iter()
         .map(|nav| nav.try_conv_with(&world))
         .collect::<Result<Vec<_>>>()?;