26 files changed, 2119 insertions, 1035 deletions

diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 09913787b..050249c0e 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -4,7 +4,7 @@ use std::{fmt, sync::Arc, time};
 
 use ra_db::{
     salsa::{Database, Durability, SweepStrategy},
-    CrateGraph, CrateId, FileId, SourceDatabase, SourceRoot, SourceRootId,
+    CrateGraph, CrateId, FileId, SourceDatabase, SourceDatabaseExt, SourceRoot, SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
 use ra_syntax::SourceFile;
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index 28c8324d0..b4df6ee2a 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -119,27 +119,28 @@ mod tests {
             ",
         ),
         @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "foo",
-       ⋮        source_range: [187; 187),
-       ⋮        delete: [187; 187),
-       ⋮        insert: "foo()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn foo(self)",
-       ⋮    },
-       ⋮    CompletionItem {
-       ⋮        label: "the_field",
-       ⋮        source_range: [187; 187),
-       ⋮        delete: [187; 187),
-       ⋮        insert: "the_field",
-       ⋮        kind: Field,
-       ⋮        detail: "(u32,)",
-       ⋮        documentation: Documentation(
-       ⋮            "This is the_field",
-       ⋮        ),
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [187; 187),
+                delete: [187; 187),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(self)",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [187; 187),
+                delete: [187; 187),
+                insert: "the_field",
+                kind: Field,
+                detail: "(u32,)",
+                documentation: Documentation(
+                    "This is the_field",
+                ),
+            },
+        ]
         "###
         );
     }
@@ -158,24 +159,25 @@ mod tests {
             ",
         ),
         @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "foo",
-       ⋮        source_range: [126; 126),
-       ⋮        delete: [126; 126),
-       ⋮        insert: "foo()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn foo(&self)",
-       ⋮    },
-       ⋮    CompletionItem {
-       ⋮        label: "the_field",
-       ⋮        source_range: [126; 126),
-       ⋮        delete: [126; 126),
-       ⋮        insert: "the_field",
-       ⋮        kind: Field,
-       ⋮        detail: "(u32, i32)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [126; 126),
+                delete: [126; 126),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(&self)",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [126; 126),
+                delete: [126; 126),
+                insert: "the_field",
+                kind: Field,
+                detail: "(u32, i32)",
+            },
+        ]
         "###
         );
     }
@@ -210,16 +212,17 @@ mod tests {
             ",
         ),
         @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "the_method",
-       ⋮        source_range: [144; 144),
-       ⋮        delete: [144; 144),
-       ⋮        insert: "the_method()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn the_method(&self)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [144; 144),
+                delete: [144; 144),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
         "###
         );
     }
@@ -238,16 +241,17 @@ mod tests {
             ",
             ),
             @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "the_method",
-       ⋮        source_range: [151; 151),
-       ⋮        delete: [151; 151),
-       ⋮        insert: "the_method()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn the_method(&self)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [151; 151),
+                delete: [151; 151),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
         "###
         );
     }
@@ -266,16 +270,17 @@ mod tests {
             ",
             ),
             @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "the_method",
-       ⋮        source_range: [155; 155),
-       ⋮        delete: [155; 155),
-       ⋮        insert: "the_method()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn the_method(&self)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [155; 155),
+                delete: [155; 155),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
         "###
         );
     }
@@ -317,16 +322,17 @@ mod tests {
             ",
         ),
         @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "the_method",
-       ⋮        source_range: [249; 249),
-       ⋮        delete: [249; 249),
-       ⋮        insert: "the_method()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "fn the_method(&self)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [249; 249),
+                delete: [249; 249),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
         "###
         );
     }
@@ -386,16 +392,17 @@ mod tests {
             ",
         ),
         @r###"
-       ⋮[
-       ⋮    CompletionItem {
-       ⋮        label: "blah",
-       ⋮        source_range: [299; 300),
-       ⋮        delete: [299; 300),
-       ⋮        insert: "blah()$0",
-       ⋮        kind: Method,
-       ⋮        detail: "pub fn blah(&self)",
-       ⋮    },
-       ⋮]
+        [
+            CompletionItem {
+                label: "blah()",
+                source_range: [299; 300),
+                delete: [299; 300),
+                insert: "blah()$0",
+                kind: Method,
+                lookup: "blah",
+                detail: "pub fn blah(&self)",
+            },
+        ]
         "###
         );
     }
diff --git a/crates/ra_ide_api/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide_api/src/completion/complete_macro_in_item_position.rs
index d808b2357..09f743c66 100644
--- a/crates/ra_ide_api/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide_api/src/completion/complete_macro_in_item_position.rs
@@ -56,6 +56,16 @@ mod tests {
             do_reference_completion(
                 "
                 //- /main.rs
+                /// Creates a [`Vec`] containing the arguments.
+                ///
+                /// - Create a [`Vec`] containing a given list of elements:
+                ///
+                /// ```
+                /// let v = vec![1, 2, 3];
+                /// assert_eq!(v[0], 1);
+                /// assert_eq!(v[1], 2);
+                /// assert_eq!(v[2], 3);
+                /// ```
                 macro_rules! vec {
                     () => {}
                 }
@@ -68,13 +78,61 @@ mod tests {
             @r##"[
     CompletionItem {
         label: "vec!",
-        source_range: [46; 46),
-        delete: [46; 46),
+        source_range: [280; 280),
+        delete: [280; 280),
         insert: "vec![$0]",
         kind: Macro,
         detail: "macro_rules! vec",
+        documentation: Documentation(
+            "Creates a [`Vec`] containing the arguments.\n\n- Create a [`Vec`] containing a given list of elements:\n\n```\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```",
+        ),
     },
 ]"##
         );
     }
+
+    #[test]
+    fn completes_macros_braces_guessing() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                /// Foo
+                ///
+                /// Not call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.
+                /// Call as `let _=foo!  { hello world };`
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"[
+    CompletionItem {
+        label: "foo!",
+        source_range: [163; 163),
+        delete: [163; 163),
+        insert: "foo! {$0}",
+        kind: Macro,
+        detail: "macro_rules! foo",
+        documentation: Documentation(
+            "Foo\n\nNot call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.\nCall as `let _=foo!  { hello world };`",
+        ),
+    },
+    CompletionItem {
+        label: "main()",
+        source_range: [163; 163),
+        delete: [163; 163),
+        insert: "main()$0",
+        kind: Function,
+        lookup: "main",
+        detail: "fn main()",
+    },
+]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs
index e01197fe4..23dece73c 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -375,19 +375,22 @@ mod tests {
                 fn foo() { let _ = S::<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "m",
-        source_range: [100; 100),
-        delete: [100; 100),
-        insert: "m()$0",
-        kind: Function,
-        detail: "fn m()",
-        documentation: Documentation(
-            "An associated method",
-        ),
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [100; 100),
+                delete: [100; 100),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
         );
     }
 
@@ -474,19 +477,22 @@ mod tests {
                 fn foo() { let _ = S::<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "m",
-        source_range: [100; 100),
-        delete: [100; 100),
-        insert: "m()$0",
-        kind: Function,
-        detail: "fn m()",
-        documentation: Documentation(
-            "An associated method",
-        ),
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [100; 100),
+                delete: [100; 100),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
         );
     }
 
@@ -507,19 +513,22 @@ mod tests {
                 fn foo() { let _ = U::<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "m",
-        source_range: [101; 101),
-        delete: [101; 101),
-        insert: "m()$0",
-        kind: Function,
-        detail: "fn m()",
-        documentation: Documentation(
-            "An associated method",
-        ),
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [101; 101),
+                delete: [101; 101),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
         );
     }
 
@@ -564,24 +573,28 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "bar",
-        source_range: [185; 185),
-        delete: [185; 185),
-        insert: "bar()$0",
-        kind: Function,
-        detail: "fn bar()",
-    },
-    CompletionItem {
-        label: "foo",
-        source_range: [185; 185),
-        delete: [185; 185),
-        insert: "foo()$0",
-        kind: Function,
-        detail: "fn foo()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "bar()",
+                source_range: [185; 185),
+                delete: [185; 185),
+                insert: "bar()$0",
+                kind: Function,
+                lookup: "bar",
+                detail: "fn bar()",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [185; 185),
+                delete: [185; 185),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
         );
     }
 
@@ -600,24 +613,27 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "foo!",
-        source_range: [179; 179),
-        delete: [179; 179),
-        insert: "foo!($0)",
-        kind: Macro,
-        detail: "#[macro_export]\nmacro_rules! foo",
-    },
-    CompletionItem {
-        label: "main",
-        source_range: [179; 179),
-        delete: [179; 179),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [179; 179),
+                delete: [179; 179),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "#[macro_export]\nmacro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [179; 179),
+                delete: [179; 179),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
         );
     }
 }
