9 files changed, 729 insertions, 33 deletions

diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
new file mode 100644
index 000000000..1cb712e32
--- /dev/null
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -0,0 +1,337 @@
+//! Entry point for call-hierarchy
+
+use indexmap::IndexMap;
+
+use hir::db::AstDatabase;
+use ra_syntax::{
+    ast::{self, DocCommentsOwner},
+    match_ast, AstNode, TextRange,
+};
+
+use crate::{
+    call_info::FnCallNode,
+    db::RootDatabase,
+    display::{ShortLabel, ToNav},
+    expand::descend_into_macros,
+    goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
+};
+
+#[derive(Debug, Clone)]
+pub struct CallItem {
+    pub target: NavigationTarget,
+    pub ranges: Vec<TextRange>,
+}
+
+impl CallItem {
+    #[cfg(test)]
+    pub(crate) fn assert_match(&self, expected: &str) {
+        let actual = self.debug_render();
+        test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
+    }
+
+    #[cfg(test)]
+    pub(crate) fn debug_render(&self) -> String {
+        format!("{} : {:?}", self.target.debug_render(), self.ranges)
+    }
+}
+
+pub(crate) fn call_hierarchy(
+    db: &RootDatabase,
+    position: FilePosition,
+) -> Option<RangeInfo<Vec<NavigationTarget>>> {
+    goto_definition::goto_definition(db, position)
+}
+
+pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
+    // 1. Find all refs
+    // 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
+    // 3. Add ranges relative to the start of the fndef.
+    let refs = references::find_all_refs(db, position, None)?;
+
+    let mut calls = CallLocations::default();
+
+    for reference in refs.info.references() {
+        let file_id = reference.file_range.file_id;
+        let file = db.parse_or_expand(file_id.into())?;
+        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
+        let token = descend_into_macros(db, file_id, token);
+        let syntax = token.value.parent();
+
+        // This target is the containing function
+        if let Some(nav) = syntax.ancestors().find_map(|node| {
+            match_ast! {
+                match node {
+                    ast::FnDef(it) => {
+                        Some(NavigationTarget::from_named(
+                            db,
+                            token.with_value(&it),
+                            it.doc_comment_text(),
+                            it.short_label(),
+                        ))
+                    },
+                    _ => { None },
+                }
+            }
+        }) {
+            let relative_range = reference.file_range.range;
+            calls.add(&nav, relative_range);
+        }
+    }
+
+    Some(calls.into_items())
+}
+
+pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
+    let file_id = position.file_id;
+    let file = db.parse_or_expand(file_id.into())?;
+    let token = file.token_at_offset(position.offset).next()?;
+    let token = descend_into_macros(db, file_id, token);
+    let syntax = token.value.parent();
+
+    let mut calls = CallLocations::default();
+
+    syntax
+        .descendants()
+        .filter_map(|node| FnCallNode::with_node_exact(&node))
+        .filter_map(|call_node| {
+            let name_ref = call_node.name_ref()?;
+            let name_ref = token.with_value(name_ref.syntax());
+
+            let analyzer = hir::SourceAnalyzer::new(db, name_ref, None);
+
+            if let Some(func_target) = match &call_node {
+                FnCallNode::CallExpr(expr) => {
+                    //FIXME: Type::as_callable is broken
+                    let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+                    match callable_def {
+                        hir::CallableDef::FunctionId(it) => {
+                            let fn_def: hir::Function = it.into();
+                            let nav = fn_def.to_nav(db);
+                            Some(nav)
+                        }
+                        _ => None,
+                    }
+                }
+                FnCallNode::MethodCallExpr(expr) => {
+                    let function = analyzer.resolve_method_call(&expr)?;
+                    Some(function.to_nav(db))
+                }
+                FnCallNode::MacroCallExpr(expr) => {
+                    let macro_def = analyzer.resolve_macro_call(db, name_ref.with_value(&expr))?;
+                    Some(macro_def.to_nav(db))
+                }
+            } {
+                Some((func_target.clone(), name_ref.value.text_range()))
+            } else {
+                None
+            }
+        })
+        .for_each(|(nav, range)| calls.add(&nav, range));
+
+    Some(calls.into_items())
+}
+
+#[derive(Default)]
+struct CallLocations {
+    funcs: IndexMap<NavigationTarget, Vec<TextRange>>,
+}
+
+impl CallLocations {
+    fn add(&mut self, target: &NavigationTarget, range: TextRange) {
+        self.funcs.entry(target.clone()).or_default().push(range);
+    }
+
+    fn into_items(self) -> Vec<CallItem> {
+        self.funcs.into_iter().map(|(target, ranges)| CallItem { target, ranges }).collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use ra_db::FilePosition;
+
+    use crate::mock_analysis::analysis_and_position;
+
+    fn check_hierarchy(
+        fixture: &str,
+        expected: &str,
+        expected_incoming: &[&str],
+        expected_outgoing: &[&str],
+    ) {
+        let (analysis, pos) = analysis_and_position(fixture);
+
+        let mut navs = analysis.call_hierarchy(pos).unwrap().unwrap().info;
+        assert_eq!(navs.len(), 1);
+        let nav = navs.pop().unwrap();
+        nav.assert_match(expected);
+
+        let item_pos = FilePosition { file_id: nav.file_id(), offset: nav.range().start() };
+        let incoming_calls = analysis.incoming_calls(item_pos).unwrap().unwrap();
+        assert_eq!(incoming_calls.len(), expected_incoming.len());
+
+        for call in 0..incoming_calls.len() {
+            incoming_calls[call].assert_match(expected_incoming[call]);
+        }
+
+        let outgoing_calls = analysis.outgoing_calls(item_pos).unwrap().unwrap();
+        assert_eq!(outgoing_calls.len(), expected_outgoing.len());
+
+        for call in 0..outgoing_calls.len() {
+            outgoing_calls[call].assert_match(expected_outgoing[call]);
+        }
+    }
+
+    #[test]
+    fn test_call_hierarchy_on_ref() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn callee() {}
+            fn caller() {
+                call<|>ee();
+            }
+            "#,
+            "callee FN_DEF FileId(1) [0; 14) [3; 9)",
+            &["caller FN_DEF FileId(1) [15; 44) [18; 24) : [[33; 39)]"],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_on_def() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn call<|>ee() {}
+            fn caller() {
+                callee();
+            }
+            "#,
+            "callee FN_DEF FileId(1) [0; 14) [3; 9)",
+            &["caller FN_DEF FileId(1) [15; 44) [18; 24) : [[33; 39)]"],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_in_same_fn() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn callee() {}
+            fn caller() {
+                call<|>ee();
+                callee();
+            }
+            "#,
+            "callee FN_DEF FileId(1) [0; 14) [3; 9)",
+            &["caller FN_DEF FileId(1) [15; 58) [18; 24) : [[33; 39), [47; 53)]"],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_in_different_fn() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn callee() {}
+            fn caller1() {
+                call<|>ee();
+            }
+
+            fn caller2() {
+                callee();
+            }
+            "#,
+            "callee FN_DEF FileId(1) [0; 14) [3; 9)",
+            &[
+                "caller1 FN_DEF FileId(1) [15; 45) [18; 25) : [[34; 40)]",
+                "caller2 FN_DEF FileId(1) [46; 76) [49; 56) : [[65; 71)]",
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_in_different_files() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            mod foo;
+            use foo::callee;
+
+            fn caller() {
+                call<|>ee();
+            }
+
+            //- /foo/mod.rs
+            pub fn callee() {}
+            "#,
+            "callee FN_DEF FileId(2) [0; 18) [7; 13)",
+            &["caller FN_DEF FileId(1) [26; 55) [29; 35) : [[44; 50)]"],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_outgoing() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn callee() {}
+            fn call<|>er() {
+                callee();
+                callee();
+            }
+            "#,
+            "caller FN_DEF FileId(1) [15; 58) [18; 24)",
+            &[],
+            &["callee FN_DEF FileId(1) [0; 14) [3; 9) : [[33; 39), [47; 53)]"],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_outgoing_in_different_files() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            mod foo;
+            use foo::callee;
+
+            fn call<|>er() {
+                callee();
+            }
+
+            //- /foo/mod.rs
+            pub fn callee() {}
+            "#,
+            "caller FN_DEF FileId(1) [26; 55) [29; 35)",
+            &[],
+            &["callee FN_DEF FileId(2) [0; 18) [7; 13) : [[44; 50)]"],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_incoming_outgoing() {
+        check_hierarchy(
+            r#"
+            //- /lib.rs
+            fn caller1() {
+                call<|>er2();
+            }
+
+            fn caller2() {
+                caller3();
+            }
+
+            fn caller3() {
+
+            }
+            "#,
+            "caller2 FN_DEF FileId(1) [32; 63) [35; 42)",
+            &["caller1 FN_DEF FileId(1) [0; 31) [3; 10) : [[19; 26)]"],
+            &["caller3 FN_DEF FileId(1) [64; 80) [67; 74) : [[51; 58)]"],
+        );
+    }
+}
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index 2c2b6fa48..a7023529b 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -88,7 +88,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
 }
 
 #[derive(Debug)]
-enum FnCallNode {
+pub(crate) enum FnCallNode {
     CallExpr(ast::CallExpr),
     MethodCallExpr(ast::MethodCallExpr),
     MacroCallExpr(ast::MacroCall),
@@ -108,7 +108,18 @@ impl FnCallNode {
         })
     }
 
-    fn name_ref(&self) -> Option<ast::NameRef> {
+    pub(crate) fn with_node_exact(node: &SyntaxNode) -> Option<FnCallNode> {
+        match_ast! {
+            match node {
+                ast::CallExpr(it) => { Some(FnCallNode::CallExpr(it)) },
+                ast::MethodCallExpr(it) => { Some(FnCallNode::MethodCallExpr(it)) },
+                ast::MacroCall(it) => { Some(FnCallNode::MacroCallExpr(it)) },
+                _ => { None },
+            }
+        }
+    }
+
+    pub(crate) fn name_ref(&self) -> Option<ast::NameRef> {
         match self {
             FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
                 ast::Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide/src/change.rs
index 8b197d642..b0aa2c8e0 100644
--- a/crates/ra_ide/src/change.rs
+++ b/crates/ra_ide/src/change.rs
@@ -176,7 +176,8 @@ impl RootDatabase {
         if !change.new_roots.is_empty() {
             let mut local_roots = Vec::clone(&self.local_roots());
             for (root_id, is_local) in change.new_roots {
-                let root = if is_local { SourceRoot::new() } else { SourceRoot::new_library() };
+                let root =
+                    if is_local { SourceRoot::new_local() } else { SourceRoot::new_library() };
                 let durability = durability(&root);
                 self.set_source_root_with_durability(root_id, Arc::new(root), durability);
                 if is_local {
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index b9ae67828..f2e45fa31 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -19,7 +19,7 @@ use super::short_label::ShortLabel;
 ///
 /// Typically, a `NavigationTarget` corresponds to some element in the source
 /// code, like a function or a struct, but this is not strictly required.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NavigationTarget {
     file_id: FileId,
     name: SmolStr,
diff --git a/crates/ra_ide/src/feature_flags.rs b/crates/ra_ide/src/feature_flags.rs
index de4ae513d..85617640d 100644
--- a/crates/ra_ide/src/feature_flags.rs
+++ b/crates/ra_ide/src/feature_flags.rs
@@ -56,6 +56,7 @@ impl Default for FeatureFlags {
             ("completion.insertion.add-call-parenthesis", true),
             ("completion.enable-postfix", true),
             ("notifications.workspace-loaded", true),
+            ("notifications.cargo-toml-not-found", true),
         ])
     }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 35e39f965..5548681f1 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -128,7 +128,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, name_kind: NameKind) -> Option<S
             hir::ModuleDef::TypeAlias(it) => from_def_source(db, it),
             hir::ModuleDef::BuiltinType(it) => Some(it.to_string()),
         },
-        Local(_) => None,
+        Local(it) => Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string())),
         TypeParam(_) | SelfType(_) => {
             // FIXME: Hover for generic param
             None
@@ -174,6 +174,8 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
         .value
         .ancestors()
         .find(|n| ast::Expr::cast(n.clone()).is_some() || ast::Pat::cast(n.clone()).is_some())?;
+
+    // The following logic will not work if token is coming from a macro
     let frange = FileRange { file_id: position.file_id, range: node.text_range() };
     res.extend(type_of(db, frange).map(rust_code_markup));
     if res.is_empty() {
@@ -729,4 +731,20 @@ fn func(foo: i32) { if true { <|>foo; }; }
             &["fn foo()"],
         );
     }
+
+    #[test]
+    fn test_hover_through_expr_in_macro() {
+        check_hover_result(
+            "
+            //- /lib.rs
+            macro_rules! id {
+                ($($tt:tt)*) => { $($tt)* }
+            }
+            fn foo(bar:u32) {
+                let a = id!(ba<|>r);
+            }            
+            ",
+            &["u32"],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 779a81b2c..4d8deb21c 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -24,6 +24,7 @@ mod goto_definition;
 mod goto_type_definition;
 mod extend_selection;
 mod hover;
+mod call_hierarchy;
 mod call_info;
 mod syntax_highlighting;
 mod parent_module;
@@ -62,6 +63,7 @@ use crate::{db::LineIndexDatabase, display::ToNav, symbol_index::FileSymbol};
 
 pub use crate::{
     assists::{Assist, AssistId},
+    call_hierarchy::CallItem,
     change::{AnalysisChange, LibraryData},
     completion::{CompletionItem, CompletionItemKind, InsertTextFormat},
     diagnostics::Severity,
@@ -73,7 +75,9 @@ pub use crate::{
     inlay_hints::{InlayHint, InlayKind},
     line_index::{LineCol, LineIndex},
     line_index_utils::translate_offset_with_edit,
-    references::{ReferenceSearchResult, SearchScope},
+    references::{
+        Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, SearchScope,
+    },
     runnables::{Runnable, RunnableKind},
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
     syntax_highlighting::HighlightedRange,
@@ -412,6 +416,24 @@ impl Analysis {
         self.with_db(|db| call_info::call_info(db, position))
     }
 
+    /// Computes call hierarchy candidates for the given file position.
+    pub fn call_hierarchy(
+        &self,
+        position: FilePosition,
+    ) -> Cancelable<Option<RangeInfo<Vec<NavigationTarget>>>> {
+        self.with_db(|db| call_hierarchy::call_hierarchy(db, position))
+    }
+
+    /// Computes incoming calls for the given file position.
+    pub fn incoming_calls(&self, position: FilePosition) -> Cancelable<Option<Vec<CallItem>>> {
+        self.with_db(|db| call_hierarchy::incoming_calls(db, position))
+    }
+
+    /// Computes incoming calls for the given file position.
+    pub fn outgoing_calls(&self, position: FilePosition) -> Cancelable<Option<Vec<CallItem>>> {
+        self.with_db(|db| call_hierarchy::outgoing_calls(db, position))
+    }
+
     /// Returns a `mod name;` declaration which created the current module.
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
         self.with_db(|db| parent_module::parent_module(db, position))
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index e3ecde50d..4e52e0e7b 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -18,7 +18,11 @@ use hir::InFile;
 use once_cell::unsync::Lazy;
 use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_prof::profile;
-use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode, TextUnit};
+use ra_syntax::{
+    algo::find_node_at_offset,
+    ast::{self, NameOwner},
+    match_ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, TextUnit, TokenAtOffset,
+};
 
 use crate::{
     db::RootDatabase, display::ToNav, FilePosition, FileRange, NavigationTarget, RangeInfo,
@@ -34,16 +38,46 @@ pub use self::search_scope::SearchScope;
 
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
-    declaration: NavigationTarget,
-    references: Vec<FileRange>,
+    declaration: Declaration,
+    references: Vec<Reference>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Declaration {
+    pub nav: NavigationTarget,
+    pub kind: ReferenceKind,
+    pub access: Option<ReferenceAccess>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Reference {
+    pub file_range: FileRange,
+    pub kind: ReferenceKind,
+    pub access: Option<ReferenceAccess>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ReferenceKind {
+    StructLiteral,
+    Other,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum ReferenceAccess {
+    Read,
+    Write,
 }
 
 impl ReferenceSearchResult {
-    pub fn declaration(&self) -> &NavigationTarget {
+    pub fn declaration(&self) -> &Declaration {
         &self.declaration
     }
 
-    pub fn references(&self) -> &[FileRange] {
+    pub fn decl_target(&self) -> &NavigationTarget {
+        &self.declaration.nav
+    }
+
+    pub fn references(&self) -> &[Reference] {
         &self.references
     }
 
@@ -56,14 +90,21 @@ impl ReferenceSearchResult {
 }
 
 // allow turning ReferenceSearchResult into an iterator
-// over FileRanges
+// over References
 impl IntoIterator for ReferenceSearchResult {
-    type Item = FileRange;
-    type IntoIter = std::vec::IntoIter<FileRange>;
+    type Item = Reference;
+    type IntoIter = std::vec::IntoIter<Reference>;
 
     fn into_iter(mut self) -> Self::IntoIter {
         let mut v = Vec::with_capacity(self.len());
-        v.push(FileRange { file_id: self.declaration.file_id(), range: self.declaration.range() });
+        v.push(Reference {
+            file_range: FileRange {
+                file_id: self.declaration.nav.file_id(),
+                range: self.declaration.nav.range(),
+            },
+            kind: self.declaration.kind,
+            access: self.declaration.access,
+        });
         v.append(&mut self.references);
         v.into_iter()
     }
@@ -71,11 +112,24 @@ impl IntoIterator for ReferenceSearchResult {
 
 pub(crate) fn find_all_refs(
     db: &RootDatabase,
-    position: FilePosition,
+    mut position: FilePosition,
     search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
+
+    let token = syntax.token_at_offset(position.offset);
+    let mut search_kind = ReferenceKind::Other;
+
+    if let TokenAtOffset::Between(ref left, ref right) = token {
+        if (right.kind() == SyntaxKind::L_CURLY || right.kind() == SyntaxKind::L_PAREN)
+            && left.kind() != SyntaxKind::IDENT
+        {
+            position = FilePosition { offset: left.text_range().start(), ..position };
+            search_kind = ReferenceKind::StructLiteral;
+        }
+    }
+
     let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
 
     let declaration = match def.kind {
@@ -96,7 +150,18 @@ pub(crate) fn find_all_refs(
         }
     };
 
-    let references = process_definition(db, def, name, search_scope);
+    let decl_range = declaration.range();
+
+    let declaration = Declaration {
+        nav: declaration,
+        kind: ReferenceKind::Other,
+        access: decl_access(&def.kind, &name, &syntax, decl_range),
+    };
+
+    let references = process_definition(db, def, name, search_scope)
+        .into_iter()
+        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
+        .collect();
 
     Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
 }
@@ -122,7 +187,7 @@ fn process_definition(
     def: NameDefinition,
     name: String,
     scope: SearchScope,
-) -> Vec<FileRange> {
+) -> Vec<Reference> {
     let _p = profile("process_definition");
 
     let pat = name.as_str();
@@ -146,7 +211,26 @@ fn process_definition(
                 }
                 if let Some(d) = classify_name_ref(db, InFile::new(file_id.into(), &name_ref)) {
                     if d == def {
-                        refs.push(FileRange { file_id, range });
+                        let kind = if name_ref
+                            .syntax()
+                            .ancestors()
+                            .find_map(ast::RecordLit::cast)
+                            .and_then(|l| l.path())
+                            .and_then(|p| p.segment())
+                            .and_then(|p| p.name_ref())
+                            .map(|n| n == name_ref)
+                            .unwrap_or(false)
+                        {
+                            ReferenceKind::StructLiteral
+                        } else {
+                            ReferenceKind::Other
+                        };
+
+                        refs.push(Reference {
+                            file_range: FileRange { file_id, range },
+                            kind,
+                            access: reference_access(&d.kind, &name_ref),
+                        });
                     }
                 }
             }
@@ -155,14 +239,94 @@ fn process_definition(
     refs
 }
 
+fn decl_access(
+    kind: &NameKind,
+    name: &str,
+    syntax: &SyntaxNode,
+    range: TextRange,
+) -> Option<ReferenceAccess> {
+    match kind {
+        NameKind::Local(_) | NameKind::Field(_) => {}
+        _ => return None,
+    };
+
+    let stmt = find_node_at_offset::<ast::LetStmt>(syntax, range.start())?;
+    if let Some(_) = stmt.initializer() {
+        let pat = stmt.pat()?;
+        match pat {
+            ast::Pat::BindPat(it) => {
+                if it.name()?.text().as_str() == name {
+                    return Some(ReferenceAccess::Write);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    None
+}
+
+fn reference_access(kind: &NameKind, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
+    // Only Locals and Fields have accesses for now.
+    match kind {
+        NameKind::Local(_) | NameKind::Field(_) => {}
+        _ => return None,
+    };
+
+    let mode = name_ref.syntax().ancestors().find_map(|node| {
+        match_ast! {
+            match (node) {
+                ast::BinExpr(expr) => {
+                    if expr.op_kind()?.is_assignment() {
+                        // If the variable or field ends on the LHS's end then it's a Write (covers fields and locals).
+                        // FIXME: This is not terribly accurate.
+                        if let Some(lhs) = expr.lhs() {
+                            if lhs.syntax().text_range().end() == name_ref.syntax().text_range().end() {
+                                return Some(ReferenceAccess::Write);
+                            }
+                        }
+                    }
+                    return Some(ReferenceAccess::Read);
+                },
+                _ => {None}
+            }
+        }
+    });
+
+    // Default Locals and Fields to read
+    mode.or(Some(ReferenceAccess::Read))
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
         mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
-        ReferenceSearchResult, SearchScope,
+        Declaration, Reference, ReferenceSearchResult, SearchScope,
     };
 
     #[test]
+    fn test_struct_literal() {
+        let code = r#"
+    struct Foo <|>{
+        a: i32,
+    }
+    impl Foo {
+        fn f() -> i32 { 42 }
+    }    
+    fn main() {
+        let f: Foo;
+        f = Foo {a: Foo::f()};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15) Other",
+            &["FileId(1) [142; 145) StructLiteral"],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_for_local() {
         let code = r#"
     fn main() {
@@ -178,7 +342,16 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 5);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [33; 34) Other Write",
+            &[
+                "FileId(1) [67; 68) Other Write",
+                "FileId(1) [71; 72) Other Read",
+                "FileId(1) [101; 102) Other Write",
+                "FileId(1) [127; 128) Other Write",
+            ],
+        );
     }
 
     #[test]
@@ -189,7 +362,11 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13) Other",
+            &["FileId(1) [38; 39) Other Read"],
+        );
     }
 
     #[test]
@@ -200,7 +377,11 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13) Other",
+            &["FileId(1) [38; 39) Other Read"],
+        );
     }
 
     #[test]
@@ -217,7 +398,11 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "spam RECORD_FIELD_DEF FileId(1) [66; 79) [70; 74) Other",
+            &["FileId(1) [152; 156) Other Read"],
+        );
     }
 
     #[test]
@@ -231,7 +416,7 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
+        check_result(refs, "f FN_DEF FileId(1) [88; 104) [91; 92) Other", &[]);
     }
 
     #[test]
@@ -246,7 +431,7 @@ mod tests {
         "#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 1);
+        check_result(refs, "B ENUM_VARIANT FileId(1) [83; 84) [83; 84) Other", &[]);
     }
 
     #[test]
@@ -285,7 +470,11 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(2) [16; 50) [27; 30) Other",
+            &["FileId(1) [52; 55) StructLiteral", "FileId(3) [77; 80) StructLiteral"],
+        );
     }
 
     // `mod foo;` is not in the results because `foo` is an `ast::Name`.
@@ -311,7 +500,11 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "foo SOURCE_FILE FileId(2) [0; 35) Other",
+            &["FileId(1) [13; 16) Other"],
+        );
     }
 
     #[test]
@@ -336,7 +529,11 @@ mod tests {
 
         let (analysis, pos) = analysis_and_position(code);
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(3) [0; 41) [18; 21) Other",
+            &["FileId(2) [20; 23) Other", "FileId(2) [46; 49) StructLiteral"],
+        );
     }
 
     #[test]
@@ -360,11 +557,19 @@ mod tests {
         let analysis = mock.analysis();
 
         let refs = analysis.find_all_refs(pos, None).unwrap().unwrap();
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
+            &["FileId(2) [16; 20) Other", "FileId(3) [16; 20) Other"],
+        );
 
         let refs =
             analysis.find_all_refs(pos, Some(SearchScope::single_file(bar))).unwrap().unwrap();
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
+            &["FileId(3) [16; 20) Other"],
+        );
     }
 
     #[test]
@@ -379,11 +584,106 @@ mod tests {
         }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 3);
+        check_result(
+            refs,
+            "m1 MACRO_CALL FileId(1) [9; 63) [46; 48) Other",
+            &["FileId(1) [96; 98) Other", "FileId(1) [114; 116) Other"],
+        );
+    }
+
+    #[test]
+    fn test_basic_highlight_read_write() {
+        let code = r#"
+        fn foo() {
+            let i<|> = 0;
+            i = i + 1;
+        }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [36; 37) Other Write",
+            &["FileId(1) [55; 56) Other Write", "FileId(1) [59; 60) Other Read"],
+        );
+    }
+
+    #[test]
+    fn test_basic_highlight_field_read_write() {
+        let code = r#"
+        struct S {
+            f: u32,
+        }
+
+        fn foo() {
+            let mut s = S{f: 0};
+            s.f<|> = 0;
+        }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "f RECORD_FIELD_DEF FileId(1) [32; 38) [32; 33) Other",
+            &["FileId(1) [96; 97) Other Read", "FileId(1) [117; 118) Other Write"],
+        );
+    }
+
+    #[test]
+    fn test_basic_highlight_decl_no_write() {
+        let code = r#"
+        fn foo() {
+            let i<|>;
+            i = 1;
+        }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [36; 37) Other",
+            &["FileId(1) [51; 52) Other Write"],
+        );
     }
 
     fn get_all_refs(text: &str) -> ReferenceSearchResult {
         let (analysis, position) = single_file_with_position(text);
         analysis.find_all_refs(position, None).unwrap().unwrap()
     }
