1 files changed, 314 insertions, 79 deletions

diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index c10a6c844..79d332e8c 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -1,9 +1,11 @@
 //! FIXME: write short doc here
 
-use hir::{db::AstDatabase, Source};
+use hir::{db::AstDatabase, InFile};
 use ra_syntax::{
     ast::{self, DocCommentsOwner},
-    match_ast, AstNode, SyntaxNode,
+    match_ast, AstNode,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, TokenAtOffset,
 };
 
 use crate::{
@@ -19,25 +21,33 @@ pub(crate) fn goto_definition(
     position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
     let file = db.parse_or_expand(position.file_id.into())?;
-    let token = file.token_at_offset(position.offset).filter(|it| !it.kind().is_trivia()).next()?;
-    let token = descend_into_macros(db, position.file_id, token);
+    let original_token = pick_best(file.token_at_offset(position.offset))?;
+    let token = descend_into_macros(db, position.file_id, original_token.clone());
 
-    let res = match_ast! {
+    let nav_targets = match_ast! {
         match (token.value.parent()) {
             ast::NameRef(name_ref) => {
-                let navs = reference_definition(db, token.with_value(&name_ref)).to_vec();
-                RangeInfo::new(name_ref.syntax().text_range(), navs.to_vec())
+                reference_definition(db, token.with_value(&name_ref)).to_vec()
             },
             ast::Name(name) => {
-                let navs = name_definition(db, token.with_value(&name))?;
-                RangeInfo::new(name.syntax().text_range(), navs)
-
+                name_definition(db, token.with_value(&name))?
             },
             _ => return None,
         }
     };
 
-    Some(res)
+    Some(RangeInfo::new(original_token.text_range(), nav_targets))
+}
+
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            IDENT | INT_NUMBER => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -58,15 +68,17 @@ impl ReferenceResult {
 
 pub(crate) fn reference_definition(
     db: &RootDatabase,
-    name_ref: Source<&ast::NameRef>,
+    name_ref: InFile<&ast::NameRef>,
 ) -> ReferenceResult {
     use self::ReferenceResult::*;
 
     let name_kind = classify_name_ref(db, name_ref).map(|d| d.kind);
     match name_kind {
-        Some(Macro(mac)) => return Exact(mac.to_nav(db)),
-        Some(Field(field)) => return Exact(field.to_nav(db)),
-        Some(AssocItem(assoc)) => return Exact(assoc.to_nav(db)),
+        Some(Macro(it)) => return Exact(it.to_nav(db)),
+        Some(Field(it)) => return Exact(it.to_nav(db)),
+        Some(TypeParam(it)) => return Exact(it.to_nav(db)),
+        Some(AssocItem(it)) => return Exact(it.to_nav(db)),
+        Some(Local(it)) => return Exact(it.to_nav(db)),
         Some(Def(def)) => match NavigationTarget::from_def(db, def) {
             Some(nav) => return Exact(nav),
             None => return Approximate(vec![]),
@@ -77,10 +89,6 @@ pub(crate) fn reference_definition(
             // us to the actual type
             return Exact(imp.to_nav(db));
         }
-        Some(Local(local)) => return Exact(local.to_nav(db)),
-        Some(GenericParam(_)) => {
-            // FIXME: go to the generic param def
-        }
         None => {}
     };
 
@@ -94,7 +102,7 @@ pub(crate) fn reference_definition(
 
 pub(crate) fn name_definition(
     db: &RootDatabase,
-    name: Source<&ast::Name>,
+    name: InFile<&ast::Name>,
 ) -> Option<Vec<NavigationTarget>> {
     let parent = name.value.syntax().parent()?;
 
@@ -115,7 +123,7 @@ pub(crate) fn name_definition(
     None
 }
 
-fn named_target(db: &RootDatabase, node: Source<&SyntaxNode>) -> Option<NavigationTarget> {
+fn named_target(db: &RootDatabase, node: InFile<&SyntaxNode>) -> Option<NavigationTarget> {
     match_ast! {
         match (node.value) {
             ast::StructDef(it) => {
@@ -213,21 +221,44 @@ fn named_target(db: &RootDatabase, node: Source<&SyntaxNode>) -> Option<Navigati
 
 #[cfg(test)]
 mod tests {
-    use test_utils::covers;
+    use test_utils::{assert_eq_text, covers};
 
     use crate::mock_analysis::analysis_and_position;
 
-    fn check_goto(fixture: &str, expected: &str) {
+    fn check_goto(fixture: &str, expected: &str, expected_range: &str) {
         let (analysis, pos) = analysis_and_position(fixture);
 
         let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
         assert_eq!(navs.len(), 1);
+
         let nav = navs.pop().unwrap();
+        let file_text = analysis.file_text(nav.file_id()).unwrap();
+
+        let mut actual = file_text[nav.full_range()].to_string();
+        if let Some(focus) = nav.focus_range() {
+            actual += "|";
+            actual += &file_text[focus];
+        }
+
+        if !expected_range.contains("...") {
+            test_utils::assert_eq_text!(&actual, expected_range);
+        } else {
+            let mut parts = expected_range.split("...");
+            let prefix = parts.next().unwrap();
+            let suffix = parts.next().unwrap();
+            assert!(
+                actual.starts_with(prefix) && actual.ends_with(suffix),
+                "\nExpected: {}\n Actual: {}\n",
+                expected_range,
+                actual
+            );
+        }
+
         nav.assert_match(expected);
     }
 
     #[test]
-    fn goto_definition_works_in_items() {
+    fn goto_def_in_items() {
         check_goto(
             "
             //- /lib.rs
@@ -235,6 +266,20 @@ mod tests {
             enum E { X(Foo<|>) }
             ",
             "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
+        );
+    }
+
+    #[test]
+    fn goto_def_at_start_of_item() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo;
+            enum E { X(<|>Foo) }
+            ",
+            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
         );
     }
 
@@ -247,61 +292,65 @@ mod tests {
             mod a;
             mod b;
             enum E { X(Foo<|>) }
+
             //- /a.rs
             struct Foo;
+
             //- /b.rs
             struct Foo;
             ",
             "Foo STRUCT_DEF FileId(2) [0; 11) [7; 10)",
+            "struct Foo;|Foo",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_module_declaration() {
+    fn goto_def_for_module_declaration() {
         check_goto(
             "
             //- /lib.rs
             mod <|>foo;
+
             //- /foo.rs
             // empty
             ",
             "foo SOURCE_FILE FileId(2) [0; 10)",
+            "// empty\n\n",
         );
 
         check_goto(
             "
             //- /lib.rs
             mod <|>foo;
+
             //- /foo/mod.rs
             // empty
             ",
             "foo SOURCE_FILE FileId(2) [0; 10)",
+            "// empty\n\n",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macros() {
-        covers!(goto_definition_works_for_macros);
+    fn goto_def_for_macros() {
+        covers!(goto_def_for_macros);
         check_goto(
             "
             //- /lib.rs
-            macro_rules! foo {
-                () => {
-                    {}
-                };
-            }
+            macro_rules! foo { () => { () } }
 
             fn bar() {
                 <|>foo!();
             }
             ",
-            "foo MACRO_CALL FileId(1) [0; 50) [13; 16)",
+            "foo MACRO_CALL FileId(1) [0; 33) [13; 16)",
+            "macro_rules! foo { () => { () } }|foo",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macros_from_other_crates() {
-        covers!(goto_definition_works_for_macros);
+    fn goto_def_for_macros_from_other_crates() {
+        covers!(goto_def_for_macros);
         check_goto(
             "
             //- /lib.rs
@@ -312,18 +361,15 @@ mod tests {
 
             //- /foo/lib.rs
             #[macro_export]
-            macro_rules! foo {
-                () => {
-                    {}
-                };
-            }
+            macro_rules! foo { () => { () } }
             ",
-            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
+            "foo MACRO_CALL FileId(2) [0; 49) [29; 32)",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macros_in_use_tree() {
+    fn goto_def_for_macros_in_use_tree() {
         check_goto(
             "
             //- /lib.rs
@@ -331,18 +377,15 @@ mod tests {
 
             //- /foo/lib.rs
             #[macro_export]
-            macro_rules! foo {
-                () => {
-                    {}
-                };
-            }
+            macro_rules! foo { () => { () } }
             ",
-            "foo MACRO_CALL FileId(2) [0; 66) [29; 32)",
+            "foo MACRO_CALL FileId(2) [0; 49) [29; 32)",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macro_defined_fn_with_arg() {
+    fn goto_def_for_macro_defined_fn_with_arg() {
         check_goto(
             "
             //- /lib.rs
@@ -350,20 +393,19 @@ mod tests {
                 ($name:ident) => (fn $name() {})
             }
 
-            define_fn!(
-                foo
-            )
+            define_fn!(foo);
 
             fn bar() {
                <|>foo();
             }
             ",
-            "foo FN_DEF FileId(1) [80; 83) [80; 83)",
+            "foo FN_DEF FileId(1) [64; 80) [75; 78)",
+            "define_fn!(foo);|foo",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_macro_defined_fn_no_arg() {
+    fn goto_def_for_macro_defined_fn_no_arg() {
         check_goto(
             "
             //- /lib.rs
@@ -377,32 +419,70 @@ mod tests {
                <|>foo();
             }
             ",
-            "foo FN_DEF FileId(1) [39; 42) [39; 42)",
+            "foo FN_DEF FileId(1) [51; 64) [51; 64)",
+            "define_fn!();|define_fn!();",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_methods() {
-        covers!(goto_definition_works_for_methods);
+    fn goto_definition_works_for_macro_inside_pattern() {
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! foo {() => {0}}
+
+            fn bar() {
+                match (0,1) {
+                    (<|>foo!(), _) => {}
+                }
+            }
+            ",
+            "foo MACRO_CALL FileId(1) [0; 28) [13; 16)",
+            "macro_rules! foo {() => {0}}|foo",
+        );
+    }
+
+    #[test]
+    fn goto_definition_works_for_macro_inside_match_arm_lhs() {
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! foo {() => {0}}
+
+            fn bar() {
+                match 0 {
+                    <|>foo!() => {}
+                }
+            }
+            ",
+            "foo MACRO_CALL FileId(1) [0; 28) [13; 16)",
+            "macro_rules! foo {() => {0}}|foo",
+        );
+    }
+
+    #[test]
+    fn goto_def_for_methods() {
+        covers!(goto_def_for_methods);
         check_goto(
             "
             //- /lib.rs
             struct Foo;
             impl Foo {
-                fn frobnicate(&self) {  }
+                fn frobnicate(&self) { }
             }
 
             fn bar(foo: &Foo) {
                 foo.frobnicate<|>();
             }
             ",
-            "frobnicate FN_DEF FileId(1) [27; 52) [30; 40)",
+            "frobnicate FN_DEF FileId(1) [27; 51) [30; 40)",
+            "fn frobnicate(&self) { }|frobnicate",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_fields() {
-        covers!(goto_definition_works_for_fields);
+    fn goto_def_for_fields() {
+        covers!(goto_def_for_fields);
         check_goto(
             "
             //- /lib.rs
@@ -415,12 +495,13 @@ mod tests {
             }
             ",
             "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+            "spam: u32|spam",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_record_fields() {
-        covers!(goto_definition_works_for_record_fields);
+    fn goto_def_for_record_fields() {
+        covers!(goto_def_for_record_fields);
         check_goto(
             "
             //- /lib.rs
@@ -435,29 +516,48 @@ mod tests {
             }
             ",
             "spam RECORD_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+            "spam: u32|spam",
+        );
+    }
+
+    #[test]
+    fn goto_for_tuple_fields() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo(u32);
+
+            fn bar() {
+                let foo = Foo(0);
+                foo.<|>0;
+            }
+            ",
+            "TUPLE_FIELD_DEF FileId(1) [11; 14)",
+            "u32",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_ufcs_inherent_methods() {
+    fn goto_def_for_ufcs_inherent_methods() {
         check_goto(
             "
             //- /lib.rs
             struct Foo;
             impl Foo {
-                fn frobnicate() {  }
+                fn frobnicate() { }
             }
 
             fn bar(foo: &Foo) {
                 Foo::frobnicate<|>();
             }
             ",
-            "frobnicate FN_DEF FileId(1) [27; 47) [30; 40)",
+            "frobnicate FN_DEF FileId(1) [27; 46) [30; 40)",
+            "fn frobnicate() { }|frobnicate",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_ufcs_trait_methods_through_traits() {
+    fn goto_def_for_ufcs_trait_methods_through_traits() {
         check_goto(
             "
             //- /lib.rs
@@ -470,11 +570,12 @@ mod tests {
             }
             ",
             "frobnicate FN_DEF FileId(1) [16; 32) [19; 29)",
+            "fn frobnicate();|frobnicate",
         );
     }
 
     #[test]
-    fn goto_definition_works_for_ufcs_trait_methods_through_self() {
+    fn goto_def_for_ufcs_trait_methods_through_self() {
         check_goto(
             "
             //- /lib.rs
@@ -489,6 +590,7 @@ mod tests {
             }
             ",
             "frobnicate FN_DEF FileId(1) [30; 46) [33; 43)",
+            "fn frobnicate();|frobnicate",
         );
     }
 
@@ -505,6 +607,7 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [12; 73)",
+            "impl Foo {...}",
         );
 
         check_goto(
@@ -518,6 +621,7 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [12; 73)",
+            "impl Foo {...}",
         );
 
         check_goto(
@@ -531,6 +635,7 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [15; 75)",
+            "impl Foo {...}",
         );
 
         check_goto(
@@ -543,6 +648,7 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [15; 62)",
+            "impl Foo {...}",
         );
     }
 
@@ -562,6 +668,7 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [49; 115)",
+            "impl Make for Foo {...}",
         );
 
         check_goto(
@@ -578,17 +685,19 @@ mod tests {
             }
             ",
             "impl IMPL_BLOCK FileId(1) [49; 115)",
+            "impl Make for Foo {...}",
         );
     }
 
     #[test]
-    fn goto_definition_works_when_used_on_definition_name_itself() {
+    fn goto_def_when_used_on_definition_name_itself() {
         check_goto(
             "
             //- /lib.rs
             struct Foo<|> { value: u32 }
             ",
             "Foo STRUCT_DEF FileId(1) [0; 25) [7; 10)",
+            "struct Foo { value: u32 }|Foo",
         );
 
         check_goto(
@@ -599,15 +708,16 @@ mod tests {
             }
             "#,
             "field RECORD_FIELD_DEF FileId(1) [17; 30) [17; 22)",
+            "field: string|field",
         );
 
         check_goto(
             "
             //- /lib.rs
-            fn foo_test<|>() {
-            }
+            fn foo_test<|>() { }
             ",
             "foo_test FN_DEF FileId(1) [0; 17) [3; 11)",
+            "fn foo_test() { }|foo_test",
         );
 
         check_goto(
@@ -618,6 +728,7 @@ mod tests {
             }
             ",
             "Foo ENUM_DEF FileId(1) [0; 25) [5; 8)",
+            "enum Foo {...}|Foo",
         );
 
         check_goto(
@@ -630,22 +741,25 @@ mod tests {
             }
             ",
             "Variant2 ENUM_VARIANT FileId(1) [29; 37) [29; 37)",
+            "Variant2|Variant2",
         );
 
         check_goto(
             r#"
             //- /lib.rs
-            static inner<|>: &str = "";
+            static INNER<|>: &str = "";
             "#,
-            "inner STATIC_DEF FileId(1) [0; 24) [7; 12)",
+            "INNER STATIC_DEF FileId(1) [0; 24) [7; 12)",
+            "static INNER: &str = \"\";|INNER",
         );
 
         check_goto(
             r#"
             //- /lib.rs
-            const inner<|>: &str = "";
+            const INNER<|>: &str = "";
             "#,
-            "inner CONST_DEF FileId(1) [0; 23) [6; 11)",
+            "INNER CONST_DEF FileId(1) [0; 23) [6; 11)",
+            "const INNER: &str = \"\";|INNER",
         );
 
         check_goto(
@@ -654,24 +768,25 @@ mod tests {
             type Thing<|> = Option<()>;
             "#,
             "Thing TYPE_ALIAS_DEF FileId(1) [0; 24) [5; 10)",
+            "type Thing = Option<()>;|Thing",
         );
 
         check_goto(
             r#"
             //- /lib.rs
-            trait Foo<|> {
-            }
+            trait Foo<|> { }
             "#,
             "Foo TRAIT_DEF FileId(1) [0; 13) [6; 9)",
+            "trait Foo { }|Foo",
         );
 
         check_goto(
             r#"
             //- /lib.rs
-            mod bar<|> {
-            }
+            mod bar<|> { }
             "#,
             "bar MODULE FileId(1) [0; 11) [4; 7)",
+            "mod bar { }|bar",
         );
     }
 
@@ -689,8 +804,128 @@ mod tests {
                     fo<|>o();
                 }
             }
+            mod confuse_index { fn foo(); }
             ",
             "foo FN_DEF FileId(1) [52; 63) [55; 58)",
+            "fn foo() {}|foo",
         );
     }
+
+    #[test]
+    fn goto_through_format() {
+        check_goto(
+            "
+            //- /lib.rs
+            #[macro_export]
+            macro_rules! format {
+                ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
+            }
+            #[rustc_builtin_macro]
+            #[macro_export]
+            macro_rules! format_args {
+                ($fmt:expr) => ({ /* compiler built-in */ });
+                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+            }
+            pub mod __export {
+                pub use crate::format_args;
+                fn foo() {} // for index confusion
+            }
+            fn foo() -> i8 {}
+            fn test() {
+                format!(\"{}\", fo<|>o())
+            }
+            ",
+            "foo FN_DEF FileId(1) [398; 415) [401; 404)",
+            "fn foo() -> i8 {}|foo",
+        );
+    }
+
+    #[test]
+    fn goto_for_type_param() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo<T> {
+                t: <|>T,
+            }
+            ",
+            "T TYPE_PARAM FileId(1) [11; 12)",
+            "T",
+        );
+    }
+
+    #[test]
+    fn goto_within_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => ($($tt)*)
+            }
+
+            fn foo() {
+                let x = 1;
+                id!({
+                    let y = <|>x;
+                    let z = y;
+                });
+            }
+            ",
+            "x BIND_PAT FileId(1) [69; 70)",
+            "x",
+        );
+
+        check_goto(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => ($($tt)*)
+            }
+
+            fn foo() {
+                let x = 1;
+                id!({
+                    let y = x;
+                    let z = <|>y;
+                });
+            }
+            ",
+            "y BIND_PAT FileId(1) [98; 99)",
+            "y",
+        );
+    }
+
+    #[test]
+    fn goto_def_in_local_fn() {
+        check_goto(
+            "
+            //- /lib.rs
+            fn main() {
+                fn foo() {
+                    let x = 92;
+                    <|>x;
+                }
+            }
+            ",
+            "x BIND_PAT FileId(1) [39; 40)",
+            "x",
+        );
+    }
+
+    #[test]
+    fn goto_def_for_field_init_shorthand() {
+        covers!(goto_def_for_field_init_shorthand);
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo { x: i32 }
+            fn main() {
+                let x = 92;
+                Foo { x<|> };
+            }
+            ",
+            "x RECORD_FIELD_DEF FileId(1) [13; 19) [13; 14)",
+            "x: i32|x",
+        )
+    }
 }