diff --git a/crates/ra_ide_api/src/completion/complete_postfix.rs b/crates/ra_ide_api/src/completion/complete_postfix.rs
index 445a02676..555cecb73 100644
--- a/crates/ra_ide_api/src/completion/complete_postfix.rs
+++ b/crates/ra_ide_api/src/completion/complete_postfix.rs
@@ -8,7 +8,7 @@ use crate::{
     CompletionItem,
 };
 use hir::{Ty, TypeCtor};
-use ra_syntax::{ast::AstNode, TextRange};
+use ra_syntax::{ast::AstNode, TextRange, TextUnit};
 use ra_text_edit::TextEditBuilder;
 
 fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
@@ -42,7 +42,13 @@ fn is_bool_or_unknown(ty: Option<Ty>) -> bool {
 
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if let Some(dot_receiver) = &ctx.dot_receiver {
-        let receiver_text = dot_receiver.syntax().text().to_string();
+        let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
+            let text = dot_receiver.syntax().text();
+            let without_dot = ..text.len() - TextUnit::of_char('.');
+            text.slice(without_dot).to_string()
+        } else {
+            dot_receiver.syntax().text().to_string()
+        };
         let receiver_ty = ctx.analyzer.type_of(ctx.db, &dot_receiver);
         if is_bool_or_unknown(receiver_ty) {
             postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
@@ -209,4 +215,61 @@ mod tests {
 ]"###
         );
     }
+
+    #[test]
+    fn postfix_completion_works_for_ambiguous_float_literal() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    42.<|>
+                }
+                "#,
+            ),
+            @r###"[
+    CompletionItem {
+        label: "box",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "Box::new(42)",
+        detail: "Box::new(expr)",
+    },
+    CompletionItem {
+        label: "dbg",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "dbg!(42)",
+        detail: "dbg!(expr)",
+    },
+    CompletionItem {
+        label: "match",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "match 42 {\n    ${1:_} => {$0\\},\n}",
+        detail: "match expr {}",
+    },
+    CompletionItem {
+        label: "not",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "!42",
+        detail: "!expr",
+    },
+    CompletionItem {
+        label: "ref",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "&42",
+        detail: "&expr",
+    },
+    CompletionItem {
+        label: "refm",
+        source_range: [52; 52),
+        delete: [49; 52),
+        insert: "&mut 42",
+        detail: "&mut expr",
+    },
+]"###
+        );
+    }
 }
diff --git a/crates/ra_ide_api/src/completion/complete_scope.rs b/crates/ra_ide_api/src/completion/complete_scope.rs
index 515a6285c..4e56de3f5 100644
--- a/crates/ra_ide_api/src/completion/complete_scope.rs
+++ b/crates/ra_ide_api/src/completion/complete_scope.rs
@@ -145,32 +145,35 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "quux",
-        source_range: [91; 91),
-        delete: [91; 91),
-        insert: "quux($0)",
-        kind: Function,
-        detail: "fn quux(x: i32)",
-    },
-    CompletionItem {
-        label: "x",
-        source_range: [91; 91),
-        delete: [91; 91),
-        insert: "x",
-        kind: Binding,
-        detail: "i32",
-    },
-    CompletionItem {
-        label: "y",
-        source_range: [91; 91),
-        delete: [91; 91),
-        insert: "y",
-        kind: Binding,
-        detail: "i32",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "quux($0)",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
         );
     }
 
@@ -190,31 +193,34 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "a",
-        source_range: [242; 242),
-        delete: [242; 242),
-        insert: "a",
-        kind: Binding,
-    },
-    CompletionItem {
-        label: "b",
-        source_range: [242; 242),
-        delete: [242; 242),
-        insert: "b",
-        kind: Binding,
-        detail: "i32",
-    },
-    CompletionItem {
-        label: "quux",
-        source_range: [242; 242),
-        delete: [242; 242),
-        insert: "quux()$0",
-        kind: Function,
-        detail: "fn quux()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "a",
+                kind: Binding,
+            },
+            CompletionItem {
+                label: "b",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "b",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
         );
     }
 
@@ -230,23 +236,26 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "quux",
-        source_range: [95; 95),
-        delete: [95; 95),
-        insert: "quux()$0",
-        kind: Function,
-        detail: "fn quux()",
-    },
-    CompletionItem {
-        label: "x",
-        source_range: [95; 95),
-        delete: [95; 95),
-        insert: "x",
-        kind: Binding,
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "quux()",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "x",
+                kind: Binding,
+            },
+        ]
+        "###
         );
     }
 
@@ -260,23 +269,26 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "T",
-        source_range: [52; 52),
-        delete: [52; 52),
-        insert: "T",
-        kind: TypeParam,
-    },
-    CompletionItem {
-        label: "quux",
-        source_range: [52; 52),
-        delete: [52; 52),
-        insert: "quux()$0",
-        kind: Function,
-        detail: "fn quux<T>()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "T",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux<T>()",
+            },
+        ]
+        "###
         );
     }
 
@@ -290,22 +302,56 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "T",
-        source_range: [54; 54),
-        delete: [54; 54),
-        insert: "T",
-        kind: TypeParam,
-    },
-    CompletionItem {
-        label: "X",
-        source_range: [54; 54),
-        delete: [54; 54),
-        insert: "X",
-        kind: Struct,
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "T",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X<…>",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "X<$0>",
+                kind: Struct,
+                lookup: "X",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_self_in_enum() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum X {
+                    Y(<|>)
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "X",
+                kind: Enum,
+            },
+        ]
+        "###
         );
     }
 
@@ -321,30 +367,33 @@ mod tests {
                 }
                 "
         ),
-        @r###"[
-    CompletionItem {
-        label: "Baz",
-        source_range: [105; 105),
-        delete: [105; 105),
-        insert: "Baz",
-        kind: Enum,
-    },
-    CompletionItem {
-        label: "Foo",
-        source_range: [105; 105),
-        delete: [105; 105),
-        insert: "Foo",
-        kind: Struct,
-    },
-    CompletionItem {
-        label: "quux",
-        source_range: [105; 105),
-        delete: [105; 105),
-        insert: "quux()$0",
-        kind: Function,
-        detail: "fn quux()",
-    },
-]"###
+        @r###"
+        [
+            CompletionItem {
+                label: "Baz",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Baz",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "Foo",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
             );
     }
 
@@ -384,23 +433,26 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "Bar",
-        source_range: [117; 117),
-        delete: [117; 117),
-        insert: "Bar",
-        kind: Struct,
-    },
-    CompletionItem {
-        label: "quux",
-        source_range: [117; 117),
-        delete: [117; 117),
-        insert: "quux()$0",
-        kind: Function,
-        detail: "fn quux()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "Bar",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
         );
     }
 
@@ -413,23 +465,26 @@ mod tests {
                 fn x() -> <|>
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "Foo",
-        source_range: [55; 55),
-        delete: [55; 55),
-        insert: "Foo",
-        kind: Struct,
-    },
-    CompletionItem {
-        label: "x",
-        source_range: [55; 55),
-        delete: [55; 55),
-        insert: "x()$0",
-        kind: Function,
-        detail: "fn x()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "Foo",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "x()",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "x()$0",
+                kind: Function,
+                lookup: "x",
+                detail: "fn x()",
+            },
+        ]
+        "###
         );
     }
 
@@ -447,24 +502,27 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "bar",
-        source_range: [146; 146),
-        delete: [146; 146),
-        insert: "bar",
-        kind: Binding,
-        detail: "i32",
-    },
-    CompletionItem {
-        label: "foo",
-        source_range: [146; 146),
-        delete: [146; 146),
-        insert: "foo()$0",
-        kind: Function,
-        detail: "fn foo()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "bar",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
         );
     }
 
@@ -509,30 +567,33 @@ mod tests {
                 }
                 "
             ),
-            @r#"[
-    CompletionItem {
-        label: "Option",
-        source_range: [18; 18),
-        delete: [18; 18),
-        insert: "Option",
-        kind: Struct,
-    },
-    CompletionItem {
-        label: "foo",
-        source_range: [18; 18),
-        delete: [18; 18),
-        insert: "foo()$0",
-        kind: Function,
-        detail: "fn foo()",
-    },
-    CompletionItem {
-        label: "std",
-        source_range: [18; 18),
-        delete: [18; 18),
-        insert: "std",
-        kind: Module,
-    },
-]"#
+            @r###"
+        [
+            CompletionItem {
+                label: "Option",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "Option",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "std",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "std",
+                kind: Module,
+            },
+        ]
+        "###
         );
     }
 
@@ -569,54 +630,57 @@ mod tests {
                 }
                 "
             ),