+
+    fn check_result(res: ReferenceSearchResult, expected_decl: &str, expected_refs: &[&str]) {
+        res.declaration().assert_match(expected_decl);
+        assert_eq!(res.references.len(), expected_refs.len());
+        res.references().iter().enumerate().for_each(|(i, r)| r.assert_match(expected_refs[i]));
+    }
+
+    impl Declaration {
+        fn debug_render(&self) -> String {
+            let mut s = format!("{} {:?}", self.nav.debug_render(), self.kind);
+            if let Some(access) = self.access {
+                s.push_str(&format!(" {:?}", access));
+            }
+            s
+        }
+
+        fn assert_match(&self, expected: &str) {
+            let actual = self.debug_render();
+            test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
+        }
+    }
+
+    impl Reference {
+        fn debug_render(&self) -> String {
+            let mut s = format!(
+                "{:?} {:?} {:?}",
+                self.file_range.file_id, self.file_range.range, self.kind
+            );
+            if let Some(access) = self.access {
+                s.push_str(&format!(" {:?}", access));
+            }
+            s
+        }
+
+        fn assert_match(&self, expected: &str) {
+            let actual = self.debug_render();
+            test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
+        }
+    }
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index b804d5f6d..e02985dcd 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -110,7 +110,13 @@ fn rename_reference(
 
     let edit = refs
         .into_iter()
-        .map(|range| source_edit_from_file_id_range(range.file_id, range.range, new_name))
+        .map(|reference| {
+            source_edit_from_file_id_range(
+                reference.file_range.file_id,
+                reference.file_range.range,
+                new_name,
+            )
+        })
         .collect::<Vec<_>>();
 
     if edit.is_empty() {