6 files changed, 311 insertions, 106 deletions

diff --git a/crates/ra_ide_api/src/display/navigation_target.rs b/crates/ra_ide_api/src/display/navigation_target.rs
index 7ea336c50..1c694cbc9 100644
--- a/crates/ra_ide_api/src/display/navigation_target.rs
+++ b/crates/ra_ide_api/src/display/navigation_target.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner, TypeAscriptionOwner},
     algo::visit::{visitor, Visitor},
 };
-use hir::{ModuleSource, FieldSource, ImplItem, Either};
+use hir::{ModuleSource, FieldSource, ImplItem};
 
 use crate::{FileSymbol, db::RootDatabase};
 
@@ -77,17 +77,12 @@ impl NavigationTarget {
     pub(crate) fn from_pat(
         db: &RootDatabase,
         file_id: FileId,
-        pat: Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>,
+        pat: AstPtr<ast::Pat>,
     ) -> NavigationTarget {
         let file = db.parse(file_id);
-        let (name, full_range) = match pat {
-            Either::A(pat) => match pat.to_node(file.syntax()).kind() {
-                ast::PatKind::BindPat(pat) => {
-                    return NavigationTarget::from_bind_pat(file_id, &pat)
-                }
-                _ => ("_".into(), pat.syntax_node_ptr().range()),
-            },
-            Either::B(slf) => ("self".into(), slf.syntax_node_ptr().range()),
+        let (name, full_range) = match pat.to_node(file.syntax()).kind() {
+            ast::PatKind::BindPat(pat) => return NavigationTarget::from_bind_pat(file_id, &pat),
+            _ => ("_".into(), pat.syntax_node_ptr().range()),
         };
         NavigationTarget {
             file_id,
@@ -99,6 +94,21 @@ impl NavigationTarget {
         }
     }
 
+    pub(crate) fn from_self_param(
+        file_id: FileId,
+        par: AstPtr<ast::SelfParam>,
+    ) -> NavigationTarget {
+        let (name, full_range) = ("self".into(), par.syntax_node_ptr().range());
+        NavigationTarget {
+            file_id,
+            name,
+            full_range,
+            focus_range: None,
+            kind: NAME,
+            container_name: None,
+        }
+    }
+
     pub(crate) fn from_module(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
         let (file_id, source) = module.definition_source(db);
         let file_id = file_id.as_original_file();
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index adae29e9c..9c56f17f2 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -1,12 +1,19 @@
 use ra_db::{FileId, SourceDatabase};
 use ra_syntax::{
     AstNode, ast,
-    algo::{find_node_at_offset, visit::{visitor, Visitor}},
+    algo::{
+        find_node_at_offset,
+        visit::{visitor, Visitor},
+    },
     SyntaxNode,
 };
-use test_utils::tested_by;
 
-use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
+use crate::{
+    FilePosition, NavigationTarget,
+    db::RootDatabase,
+    RangeInfo,
+    name_ref_kind::{NameRefKind::*, classify_name_ref},
+};
 
 pub(crate) fn goto_definition(
     db: &RootDatabase,
@@ -50,85 +57,24 @@ pub(crate) fn reference_definition(
 
     let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
 
-    // Special cases:
-
-    // 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 Exact(NavigationTarget::from_function(db, 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(macro_call) = analyzer.resolve_macro_call(macro_call) {
-            return Exact(NavigationTarget::from_macro_def(db, macro_call));
-        }
-    }
-
-    // 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 Exact(NavigationTarget::from_field(db, field));
-        };
-    }
-
-    // It could also be a named field
-    if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::NamedField::cast) {
-        tested_by!(goto_definition_works_for_named_fields);
-
-        let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
-
-        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, lit.into())) {
-            if let Some((hir::AdtDef::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 Exact(NavigationTarget::from_field(db, field));
-                }
+    match classify_name_ref(db, &analyzer, name_ref) {
+        Some(Method(func)) => return Exact(NavigationTarget::from_function(db, func)),
+        Some(Macro(mac)) => return Exact(NavigationTarget::from_macro_def(db, mac)),
+        Some(FieldAccess(field)) => return Exact(NavigationTarget::from_field(db, field)),
+        Some(AssocItem(assoc)) => return Exact(NavigationTarget::from_impl_item(db, assoc)),
+        Some(Def(def)) => return Exact(NavigationTarget::from_def(db, def)),
+        Some(SelfType(ty)) => {
+            if let Some((def_id, _)) = ty.as_adt() {
+                return Exact(NavigationTarget::from_adt_def(db, def_id));
             }
         }
-    }
-
-    // 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) {
-            match resolved {
-                hir::PathResolution::Def(def) => return Exact(NavigationTarget::from_def(db, def)),
-                hir::PathResolution::LocalBinding(pat) => {
-                    let nav = NavigationTarget::from_pat(db, file_id, pat);
-                    return Exact(nav);
-                }
-                hir::PathResolution::GenericParam(..) => {
-                    // FIXME: go to the generic param def
-                }
-                hir::PathResolution::Macro(def) => {
-                    let nav = NavigationTarget::from_macro_def(db, def);
-                    return Exact(nav);
-                }
-                hir::PathResolution::SelfType(impl_block) => {
-                    let ty = impl_block.target_ty(db);
-
-                    if let Some((def_id, _)) = ty.as_adt() {
-                        return Exact(NavigationTarget::from_adt_def(db, def_id));
-                    }
-                }
-                hir::PathResolution::AssocItem(assoc) => {
-                    return Exact(NavigationTarget::from_impl_item(db, assoc));
-                }
-            }
+        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
         }
-    }
+        None => {}
+    };
 
     // Fallback index based approach:
     let navs = crate::symbol_index::index_resolve(db, name_ref)
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index d4be8bd6c..f78348f74 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -18,6 +18,7 @@ mod change;
 mod status;
 mod completion;
 mod runnables;