-            @r##"[
-    CompletionItem {
-        label: "bar!",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "bar!($0)",
-        kind: Macro,
-        detail: "macro_rules! bar",
-    },
-    CompletionItem {
-        label: "baz!",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "baz!($0)",
-        kind: Macro,
-        detail: "#[macro_export]\nmacro_rules! baz",
-    },
-    CompletionItem {
-        label: "foo!",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "foo!($0)",
-        kind: Macro,
-        detail: "macro_rules! foo",
-    },
-    CompletionItem {
-        label: "m1",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "m1",
-        kind: Module,
-    },
-    CompletionItem {
-        label: "m2",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "m2",
-        kind: Module,
-    },
-    CompletionItem {
-        label: "main",
-        source_range: [252; 252),
-        delete: [252; 252),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-]"##
+            @r###"
+        [
+            CompletionItem {
+                label: "bar!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "bar!($0)",
+                kind: Macro,
+                detail: "macro_rules! bar",
+            },
+            CompletionItem {
+                label: "baz!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "baz!($0)",
+                kind: Macro,
+                detail: "#[macro_export]\nmacro_rules! baz",
+            },
+            CompletionItem {
+                label: "foo!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "m1",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m1",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "m2",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m2",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
         );
     }
 
@@ -635,24 +699,27 @@ mod tests {
                 }
                 "
             ),
-            @r##"[
-    CompletionItem {
-        label: "foo",
-        source_range: [49; 49),
-        delete: [49; 49),
-        insert: "foo()$0",
-        kind: Function,
-        detail: "fn foo()",
-    },
-    CompletionItem {
-        label: "foo!",
-        source_range: [49; 49),
-        delete: [49; 49),
-        insert: "foo!($0)",
-        kind: Macro,
-        detail: "macro_rules! foo",
-    },
-]"##
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
         );
     }
 
@@ -671,24 +738,27 @@ mod tests {
                 }
                 "
             ),
-            @r##"[
-    CompletionItem {
-        label: "foo!",
-        source_range: [57; 57),
-        delete: [57; 57),
-        insert: "foo!($0)",
-        kind: Macro,
-        detail: "macro_rules! foo",
-    },
-    CompletionItem {
-        label: "main",
-        source_range: [57; 57),
-        delete: [57; 57),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-]"##
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
         );
     }
 
@@ -707,24 +777,27 @@ mod tests {
                 }
                 "
             ),
-            @r##"[
-    CompletionItem {
-        label: "foo!",
-        source_range: [50; 50),
-        delete: [50; 50),
-        insert: "foo!($0)",
-        kind: Macro,
-        detail: "macro_rules! foo",
-    },
-    CompletionItem {
-        label: "main",
-        source_range: [50; 50),
-        delete: [50; 50),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-]"##
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
         );
     }
 }
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index e9ad06965..64cbc0f98 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -38,8 +38,11 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_new_item: bool,
     /// The receiver if this is a field or method access, i.e. writing something.<|>
     pub(super) dot_receiver: Option<ast::Expr>,
+    pub(super) dot_receiver_is_ambiguous_float_literal: bool,
     /// If this is a call (method or function) in particular, i.e. the () are already there.
     pub(super) is_call: bool,
+    pub(super) is_path_type: bool,
+    pub(super) has_type_args: bool,
 }
 
 impl<'a> CompletionContext<'a> {
@@ -76,6 +79,9 @@ impl<'a> CompletionContext<'a> {
             is_new_item: false,
             dot_receiver: None,
             is_call: false,
+            is_path_type: false,
+            has_type_args: false,
+            dot_receiver_is_ambiguous_float_literal: false,
         };
         ctx.fill(&original_parse, position.offset);
         Some(ctx)
@@ -176,6 +182,9 @@ impl<'a> CompletionContext<'a> {
                 .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast))
                 .is_some();
 
+            self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
+            self.has_type_args = segment.type_arg_list().is_some();
+
             if let Some(mut path) = hir::Path::from_ast(path.clone()) {
                 if !path.is_ident() {
                     path.segments.pop().unwrap();
@@ -228,6 +237,16 @@ impl<'a> CompletionContext<'a> {
                 .expr()
                 .map(|e| e.syntax().text_range())
                 .and_then(|r| find_node_with_range(original_file.syntax(), r));
+            self.dot_receiver_is_ambiguous_float_literal = if let Some(ast::Expr::Literal(l)) =
+                &self.dot_receiver
+            {
+                match l.kind() {
+                    ast::LiteralKind::FloatNumber { suffix: _ } => l.token().text().ends_with('.'),
+                    _ => false,
+                }
+            } else {
+                false
+            }
         }
         if let Some(method_call_expr) = ast::MethodCallExpr::cast(parent) {
             // As above
diff --git a/crates/ra_ide_api/src/completion/completion_item.rs b/crates/ra_ide_api/src/completion/completion_item.rs
index b1f0390ec..3e6933bc1 100644
--- a/crates/ra_ide_api/src/completion/completion_item.rs
+++ b/crates/ra_ide_api/src/completion/completion_item.rs
@@ -216,6 +216,10 @@ impl Builder {
         self.lookup = Some(lookup.into());
         self
     }
+    pub(crate) fn label(mut self, label: impl Into<String>) -> Builder {
+        self.label = label.into();
+        self
+    }
     pub(crate) fn insert_text(mut self, insert_text: impl Into<String>) -> Builder {
         self.insert_text = Some(insert_text.into());
         self
diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs
index 48028a2f9..aed4ce6d4 100644
--- a/crates/ra_ide_api/src/completion/presentation.rs
+++ b/crates/ra_ide_api/src/completion/presentation.rs
@@ -1,12 +1,12 @@
 //! This modules takes care of rendering various definitions as completion items.
 
-use hir::{Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
+use hir::{db::HirDatabase, Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
 use join_to_string::join;
 use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
 
 use crate::completion::{
-    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
+    db, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
 };
 
 use crate::display::{const_label, function_label, macro_label, type_label};
@@ -44,54 +44,56 @@ impl Completions {
     ) {
         use hir::ModuleDef::*;
 
-        let mut completion_kind = CompletionKind::Reference;
-        let (kind, docs) = match resolution {
-            ScopeDef::ModuleDef(Module(it)) => (CompletionItemKind::Module, it.docs(ctx.db)),
+        let completion_kind = match resolution {
+            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
+            _ => CompletionKind::Reference,
+        };
+
+        let kind = match resolution {
+            ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::Module,
             ScopeDef::ModuleDef(Function(func)) => {
                 return self.add_function_with_name(ctx, Some(local_name), *func);
             }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(it))) => {
-                (CompletionItemKind::Struct, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Union(it))) => {
-                (CompletionItemKind::Struct, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(it))) => {
-                (CompletionItemKind::Enum, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(EnumVariant(it)) => {
-                (CompletionItemKind::EnumVariant, it.docs(ctx.db))
-            }
-            ScopeDef::ModuleDef(Const(it)) => (CompletionItemKind::Const, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(Static(it)) => (CompletionItemKind::Static, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(Trait(it)) => (CompletionItemKind::Trait, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(TypeAlias(it)) => (CompletionItemKind::TypeAlias, it.docs(ctx.db)),
-            ScopeDef::ModuleDef(BuiltinType(..)) => {
-                completion_kind = CompletionKind::BuiltinType;
-                (CompletionItemKind::BuiltinType, None)
-            }
-            ScopeDef::GenericParam(..) => (CompletionItemKind::TypeParam, None),
-            ScopeDef::LocalBinding(..) => (CompletionItemKind::Binding, None),
-            ScopeDef::SelfType(..) => (
-                CompletionItemKind::TypeParam, // (does this need its own kind?)
-                None,
-            ),
+            ScopeDef::ModuleDef(Adt(hir::Adt::Struct(_))) => CompletionItemKind::Struct,
+            // FIXME: add CompletionItemKind::Union
+            ScopeDef::ModuleDef(Adt(hir::Adt::Union(_))) => CompletionItemKind::Struct,
+            ScopeDef::ModuleDef(Adt(hir::Adt::Enum(_))) => CompletionItemKind::Enum,
+
+            ScopeDef::ModuleDef(EnumVariant(..)) => CompletionItemKind::EnumVariant,
+            ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::Const,
+            ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::Static,
+            ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::Trait,
+            ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::TypeAlias,
+            ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
+            ScopeDef::GenericParam(..) => CompletionItemKind::TypeParam,
+            ScopeDef::LocalBinding(..) => CompletionItemKind::Binding,
+            // (does this need its own kind?)
+            ScopeDef::AdtSelfType(..) | ScopeDef::ImplSelfType(..) => CompletionItemKind::TypeParam,
             ScopeDef::MacroDef(mac) => {
-                self.add_macro(ctx, Some(local_name), *mac);
-                return;
+                return self.add_macro(ctx, Some(local_name), *mac);
             }
             ScopeDef::Unknown => {
-                self.add(CompletionItem::new(
+                return self.add(CompletionItem::new(
                     CompletionKind::Reference,
                     ctx.source_range(),
                     local_name,
                 ));
-                return;
             }
         };
 
+        let docs = match resolution {
+            ScopeDef::ModuleDef(Module(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Adt(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(EnumVariant(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Const(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Static(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(Trait(it)) => it.docs(ctx.db),
+            ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(ctx.db),
+            _ => None,
+        };
+
         let mut completion_item =
-            CompletionItem::new(completion_kind, ctx.source_range(), local_name);
+            CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone());
         if let ScopeDef::LocalBinding(pat_id) = resolution {
             let ty = ctx
                 .analyzer
@@ -100,6 +102,28 @@ impl Completions {
                 .map(|t| t.display(ctx.db).to_string());
             completion_item = completion_item.set_detail(ty);
         };
+
+        // If not an import, add parenthesis automatically.
+        if ctx.is_path_type
+            && !ctx.has_type_args
+            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
+        {
+            let generic_def: Option<hir::GenericDef> = match resolution {
+                ScopeDef::ModuleDef(Adt(it)) => Some((*it).into()),
+                ScopeDef::ModuleDef(TypeAlias(it)) => Some((*it).into()),
+                _ => None,
+            };
+            if let Some(def) = generic_def {
+                if has_non_default_type_params(def, ctx.db) {
+                    tested_by!(inserts_angle_brackets_for_generics);
+                    completion_item = completion_item
+                        .lookup_by(local_name.clone())
+                        .label(format!("{}<…>", local_name))
+                        .insert_snippet(format!("{}<$0>", local_name));
+                }
+            }
+        }
+
         completion_item.kind(kind).set_documentation(docs).add_to(self)
     }
 
@@ -107,6 +131,33 @@ impl Completions {
         self.add_function_with_name(ctx, None, func)
     }
 
+    fn guess_macro_braces(&self, macro_name: &str, docs: &str) -> &'static str {
+        let mut votes = [0, 0, 0];
+        for (idx, s) in docs.match_indices(&macro_name) {
+            let (before, after) = (&docs[..idx], &docs[idx + s.len()..]);
+            // Ensure to match the full word
+            if after.starts_with("!")
+                && before
+                    .chars()
+                    .rev()
+                    .next()
+                    .map_or(true, |c| c != '_' && !c.is_ascii_alphanumeric())
+            {
+                // It may have spaces before the braces like `foo! {}`
+                match after[1..].chars().find(|&c| !c.is_whitespace()) {
+                    Some('{') => votes[0] += 1,
+                    Some('[') => votes[1] += 1,
+                    Some('(') => votes[2] += 1,
+                    _ => {}
+                }
+            }
+        }
+
+        // Insert a space before `{}`.
+        // We prefer the last one when some votes equal.
+        *votes.iter().zip(&[" {$0}", "[$0]", "($0)"]).max_by_key(|&(&vote, _)| vote).unwrap().1
+    }
+
     pub(crate) fn add_macro(
         &mut self,
         ctx: &CompletionContext,
@@ -117,10 +168,9 @@ impl Completions {
         if let Some(name) = name {
             let detail = macro_label(&ast_node);
 
-            let macro_braces_to_insert = match name.as_str() {
-                "vec" => "[$0]",
-                _ => "($0)",
-            };
+            let docs = macro_.docs(ctx.db);
+            let macro_braces_to_insert =
+                self.guess_macro_braces(&name, docs.as_ref().map_or("", |s| s.as_str()));
             let macro_declaration = name + "!";
 
             let builder = CompletionItem::new(
@@ -129,7 +179,7 @@ impl Completions {
                 &macro_declaration,
             )
             .kind(CompletionItemKind::Macro)
-            .set_documentation(macro_.docs(ctx.db))
+            .set_documentation(docs)
             .detail(detail)
             .insert_snippet(macro_declaration + macro_braces_to_insert);
 
@@ -148,28 +198,31 @@ impl Completions {
         let ast_node = func.source(ctx.db).ast;
         let detail = function_label(&ast_node);
 
-        let mut builder = CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name)
-            .kind(if data.has_self_param() {
-                CompletionItemKind::Method
-            } else {
-                CompletionItemKind::Function
-            })
-            .set_documentation(func.docs(ctx.db))
-            .detail(detail);
-        // If not an import, add parenthesis automatically.
+        let mut builder =
+            CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
+                .kind(if data.has_self_param() {
+                    CompletionItemKind::Method
+                } else {
+                    CompletionItemKind::Function
+                })
+                .set_documentation(func.docs(ctx.db))
+                .detail(detail);
+
+        // Add `<>` for generic types
         if ctx.use_item_syntax.is_none()
             && !ctx.is_call
             && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
         {
             tested_by!(inserts_parens_for_function_calls);
-            let snippet =
+            let (snippet, label) =
                 if data.params().is_empty() || data.has_self_param() && data.params().len() == 1 {
-                    format!("{}()$0", data.name())
+                    (format!("{}()$0", data.name()), format!("{}()", name))
                 } else {
-                    format!("{}($0)", data.name())
+                    (format!("{}($0)", data.name()), format!("{}(…)", name))
                 };
-            builder = builder.insert_snippet(snippet);
+            builder = builder.lookup_by(name.clone()).label(label).insert_snippet(snippet);
         }
+
         self.add(builder)
     }
 
@@ -213,7 +266,6 @@ impl Completions {
             .separator(", ")
             .surround_with("(", ")")
             .to_string();
-
         CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
             .kind(CompletionItemKind::EnumVariant)
             .set_documentation(variant.docs(ctx.db))
@@ -222,6 +274,11 @@ impl Completions {
     }
 }
 
+fn has_non_default_type_params(def: hir::GenericDef, db: &db::RootDatabase) -> bool {
+    let subst = db.generic_defaults(def);
+    subst.iter().any(|ty| ty == &Ty::Unknown)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::completion::{do_completion, CompletionItem, CompletionKind};
@@ -242,24 +299,28 @@ mod tests {
                 fn main() { no_<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "main",
-        source_range: [61; 64),
-        delete: [61; 64),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-    CompletionItem {
-        label: "no_args",
-        source_range: [61; 64),
-        delete: [61; 64),
-        insert: "no_args()$0",
-        kind: Function,
-        detail: "fn no_args()",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "main()",
+                source_range: [61; 64),
+                delete: [61; 64),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+            CompletionItem {
+                label: "no_args()",
+                source_range: [61; 64),
+                delete: [61; 64),
+                insert: "no_args()$0",
+                kind: Function,
+                lookup: "no_args",
+                detail: "fn no_args()",
+            },
+        ]
+        "###
         );
         assert_debug_snapshot!(
             do_reference_completion(
@@ -268,24 +329,28 @@ mod tests {
                 fn main() { with_<|> }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "main",
-        source_range: [80; 85),
-        delete: [80; 85),
-        insert: "main()$0",
-        kind: Function,
-        detail: "fn main()",
-    },
-    CompletionItem {
-        label: "with_args",
-        source_range: [80; 85),
-        delete: [80; 85),
-        insert: "with_args($0)",
-        kind: Function,
-        detail: "fn with_args(x: i32, y: String)",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "main()",
+                source_range: [80; 85),
+                delete: [80; 85),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+            CompletionItem {
+                label: "with_args(…)",
+                source_range: [80; 85),
+                delete: [80; 85),
+                insert: "with_args($0)",
+                kind: Function,
+                lookup: "with_args",
+                detail: "fn with_args(x: i32, y: String)",
+            },
+        ]
+        "###
         );
         assert_debug_snapshot!(
             do_reference_completion(
@@ -299,16 +364,19 @@ mod tests {
                 }
                 "
             ),
-            @r###"[
-    CompletionItem {
-        label: "foo",
-        source_range: [163; 164),
-        delete: [163; 164),
-        insert: "foo()$0",
-        kind: Method,
-        detail: "fn foo(&self)",
-    },
-]"###
+            @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [163; 164),
+                delete: [163; 164),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(&self)",
+            },
+        ]
+        "###
         );
     }
 
@@ -389,4 +457,123 @@ mod tests {
 ]"#
         );
     }
+
+    #[test]
+    fn inserts_angle_brackets_for_generics() {
+        covers!(inserts_angle_brackets_for_generics);
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T> {}
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec<…>",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "Vec<$0>",
+                kind: Struct,
+                lookup: "Vec",
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                type Vec<T> = (T,);
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec<…>",
+                source_range: [64; 66),
+                delete: [64; 66),
+                insert: "Vec<$0>",
+                kind: TypeAlias,
+                lookup: "Vec",
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [64; 66),
+                delete: [64; 66),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T = i128> {}
+                fn foo(xs: Ve<|>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec",
+                source_range: [68; 70),
+                delete: [68; 70),
+                insert: "Vec",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [68; 70),
+                delete: [68; 70),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve)",
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Vec<T> {}
+                fn foo(xs: Ve<|><i128>)
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Vec",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "Vec",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [61; 63),
+                delete: [61; 63),
+                insert: "foo($0)",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo(xs: Ve<i128>)",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide_api/src/db.rs b/crates/ra_ide_api/src/db.rs
index ea0714add..9146b647a 100644
--- a/crates/ra_ide_api/src/db.rs
+++ b/crates/ra_ide_api/src/db.rs
@@ -4,8 +4,10 @@ use std::sync::Arc;
 
 use ra_db::{
     salsa::{self, Database, Durability},
-    Canceled, CheckCanceled, CrateId, FileId, SourceDatabase, SourceRootId,
+    Canceled, CheckCanceled, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase,
+    SourceDatabaseExt, SourceRootId,
 };
+use relative_path::RelativePath;
 use rustc_hash::FxHashMap;
 
 use crate::{
@@ -15,6 +17,7 @@ use crate::{
 
 #[salsa::database(
     ra_db::SourceDatabaseStorage,
+    ra_db::SourceDatabaseExtStorage,
     LineIndexDatabaseStorage,
     symbol_index::SymbolsDatabaseStorage,
     hir::db::InternDatabaseStorage,
@@ -31,6 +34,22 @@ pub(crate) struct RootDatabase {
     pub(crate) last_gc_check: crate::wasm_shims::Instant,
 }
 
+impl FileLoader for RootDatabase {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        FileLoaderDelegate(self).file_text(file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        FileLoaderDelegate(self).relevant_crates(file_id)
+    }
+}
+
 impl hir::debug::HirDebugHelper for RootDatabase {
     fn crate_name(&self, krate: CrateId) -> Option<String> {
         self.debug_data.crate_names.get(&krate).cloned()
@@ -39,7 +58,7 @@ impl hir::debug::HirDebugHelper for RootDatabase {
         let source_root_id = self.file_source_root(file_id);
         let source_root_path = self.debug_data.root_paths.get(&source_root_id)?;
         let file_path = self.file_relative_path(file_id);
-        Some(format!("{}/{}", source_root_path, file_path.display()))
+        Some(format!("{}/{}", source_root_path, file_path))
     }
 }
 
@@ -104,7 +123,7 @@ pub(crate) trait LineIndexDatabase: ra_db::SourceDatabase + CheckCanceled {
     fn line_index(&self, file_id: FileId) -> Arc<LineIndex>;
 }
 
-fn line_index(db: &impl ra_db::SourceDatabase, file_id: FileId) -> Arc<LineIndex> {
+fn line_index(db: &impl LineIndexDatabase, file_id: FileId) -> Arc<LineIndex> {
     let text = db.file_text(file_id);
     Arc::new(LineIndex::new(&*text))
 }
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index 0435188c8..8743a3a79 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -4,7 +4,7 @@ use std::cell::RefCell;
 
 use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
 use itertools::Itertools;
-use ra_db::SourceDatabase;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
 use ra_syntax::{
     algo,
@@ -12,6 +12,7 @@ use ra_syntax::{
     Location, SyntaxNode, TextRange, T,
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
+use relative_path::RelativePath;
 
 use crate::{db::RootDatabase, Diagnostic, FileId, FileSystemEdit, SourceChange, SourceFileEdit};
 
@@ -47,8 +48,14 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
         })
     })
     .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-        let source_root = db.file_source_root(d.source().file_id.original_file(db));
-        let create_file = FileSystemEdit::CreateFile { source_root, path: d.candidate.clone() };
+        let original_file = d.source().file_id.original_file(db);
+        let source_root = db.file_source_root(original_file);
+        let path = db
+            .file_relative_path(original_file)
+            .parent()
+            .unwrap_or_else(|| RelativePath::new(""))
+            .join(&d.candidate);
+        let create_file = FileSystemEdit::CreateFile { source_root, path };
         let fix = SourceChange::file_system_edit("create module", create_file);
         res.borrow_mut().push(Diagnostic {
             range: d.highlight_range(),
diff --git a/crates/ra_ide_api/src/display/navigation_target.rs b/crates/ra_ide_api/src/display/navigation_target.rs
index d0b1a8a2a..5cb67fb95 100644
--- a/crates/ra_ide_api/src/display/navigation_target.rs
+++ b/crates/ra_ide_api/src/display/navigation_target.rs
@@ -119,7 +119,7 @@ impl NavigationTarget {
 
     pub(crate) fn from_module(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
         let src = module.definition_source(db);
-        let file_id = src.file_id.as_original_file();
+        let file_id = src.file_id.original_file(db);
         let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
         match src.ast {
             ModuleSource::SourceFile(node) => {
@@ -139,7 +139,7 @@ impl NavigationTarget {
     pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
         let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
         if let Some(src) = module.declaration_source(db) {
-            let file_id = src.file_id.as_original_file();
+            let file_id = src.file_id.original_file(db);
             return NavigationTarget::from_syntax(
                 file_id,
                 name,
@@ -213,7 +213,7 @@ impl NavigationTarget {
     ) -> NavigationTarget {
         let src = impl_block.source(db);
         NavigationTarget::from_syntax(
-            src.file_id.as_original_file(),
+            src.file_id.original_file(db),
             "impl".into(),
             None,
             src.ast.syntax(),
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
index 33fefb541..602757e92 100644
--- a/crates/ra_ide_api/src/extend_selection.rs
+++ b/crates/ra_ide_api/src/extend_selection.rs
@@ -32,6 +32,7 @@ fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange
         PARAM_LIST,
         ARG_LIST,
         ARRAY_EXPR,
+        TUPLE_EXPR,
     ];
 
     if range.is_empty() {
@@ -245,6 +246,8 @@ mod tests {
         do_check(r#"const FOO: [usize; 2] = [ 22 , 33<|>];"#, &["33", ", 33"]);
         do_check(r#"const FOO: [usize; 2] = [ 22 , 33<|> ,];"#, &["33", ", 33"]);
 
+        do_check(r#"fn main() { (1, 2<|>) }"#, &["2", ", 2", "(1, 2)"]);
+
         do_check(
             r#"
 const FOO: [usize; 2] = [
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 41a88314f..1f3fa6c57 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -10,7 +10,7 @@ use ra_syntax::{
 use crate::{
     db::RootDatabase,
     display::ShortLabel,
-    name_ref_kind::{classify_name_ref, NameRefKind::*},
+    references::{classify_name_ref, NameKind::*},
     FilePosition, NavigationTarget, RangeInfo,
 };
 
@@ -54,13 +54,11 @@ pub(crate) fn reference_definition(
 ) -> ReferenceResult {
     use self::ReferenceResult::*;
 
-    let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
-
-    match classify_name_ref(db, &analyzer, name_ref) {
+    let name_kind = classify_name_ref(db, file_id, &name_ref).map(|d| d.kind);
+    match name_kind {
         Some(Macro(mac)) => return Exact(NavigationTarget::from_macro_def(db, mac)),
-        Some(FieldAccess(field)) => return Exact(NavigationTarget::from_field(db, field)),
+        Some(Field(field)) => return Exact(NavigationTarget::from_field(db, field)),
         Some(AssocItem(assoc)) => return Exact(NavigationTarget::from_assoc_item(db, assoc)),
-        Some(Method(func)) => return Exact(NavigationTarget::from_def_source(db, func)),
         Some(Def(def)) => match NavigationTarget::from_def(db, def) {
             Some(nav) => return Exact(nav),
             None => return Approximate(vec![]),
@@ -70,7 +68,7 @@ pub(crate) fn reference_definition(
                 return Exact(NavigationTarget::from_adt_def(db, def_id));
             }
         }
-        Some(Pat(pat)) => return Exact(NavigationTarget::from_pat(db, file_id, pat)),
+        Some(Pat((_, pat))) => return Exact(NavigationTarget::from_pat(db, file_id, pat)),
         Some(SelfParam(par)) => return Exact(NavigationTarget::from_self_param(file_id, par)),
         Some(GenericParam(_)) => {
             // FIXME: go to the generic param def
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
index 24b161c5c..ba328efa1 100644
--- a/crates/ra_ide_api/src/hover.rs
+++ b/crates/ra_ide_api/src/hover.rs
@@ -14,7 +14,7 @@ use crate::{
         description_from_symbol, docs_from_symbol, macro_label, rust_code_markup,
         rust_code_markup_with_doc, ShortLabel,
     },
-    name_ref_kind::{classify_name_ref, NameRefKind::*},
+    references::{classify_name_ref, NameKind::*},
     FilePosition, FileRange, RangeInfo,
 };
 
@@ -99,17 +99,14 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 
     let mut range = None;
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
-        let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
-
         let mut no_fallback = false;
-
-        match classify_name_ref(db, &analyzer, &name_ref) {
-            Some(Method(it)) => res.extend(from_def_source(db, it)),
+        let name_kind = classify_name_ref(db, position.file_id, &name_ref).map(|d| d.kind);
+        match name_kind {
             Some(Macro(it)) => {
                 let src = it.source(db);
                 res.extend(hover_text(src.ast.doc_comment_text(), Some(macro_label(&src.ast))));
             }
-            Some(FieldAccess(it)) => {
+            Some(Field(it)) => {
                 let src = it.source(db);
                 if let hir::FieldSource::Named(it) = src.ast {
                     res.extend(hover_text(it.doc_comment_text(), it.short_label()));
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 24f1b91f6..19669a7f0 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -19,7 +19,6 @@ mod feature_flags;
 mod status;
 mod completion;
 mod runnables;
-mod name_ref_kind;
 mod goto_definition;
 mod goto_type_definition;
 mod extend_selection;
@@ -52,7 +51,7 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use ra_db::{
     salsa::{self, ParallelDatabase},
-    CheckCanceled, SourceDatabase,
+    CheckCanceled, FileLoader, SourceDatabase,
 };
 use ra_syntax::{SourceFile, TextRange, TextUnit};
 use ra_text_edit::TextEdit;
@@ -289,10 +288,14 @@ impl AnalysisHost {
     pub fn per_query_memory_usage(&mut self) -> Vec<(String, ra_prof::Bytes)> {
         self.db.per_query_memory_usage()
     }
-    pub fn raw_database(&self) -> &(impl hir::db::HirDatabase + salsa::Database) {
+    pub fn raw_database(
+        &self,
+    ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
         &self.db
     }
-    pub fn raw_database_mut(&mut self) -> &mut (impl hir::db::HirDatabase + salsa::Database) {
+    pub fn raw_database_mut(
+        &mut self,
+    ) -> &mut (impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
         &mut self.db
     }
 }
@@ -325,7 +328,8 @@ impl Analysis {
         let file_id = FileId(0);
         // FIXME: cfg options
         // Default to enable test for single file.
-        let cfg_options = CfgOptions::default().atom("test".into());
+        let mut cfg_options = CfgOptions::default();
+        cfg_options.insert_atom("test".into());
         crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options);
         change.add_file(source_root, file_id, "main.rs".into(), Arc::new(text));
         change.set_crate_graph(crate_graph);
diff --git a/crates/ra_ide_api/src/marks.rs b/crates/ra_ide_api/src/marks.rs
index 3f4ba248b..848ae4dc7 100644
--- a/crates/ra_ide_api/src/marks.rs
+++ b/crates/ra_ide_api/src/marks.rs
@@ -1,6 +1,7 @@
 //! See test_utils/src/marks.rs
 
 test_utils::marks!(
+    inserts_angle_brackets_for_generics
     inserts_parens_for_function_calls
     goto_definition_works_for_macros
     goto_definition_works_for_methods
diff --git a/crates/ra_ide_api/src/name_ref_kind.rs b/crates/ra_ide_api/src/name_ref_kind.rs
deleted file mode 100644
index 149585971..000000000
--- a/crates/ra_ide_api/src/name_ref_kind.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-//! FIXME: write short doc here
-
-use hir::Either;
-use ra_syntax::{ast, AstNode, AstPtr};
-use test_utils::tested_by;
-
-use crate::db::RootDatabase;
-
-pub enum NameRefKind {
-    Method(hir::Function),
-    Macro(hir::MacroDef),
-    FieldAccess(hir::StructField),
-    AssocItem(hir::AssocItem),
-    Def(hir::ModuleDef),
-    SelfType(hir::Ty),
-    Pat(AstPtr<ast::BindPat>),
-    SelfParam(AstPtr<ast::SelfParam>),
-    GenericParam(u32),
-}
-
-pub(crate) fn classify_name_ref(
-    db: &RootDatabase,
-    analyzer: &hir::SourceAnalyzer,
-    name_ref: &ast::NameRef,
-) -> Option<NameRefKind> {
-    use NameRefKind::*;
-
-    // Check if it is a method
-    if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
-        tested_by!(goto_definition_works_for_methods);
-        if let Some(func) = analyzer.resolve_method_call(&method_call) {
-            return Some(Method(func));
-        }
-    }
-
-    // It could be a macro call
-    if let Some(macro_call) = name_ref
-        .syntax()
-        .parent()
-        .and_then(|node| node.parent())
-        .and_then(|node| node.parent())
-        .and_then(ast::MacroCall::cast)
-    {
-        tested_by!(goto_definition_works_for_macros);
-        if let Some(mac) = analyzer.resolve_macro_call(db, &macro_call) {
-            return Some(Macro(mac));
-        }
-    }
-
-    // It could also be a field access
-    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
-        tested_by!(goto_definition_works_for_fields);
-        if let Some(field) = analyzer.resolve_field(&field_expr) {
-            return Some(FieldAccess(field));
-        };
-    }
-
-    // It could also be a named field
-    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::RecordField::cast) {
-        tested_by!(goto_definition_works_for_record_fields);
-
-        let record_lit = field_expr.syntax().ancestors().find_map(ast::RecordLit::cast);
-
-        if let Some(ty) = record_lit.and_then(|lit| analyzer.type_of(db, &lit.into())) {
-            if let Some((hir::Adt::Struct(s), _)) = ty.as_adt() {
-                let hir_path = hir::Path::from_name_ref(name_ref);
-                let hir_name = hir_path.as_ident().unwrap();
-
-                if let Some(field) = s.field(db, hir_name) {
-                    return Some(FieldAccess(field));
-                }
-            }
-        }
-    }
-
-    // General case, a path or a local:
-    if let Some(path) = name_ref.syntax().ancestors().find_map(ast::Path::cast) {
-        if let Some(resolved) = analyzer.resolve_path(db, &path) {
-            return match resolved {
-                hir::PathResolution::Def(def) => Some(Def(def)),
-                hir::PathResolution::LocalBinding(Either::A(pat)) => Some(Pat(pat)),
-                hir::PathResolution::LocalBinding(Either::B(par)) => Some(SelfParam(par)),
-                hir::PathResolution::GenericParam(par) => {
-                    // FIXME: get generic param def
-                    Some(GenericParam(par))
-                }
-                hir::PathResolution::Macro(def) => Some(Macro(def)),
-                hir::PathResolution::SelfType(impl_block) => {
-                    let ty = impl_block.target_ty(db);
-                    Some(SelfType(ty))
-                }
-                hir::PathResolution::AssocItem(assoc) => Some(AssocItem(assoc)),
-            };
-        }
-    }
-
-    None
-}
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()
     }
 }
diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs
new file mode 100644
index 000000000..c8daff9b1
--- /dev/null
+++ b/crates/ra_ide_api/src/references/classify.rs
@@ -0,0 +1,179 @@
+//! Functions that are used to classify an element from its definition or reference.
+
+use hir::{Either, FromSource, Module, ModuleSource, Path, PathResolution, Source, SourceAnalyzer};
+use ra_db::FileId;
+use ra_syntax::{ast, match_ast, AstNode, AstPtr};
+use test_utils::tested_by;
+
+use super::{
+    name_definition::{from_assoc_item, from_module_def, from_pat, from_struct_field},
+    NameDefinition, NameKind,
+};
+use crate::db::RootDatabase;
+
+pub(crate) fn classify_name(
+    db: &RootDatabase,
+    file_id: FileId,
+    name: &ast::Name,
+) -> Option<NameDefinition> {
+    let parent = name.syntax().parent()?;
+    let file_id = file_id.into();
+
+    // FIXME: add ast::MacroCall(it)
+    match_ast! {
+        match parent {
+            ast::BindPat(it) => {
+                from_pat(db, file_id, AstPtr::new(&it))
+            },
+            ast::RecordFieldDef(it) => {
+                let ast = hir::FieldSource::Named(it);
+                let src = hir::Source { file_id, ast };
+                let field = hir::StructField::from_source(db, src)?;
+                Some(from_struct_field(db, field))
+            },
+            ast::Module(it) => {
+                let def = {
+                    if !it.has_semi() {
+                        let ast = hir::ModuleSource::Module(it);
+                        let src = hir::Source { file_id, ast };
+                        hir::Module::from_definition(db, src)
+                    } else {
+                        let src = hir::Source { file_id, ast: it };
+                        hir::Module::from_declaration(db, src)
+                    }
+                }?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::StructDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Struct::from_source(db, src)?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::EnumDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Enum::from_source(db, src)?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::TraitDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Trait::from_source(db, src)?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::StaticDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Static::from_source(db, src)?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::EnumVariant(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::EnumVariant::from_source(db, src)?;
+                Some(from_module_def(db, def.into(), None))
+            },
+            ast::FnDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Function::from_source(db, src)?;
+                if parent.parent().and_then(ast::ItemList::cast).is_some() {
+                    Some(from_assoc_item(db, def.into()))
+                } else {
+                    Some(from_module_def(db, def.into(), None))
+                }
+            },
+            ast::ConstDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::Const::from_source(db, src)?;
+                if parent.parent().and_then(ast::ItemList::cast).is_some() {
+                    Some(from_assoc_item(db, def.into()))
+                } else {
+                    Some(from_module_def(db, def.into(), None))
+                }
+            },
+            ast::TypeAliasDef(it) => {
+                let src = hir::Source { file_id, ast: it };
+                let def = hir::TypeAlias::from_source(db, src)?;
+                if parent.parent().and_then(ast::ItemList::cast).is_some() {
+                    Some(from_assoc_item(db, def.into()))
+                } else {
+                    Some(from_module_def(db, def.into(), None))
+                }
+            },
+            _ => None,
+        }
+    }
+}
+
+pub(crate) fn classify_name_ref(
+    db: &RootDatabase,
+    file_id: FileId,
+    name_ref: &ast::NameRef,
+) -> Option<NameDefinition> {
+    use PathResolution::*;
+
+    let parent = name_ref.syntax().parent()?;
+    let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
+
+    if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
+        tested_by!(goto_definition_works_for_methods);
+        if let Some(func) = analyzer.resolve_method_call(&method_call) {
+            return Some(from_assoc_item(db, func.into()));
+        }
+    }
+
+    if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
+        tested_by!(goto_definition_works_for_fields);
+        if let Some(field) = analyzer.resolve_field(&field_expr) {
+            return Some(from_struct_field(db, field));
+        }
+    }
+
+    if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
+        tested_by!(goto_definition_works_for_record_fields);
+        if let Some(record_lit) = record_field.syntax().ancestors().find_map(ast::RecordLit::cast) {
+            let variant_def = analyzer.resolve_record_literal(&record_lit)?;
+            let hir_path = Path::from_name_ref(name_ref);
+            let hir_name = hir_path.as_ident()?;
+            let field = variant_def.field(db, hir_name)?;
+            return Some(from_struct_field(db, field));
+        }
+    }
+
+    let ast = ModuleSource::from_child_node(db, file_id, &parent);
+    let file_id = file_id.into();
+    // FIXME: find correct container and visibility for each case
+    let container = Module::from_definition(db, Source { file_id, ast })?;
+    let visibility = None;
+
+    if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
+        tested_by!(goto_definition_works_for_macros);
+        if let Some(macro_def) = analyzer.resolve_macro_call(db, &macro_call) {
+            let kind = NameKind::Macro(macro_def);
+            return Some(NameDefinition { kind, container, visibility });
+        }
+    }
+
+    let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
+    let resolved = analyzer.resolve_path(db, &path)?;
+    match resolved {
+        Def(def) => Some(from_module_def(db, def, Some(container))),
+        AssocItem(item) => Some(from_assoc_item(db, item)),
+        LocalBinding(Either::A(pat)) => from_pat(db, file_id, pat),
+        LocalBinding(Either::B(par)) => {
+            let kind = NameKind::SelfParam(par);
+            Some(NameDefinition { kind, container, visibility })
+        }
+        GenericParam(par) => {
+            // FIXME: get generic param def
+            let kind = NameKind::GenericParam(par);
+            Some(NameDefinition { kind, container, visibility })
+        }
+        Macro(def) => {
+            let kind = NameKind::Macro(def);
+            Some(NameDefinition { kind, container, visibility })
+        }
+        SelfType(impl_block) => {
+            let ty = impl_block.target_ty(db);
+            let kind = NameKind::SelfType(ty);
+            let container = impl_block.module();
+            Some(NameDefinition { kind, container, visibility })
+        }
+    }
+}
diff --git a/crates/ra_ide_api/src/references/name_definition.rs b/crates/ra_ide_api/src/references/name_definition.rs
new file mode 100644
index 000000000..4580bc789
--- /dev/null
+++ b/crates/ra_ide_api/src/references/name_definition.rs
@@ -0,0 +1,113 @@
+//! `NameDefinition` keeps information about the element we want to search references for.
+//! The element is represented by `NameKind`. It's located inside some `container` and
+//! has a `visibility`, which defines a search scope.
+//! Note that the reference search is possible for not all of the classified items.
+
+use hir::{
+    db::AstDatabase, Adt, AssocItem, DefWithBody, FromSource, HasSource, HirFileId, MacroDef,
+    Module, ModuleDef, StructField, Ty, VariantDef,
+};
+use ra_syntax::{ast, ast::VisibilityOwner, match_ast, AstNode, AstPtr};
+
+use crate::db::RootDatabase;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum NameKind {
+    Macro(MacroDef),
+    Field(StructField),
+    AssocItem(AssocItem),
+    Def(ModuleDef),
+    SelfType(Ty),
+    Pat((DefWithBody, AstPtr<ast::BindPat>)),
+    SelfParam(AstPtr<ast::SelfParam>),
+    GenericParam(u32),
+}
+
+#[derive(PartialEq, Eq)]
+pub(crate) struct NameDefinition {
+    pub visibility: Option<ast::Visibility>,
+    pub container: Module,
+    pub kind: NameKind,
+}
+
+pub(super) fn from_pat(
+    db: &RootDatabase,
+    file_id: HirFileId,
+    pat: AstPtr<ast::BindPat>,
+) -> Option<NameDefinition> {
+    let root = db.parse_or_expand(file_id)?;
+    let def = pat.to_node(&root).syntax().ancestors().find_map(|node| {
+        match_ast! {
+            match node {
+                ast::FnDef(it) => {
+                    let src = hir::Source { file_id, ast: it };
+                    Some(hir::Function::from_source(db, src)?.into())
+                },
+                ast::ConstDef(it) => {
+                    let src = hir::Source { file_id, ast: it };
+                    Some(hir::Const::from_source(db, src)?.into())
+                },
+                ast::StaticDef(it) => {
+                    let src = hir::Source { file_id, ast: it };
+                    Some(hir::Static::from_source(db, src)?.into())
+                },
+                _ => None,
+            }
+        }
+    })?;
+    let kind = NameKind::Pat((def, pat));
+    let container = def.module(db);
+    Some(NameDefinition { kind, container, visibility: None })
+}
+
+pub(super) fn from_assoc_item(db: &RootDatabase, item: AssocItem) -> NameDefinition {
+    let container = item.module(db);
+    let visibility = match item {
+        AssocItem::Function(f) => f.source(db).ast.visibility(),
+        AssocItem::Const(c) => c.source(db).ast.visibility(),
+        AssocItem::TypeAlias(a) => a.source(db).ast.visibility(),
+    };
+    let kind = NameKind::AssocItem(item);
+    NameDefinition { kind, container, visibility }
+}
+
+pub(super) fn from_struct_field(db: &RootDatabase, field: StructField) -> NameDefinition {
+    let kind = NameKind::Field(field);
+    let parent = field.parent_def(db);
+    let container = parent.module(db);
+    let visibility = match parent {
+        VariantDef::Struct(s) => s.source(db).ast.visibility(),
+        VariantDef::EnumVariant(e) => e.source(db).ast.parent_enum().visibility(),
+    };
+    NameDefinition { kind, container, visibility }
+}
+
+pub(super) fn from_module_def(
+    db: &RootDatabase,
+    def: ModuleDef,
+    module: Option<Module>,
+) -> NameDefinition {
+    let kind = NameKind::Def(def);
+    let (container, visibility) = match def {
+        ModuleDef::Module(it) => {
+            let container = it.parent(db).or_else(|| Some(it)).unwrap();
+            let visibility = it.declaration_source(db).and_then(|s| s.ast.visibility());
+            (container, visibility)
+        }
+        ModuleDef::EnumVariant(it) => {
+            let container = it.module(db);
+            let visibility = it.source(db).ast.parent_enum().visibility();
+            (container, visibility)
+        }
+        ModuleDef::Function(it) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Const(it) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Static(it) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Trait(it) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::TypeAlias(it) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Adt(Adt::Struct(it)) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Adt(Adt::Union(it)) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::Adt(Adt::Enum(it)) => (it.module(db), it.source(db).ast.visibility()),
+        ModuleDef::BuiltinType(..) => (module.unwrap(), None),
+    };
+    NameDefinition { kind, container, visibility }
+}
diff --git a/crates/ra_ide_api/src/references/rename.rs b/crates/ra_ide_api/src/references/rename.rs
new file mode 100644
index 000000000..0e2e088e0
--- /dev/null
+++ b/crates/ra_ide_api/src/references/rename.rs
@@ -0,0 +1,469 @@
+//! FIXME: write short doc here
+
+use hir::ModuleSource;
+use ra_db::{SourceDatabase, SourceDatabaseExt};
+use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode};
+use relative_path::{RelativePath, RelativePathBuf};
+
+use crate::{
+    db::RootDatabase, FileId, FilePosition, FileSystemEdit, RangeInfo, SourceChange,
+    SourceFileEdit, TextRange,
+};
+
+use super::find_all_refs;
+
+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)
+    }
+}
+
+fn find_name_and_module_at_offset(
+    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()
+        },
+    }
+}
+
+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.original_file(db);
+        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);
+                }
+            }
+            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)))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
+        ReferenceSearchResult,
+    };
+    use insta::assert_debug_snapshot;
+    use test_utils::assert_eq_text;
+
+    #[test]
+    fn test_find_all_refs_for_local() {
+        let code = r#"
+    fn main() {
+        let mut i = 1;
+        let j = 1;
+        i = i<|> + j;
+
+        {
+            i = 0;
+        }
+
+        i = 5;
+    }"#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 5);
+    }
+
+    #[test]
+    fn test_find_all_refs_for_param_inside() {
+        let code = r#"
+    fn foo(i : u32) -> u32 {
+        i<|>
+    }"#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 2);
+    }
+
+    #[test]
+    fn test_find_all_refs_for_fn_param() {
+        let code = r#"
+    fn foo(i<|> : u32) -> u32 {
+        i
+    }"#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 2);
+    }
+
+    #[test]
+    fn test_find_all_refs_field_name() {
+        let code = r#"
+            //- /lib.rs
+            struct Foo {
+                pub spam<|>: u32,
+            }
+
+            fn main(s: Foo) {
+                let f = s.spam;
+            }
+        "#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 2);
+    }
+
+    #[test]
+    fn test_find_all_refs_impl_item_name() {
+        let code = r#"
+            //- /lib.rs
+            struct Foo;
+            impl Foo {
+                fn f<|>(&self) {  }
+            }
+        "#;
+
+        let refs = get_all_refs(code);
+        assert_eq!(refs.len(), 1);
+    }
+
+    #[test]
+    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_find_all_refs_modules() {
+        let code = r#"
+            //- /lib.rs
+            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);
+    }
+
+    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;
+
+        {
+            k = 0;
+        }
+
+        k = 5;
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_for_param_inside() {
+        test_rename(
+            r#"
+    fn foo(i : u32) -> u32 {
+        i<|>
+    }"#,
+            "j",
+            r#"
+    fn foo(j : u32) -> u32 {
+        j
+    }"#,
+        );
+    }
+
+    #[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
+    }"#,
+        );
+    }
+
+    #[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
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_mod() {
+        let (analysis, position) = analysis_and_position(
+            "
+            //- /lib.rs
+            mod bar;
+
+            //- /bar.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,
+                },
+            },
+        )
+        "###);
+    }
+
+    #[test]
+    fn test_rename_mod_in_dir() {
+        let (analysis, position) = analysis_and_position(
+            "
+            //- /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,
+                },
+            },
+        )
+        "###
+               );
+    }
+
+    fn test_rename(text: &str, new_name: &str, expected: &str) {
+        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);
+    }
+}
diff --git a/crates/ra_ide_api/src/references/search_scope.rs b/crates/ra_ide_api/src/references/search_scope.rs
new file mode 100644
index 000000000..5cb69b8fc
--- /dev/null
+++ b/crates/ra_ide_api/src/references/search_scope.rs
@@ -0,0 +1,92 @@
+//! Generally, `search_scope` returns files that might contain references for the element.
+//! For `pub(crate)` things it's a crate, for `pub` things it's a crate and dependant crates.
+//! In some cases, the location of the references is known to within a `TextRange`,
+//! e.g. for things like local variables.
+
+use hir::{DefWithBody, HasSource, ModuleSource};
+use ra_db::{FileId, SourceDatabase, SourceDatabaseExt};
+use ra_syntax::{AstNode, TextRange};
+use rustc_hash::FxHashSet;
+
+use crate::db::RootDatabase;
+
+use super::{NameDefinition, NameKind};
+
+impl NameDefinition {
+    pub(crate) fn search_scope(&self, db: &RootDatabase) -> FxHashSet<(FileId, Option<TextRange>)> {
+        let module_src = self.container.definition_source(db);
+        let file_id = module_src.file_id.original_file(db);
+
+        if let NameKind::Pat((def, _)) = self.kind {
+            let mut res = FxHashSet::default();
+            let range = match def {
+                DefWithBody::Function(f) => f.source(db).ast.syntax().text_range(),
+                DefWithBody::Const(c) => c.source(db).ast.syntax().text_range(),
+                DefWithBody::Static(s) => s.source(db).ast.syntax().text_range(),
+            };
+            res.insert((file_id, Some(range)));
+            return res;
+        }
+
+        let vis =
+            self.visibility.as_ref().map(|v| v.syntax().to_string()).unwrap_or("".to_string());
+
+        if vis.as_str() == "pub(super)" {
+            if let Some(parent_module) = self.container.parent(db) {
+                let mut files = FxHashSet::default();
+                let parent_src = parent_module.definition_source(db);
+                let file_id = parent_src.file_id.original_file(db);
+
+                match parent_src.ast {
+                    ModuleSource::Module(m) => {
+                        let range = Some(m.syntax().text_range());
+                        files.insert((file_id, range));
+                    }
+                    ModuleSource::SourceFile(_) => {
+                        files.insert((file_id, None));
+                        files.extend(parent_module.children(db).map(|m| {
+                            let src = m.definition_source(db);
+                            (src.file_id.original_file(db), None)
+                        }));
+                    }
+                }
+                return files;
+            }
+        }
+
+        if vis.as_str() != "" {
+            let source_root_id = db.file_source_root(file_id);
+            let source_root = db.source_root(source_root_id);
+            let mut files =
+                source_root.walk().map(|id| (id.into(), None)).collect::<FxHashSet<_>>();
+
+            // FIXME: add "pub(in path)"
+
+            if vis.as_str() == "pub(crate)" {
+                return files;
+            }
+            if vis.as_str() == "pub" {
+                let krate = self.container.krate(db).unwrap();
+                let crate_graph = db.crate_graph();
+                for crate_id in crate_graph.iter() {
+                    let mut crate_deps = crate_graph.dependencies(crate_id);
+                    if crate_deps.any(|dep| dep.crate_id() == krate.crate_id()) {
+                        let root_file = crate_graph.crate_root(crate_id);
+                        let source_root_id = db.file_source_root(root_file);
+                        let source_root = db.source_root(source_root_id);
+                        files.extend(source_root.walk().map(|id| (id.into(), None)));
+                    }
+                }
+                return files;
+            }
+        }
+
+        let mut res = FxHashSet::default();
+        let range = match module_src.ast {
+            ModuleSource::Module(m) => Some(m.syntax().text_range()),
+            ModuleSource::SourceFile(_) => None,
+        };
+        res.insert((file_id, range));
+        res
+    }
+}
diff --git a/crates/ra_ide_api/src/snapshots/highlighting.html b/crates/ra_ide_api/src/snapshots/highlighting.html
index ae30ebba3..b39c4d371 100644
--- a/crates/ra_ide_api/src/snapshots/highlighting.html
+++ b/crates/ra_ide_api/src/snapshots/highlighting.html
@@ -19,7 +19,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .keyword\.unsafe   { color: #DFAF8F; }
 .keyword\.control  { color: #F0DFAF; font-weight: bold; }
 </style>
-<pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute text">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
+<pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
 <span class="keyword">struct</span> <span class="type">Foo</span> {
     <span class="keyword">pub</span> <span class="field">x</span>: <span class="type">i32</span>,
     <span class="keyword">pub</span> <span class="field">y</span>: <span class="type">i32</span>,
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
index 797e9926f..5729eb5b3 100644
--- a/crates/ra_ide_api/src/symbol_index.rs
+++ b/crates/ra_ide_api/src/symbol_index.rs
@@ -29,7 +29,7 @@ use std::{
 use fst::{self, Streamer};
 use ra_db::{
     salsa::{self, ParallelDatabase},
-    SourceDatabase, SourceRootId,
+    SourceDatabaseExt, SourceRootId,
 };
 use ra_syntax::{
     ast::{self, NameOwner},
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 9ae2dc061..33f3caceb 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -14,7 +14,7 @@ use ra_syntax::{
 
 use crate::{
     db::RootDatabase,
-    name_ref_kind::{classify_name_ref, NameRefKind::*},
+    references::{classify_name_ref, NameKind::*},
     FileId,
 };
 
@@ -97,13 +97,14 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
             STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
             ATTR => "attribute",
             NAME_REF => {
+                if node.ancestors().any(|it| it.kind() == ATTR) {
+                    continue;
+                }
                 if let Some(name_ref) = node.as_node().cloned().and_then(ast::NameRef::cast) {
-                    // FIXME: try to reuse the SourceAnalyzers
-                    let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
-                    match classify_name_ref(db, &analyzer, &name_ref) {
-                        Some(Method(_)) => "function",
+                    let name_kind = classify_name_ref(db, file_id, &name_ref).map(|d| d.kind);
+                    match name_kind {
                         Some(Macro(_)) => "macro",
-                        Some(FieldAccess(_)) => "field",
+                        Some(Field(_)) => "field",
                         Some(AssocItem(hir::AssocItem::Function(_))) => "function",
                         Some(AssocItem(hir::AssocItem::Const(_))) => "constant",
                         Some(AssocItem(hir::AssocItem::TypeAlias(_))) => "type",
@@ -117,7 +118,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                         Some(Def(hir::ModuleDef::TypeAlias(_))) => "type",
                         Some(Def(hir::ModuleDef::BuiltinType(_))) => "type",
                         Some(SelfType(_)) => "type",
-                        Some(Pat(ptr)) => {
+                        Some(Pat((_, ptr))) => {
                             let pat = ptr.to_node(&root);
                             if let Some(name) = pat.name() {
                                 let text = name.text();
@@ -127,6 +128,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                                     Some(calc_binding_hash(file_id, &text, *shadow_count))
                             }
 
+                            let analyzer =
+                                hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
                             if is_variable_mutable(db, &analyzer, ptr.to_node(&root)) {
                                 "variable.mut"
                             } else {