+mod name_ref_kind;
 mod goto_definition;
 mod goto_type_definition;
 mod extend_selection;
@@ -53,10 +54,7 @@ use ra_db::{
 };
 use relative_path::RelativePathBuf;
 
-use crate::{
-    symbol_index::FileSymbol,
-    db::LineIndexDatabase,
-};
+use crate::{symbol_index::FileSymbol, db::LineIndexDatabase};
 
 pub use crate::{
     change::{AnalysisChange, LibraryData},
@@ -73,10 +71,7 @@ pub use crate::{
     display::{FunctionSignature, NavigationTarget, StructureNode, file_structure},
 };
 
-pub use ra_db::{
-    Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId,
-    Edition
-};
+pub use ra_db::{Canceled, CrateGraph, CrateId, FileId, FilePosition, FileRange, SourceRootId, Edition};
 pub use hir::Documentation;
 
 // We use jemalloc mainly to get heap usage statistics, actual performance
diff --git a/crates/ra_ide_api/src/name_ref_kind.rs b/crates/ra_ide_api/src/name_ref_kind.rs
new file mode 100644
index 000000000..b498fe495
--- /dev/null
+++ b/crates/ra_ide_api/src/name_ref_kind.rs
@@ -0,0 +1,95 @@
+use ra_syntax::{AstNode, AstPtr, ast};
+use hir::Either;
+use crate::db::RootDatabase;
+use test_utils::tested_by;
+
+pub enum NameRefKind {
+    Method(hir::Function),
+    Macro(hir::MacroByExampleDef),
+    FieldAccess(hir::StructField),
+    AssocItem(hir::ImplItem),
+    Def(hir::ModuleDef),
+    SelfType(hir::Ty),
+    Pat(AstPtr<ast::Pat>),
+    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(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::NamedField::cast) {
+        tested_by!(goto_definition_works_for_named_fields);
+
+        let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
+
+        if let Some(ty) = struct_lit.and_then(|lit| analyzer.type_of(db, lit.into())) {
+            if let Some((hir::AdtDef::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/snapshots/tests__highlighting.snap b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
index 72029e0ed..9d4c04db3 100644
--- a/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
+++ b/crates/ra_ide_api/src/snapshots/tests__highlighting.snap
@@ -1,33 +1,145 @@
 ---
-created: "2019-03-23T16:20:31.394314144Z"
-creator: insta@0.7.1
+created: "2019-05-23T12:10:32.628883358Z"
+creator: insta@0.8.1
 source: crates/ra_ide_api/src/syntax_highlighting.rs
 expression: result
 ---
 Ok(
     [
         HighlightedRange {
-            range: [1; 11),
+            range: [1; 24),
+            tag: "attribute"
+        },
+        HighlightedRange {
+            range: [25; 31),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [32; 35),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [42; 45),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [46; 47),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [49; 52),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [58; 61),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [62; 63),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [65; 68),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [73; 75),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [76; 79),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [80; 81),
+            tag: "type"
+        },
+        HighlightedRange {
+            range: [80; 81),
+            tag: "function"
+        },
+        HighlightedRange {
+            range: [88; 89),
+            tag: "type"
+        },
+        HighlightedRange {
+            range: [96; 110),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [117; 127),
             tag: "comment"
         },
         HighlightedRange {
-            range: [12; 14),
+            range: [128; 130),
             tag: "keyword"
         },
         HighlightedRange {
-            range: [15; 19),
+            range: [131; 135),
             tag: "function"
         },
         HighlightedRange {
-            range: [29; 37),
+            range: [145; 153),
             tag: "macro"
         },
         HighlightedRange {
-            range: [38; 50),
+            range: [154; 166),
             tag: "string"
         },
         HighlightedRange {
-            range: [52; 54),
+            range: [168; 170),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [178; 181),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [182; 185),
+            tag: "keyword"
+        },
+        HighlightedRange {
+            range: [186; 189),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [197; 200),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [192; 195),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [208; 211),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [212; 216),
+            tag: "macro"
+        },
+        HighlightedRange {
+            range: [226; 227),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [232; 233),
+            tag: "literal"
+        },
+        HighlightedRange {
+            range: [242; 248),
+            tag: "keyword.unsafe"
+        },
+        HighlightedRange {
+            range: [251; 254),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [255; 262),
+            tag: "text"
+        },
+        HighlightedRange {
+            range: [263; 264),
             tag: "literal"
         }
     ]
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 2158291dc..89f20260f 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -40,8 +40,41 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
             COMMENT => "comment",
             STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
             ATTR => "attribute",
-            NAME_REF => "text",
+            NAME_REF => {
+                if let Some(name_ref) = node.as_node().and_then(|n| ast::NameRef::cast(n)) {
+                    use crate::name_ref_kind::{classify_name_ref, NameRefKind::*};
+                    use hir::{ModuleDef, ImplItem};
+
+                    // 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",
+                        Some(Macro(_)) => "macro",
+                        Some(FieldAccess(_)) => "field",
+                        Some(AssocItem(ImplItem::Method(_))) => "function",
+                        Some(AssocItem(ImplItem::Const(_))) => "constant",
+                        Some(AssocItem(ImplItem::TypeAlias(_))) => "type",
+                        Some(Def(ModuleDef::Module(_))) => "module",
+                        Some(Def(ModuleDef::Function(_))) => "function",
+                        Some(Def(ModuleDef::Struct(_))) => "type",
+                        Some(Def(ModuleDef::Enum(_))) => "type",
+                        Some(Def(ModuleDef::EnumVariant(_))) => "constant",
+                        Some(Def(ModuleDef::Const(_))) => "constant",
+                        Some(Def(ModuleDef::Static(_))) => "constant",
+                        Some(Def(ModuleDef::Trait(_))) => "type",
+                        Some(Def(ModuleDef::TypeAlias(_))) => "type",
+                        Some(SelfType(_)) => "type",
+                        Some(Pat(_)) => "text",
+                        Some(SelfParam(_)) => "type",
+                        Some(GenericParam(_)) => "type",
+                        None => "text",
+                    }
+                } else {
+                    "text"
+                }
+            }
             NAME => "function",
+            TYPE_ALIAS_DEF | TYPE_ARG | TYPE_PARAM => "type",
             INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
             LIFETIME => "parameter",
             T![unsafe] => "keyword.unsafe",
@@ -87,9 +120,23 @@ mod tests {
     fn test_highlighting() {
         let (analysis, file_id) = single_file(
             r#"
+#[derive(Clone, Debug)]
+struct Foo {
+    pub x: i32,
+    pub y: i32,
+}
+
+fn foo<T>() -> T {
+    unimplemented!();
+}
+
 // comment
 fn main() {}
     println!("Hello, {}!", 92);
+
+    let mut vec = Vec::new();
+    vec.push(Foo { x: 0, y: 1 });
+    unsafe { vec.set_len(0); }
 "#,
         );
         let result = analysis.highlight(file_id);