31 files changed, 1221 insertions, 94 deletions

diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index e8f335e33..30b598e9a 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -49,7 +49,7 @@ fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
     let file_id = FileId(0);
     let rel_path: RelativePathBuf = "/main.rs".into();
 
-    let mut source_root = SourceRoot::default();
+    let mut source_root = SourceRoot::new_local();
     source_root.insert_file(rel_path.clone(), file_id);
 
     let mut crate_graph = CrateGraph::default();
@@ -77,7 +77,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
     let mut crate_deps = Vec::new();
     let mut default_crate_root: Option<FileId> = None;
 
-    let mut source_root = SourceRoot::default();
+    let mut source_root = SourceRoot::new_local();
     let mut source_root_id = WORKSPACE;
     let mut source_root_prefix: RelativePathBuf = "/".into();
     let mut file_id = FileId(0);
@@ -87,7 +87,7 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
     for entry in fixture.iter() {
         let meta = match parse_meta(&entry.meta) {
             ParsedMeta::Root { path } => {
-                let source_root = std::mem::replace(&mut source_root, SourceRoot::default());
+                let source_root = std::mem::replace(&mut source_root, SourceRoot::new_local());
                 db.set_source_root(source_root_id, Arc::new(source_root));
                 source_root_id.0 += 1;
                 source_root_prefix = path;
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 2a7ed20d1..07269237a 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -33,7 +33,7 @@ pub struct FileId(pub u32);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct SourceRootId(pub u32);
 
-#[derive(Default, Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SourceRoot {
     /// Sysroot or crates.io library.
     ///
@@ -44,11 +44,11 @@ pub struct SourceRoot {
 }
 
 impl SourceRoot {
-    pub fn new() -> SourceRoot {
-        Default::default()
+    pub fn new_local() -> SourceRoot {
+        SourceRoot { is_library: false, files: Default::default() }
     }
     pub fn new_library() -> SourceRoot {
-        SourceRoot { is_library: true, ..SourceRoot::new() }
+        SourceRoot { is_library: true, files: Default::default() }
     }
     pub fn insert_file(&mut self, path: RelativePathBuf, file_id: FileId) {
         self.files.insert(path, file_id);
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 2c119269c..e9e275670 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -62,8 +62,13 @@ register_builtin! {
 }
 
 fn to_line_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
-    // FIXME: Use expansion info
     let file_id = file.original_file(db);
+
+    // FIXME: if the file is coming from macro, we return a dummy value for now.
+    if file.call_node(db).map(|it| it.file_id != file_id.into()).unwrap_or(true) {
+        return 0;
+    }
+
     let text = db.file_text(file_id);
     let mut line_num = 1;
 
@@ -150,8 +155,11 @@ fn option_env_expand(
 }
 
 fn to_col_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
-    // FIXME: Use expansion info
     let file_id = file.original_file(db);
+    // FIXME: if the file is coming from macro, we return a dummy value for now.
+    if file.call_node(db).map(|it| it.file_id != file_id.into()).unwrap_or(true) {
+        return 0;
+    }
     let text = db.file_text(file_id);
 
     let pos = pos.to_usize();
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 2e12e126f..af5b22d1c 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -178,6 +178,7 @@ fn to_fragment_kind(db: &dyn AstDatabase, macro_call_id: MacroCallId) -> Fragmen
 
     match parent.kind() {
         MACRO_ITEMS | SOURCE_FILE => FragmentKind::Items,
+        ITEM_LIST => FragmentKind::Items,
         LET_STMT => {
             // FIXME: Handle Pattern
             FragmentKind::Expr
@@ -187,7 +188,28 @@ fn to_fragment_kind(db: &dyn AstDatabase, macro_call_id: MacroCallId) -> Fragmen
         ARG_LIST => FragmentKind::Expr,
         TRY_EXPR => FragmentKind::Expr,
         TUPLE_EXPR => FragmentKind::Expr,
-        ITEM_LIST => FragmentKind::Items,
+        PAREN_EXPR => FragmentKind::Expr,
+
+        FOR_EXPR => FragmentKind::Expr,
+        PATH_EXPR => FragmentKind::Expr,
+        LAMBDA_EXPR => FragmentKind::Expr,
+        CONDITION => FragmentKind::Expr,
+        BREAK_EXPR => FragmentKind::Expr,
+        RETURN_EXPR => FragmentKind::Expr,
+        BLOCK_EXPR => FragmentKind::Expr,
+        MATCH_EXPR => FragmentKind::Expr,
+        MATCH_ARM => FragmentKind::Expr,
+        MATCH_GUARD => FragmentKind::Expr,
+        RECORD_FIELD => FragmentKind::Expr,
+        CALL_EXPR => FragmentKind::Expr,
+        INDEX_EXPR => FragmentKind::Expr,
+        METHOD_CALL_EXPR => FragmentKind::Expr,
+        AWAIT_EXPR => FragmentKind::Expr,
+        CAST_EXPR => FragmentKind::Expr,
+        REF_EXPR => FragmentKind::Expr,
+        PREFIX_EXPR => FragmentKind::Expr,
+        RANGE_EXPR => FragmentKind::Expr,
+        BIN_EXPR => FragmentKind::Expr,
         _ => {
             // Unknown , Just guess it is `Items`
             FragmentKind::Items
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 69c695cc8..9d09d93a7 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -136,6 +136,87 @@ fn main() {
 }
 
 #[test]
+fn expr_macro_expanded_in_various_places() {
+    assert_snapshot!(
+        infer(r#"
+macro_rules! spam {
+    () => (1isize);
+}
+
+fn spam() {
+    spam!();
+    (spam!());
+    spam!().spam(spam!());
+    for _ in spam!() {}
+    || spam!();
+    while spam!() {}
+    break spam!();
+    return spam!();
+    match spam!() {
+        _ if spam!() => spam!(),
+    }
+    spam!()(spam!());
+    Spam { spam: spam!() };
+    spam!()[spam!()];
+    await spam!();
+    spam!() as usize;
+    &spam!();
+    -spam!();
+    spam!()..spam!();
+    spam!() + spam!();
+}
+"#),
+        @r###"
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    ![0; 6) '1isize': isize
+    [54; 457) '{     ...!(); }': !
+    [88; 109) 'spam!(...am!())': {unknown}
+    [115; 134) 'for _ ...!() {}': ()
+    [119; 120) '_': {unknown}
+    [132; 134) '{}': ()
+    [139; 149) '|| spam!()': || -> isize
+    [155; 171) 'while ...!() {}': ()
+    [169; 171) '{}': ()
+    [176; 189) 'break spam!()': !
+    [195; 209) 'return spam!()': !
+    [215; 269) 'match ...     }': isize
+    [239; 240) '_': isize
+    [274; 290) 'spam!(...am!())': {unknown}
+    [296; 318) 'Spam {...m!() }': {unknown}
+    [324; 340) 'spam!(...am!()]': {unknown}
+    [365; 381) 'spam!(... usize': usize
+    [387; 395) '&spam!()': &isize
+    [401; 409) '-spam!()': isize
+    [415; 431) 'spam!(...pam!()': {unknown}
+    [437; 454) 'spam!(...pam!()': isize
+    "###
+    );
+}
+
+#[test]
 fn infer_type_value_macro_having_same_name() {
     assert_snapshot!(
         infer(r#"
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 13c5f62e4..6c5d39549 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -310,6 +310,23 @@ fn test<R>(query_response: Canonical<QueryResponse<R>>) {
 }
 
 #[test]
+fn infer_paren_macro_call() {
+    assert_snapshot!(
+        infer(r#"
+macro_rules! bar { () => {0u32} }
+fn test() {
+    let a = (bar!());
+}
+"#),
+        @r###"
+    ![0; 4) '0u32': u32
+    [45; 70) '{     ...()); }': ()
+    [55; 56) 'a': u32
+        "###
+    );
+}
+
+#[test]
 fn bug_1030() {
     assert_snapshot!(infer(r#"
 struct HashSet<T, H>;
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index e3439ae31..2c9f9dce0 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -13,6 +13,7 @@ wasm = []
 [dependencies]
 either = "1.5"
 format-buf = "1.0.0"
+indexmap = "1.3.0"
 itertools = "0.8.0"
 join_to_string = "0.1.3"
 log = "0.4.5"
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() {
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index db502c200..c4711076c 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -1,8 +1,8 @@
 //! Advertizes the capabilities of the LSP Server.
 
 use lsp_types::{
-    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
-    DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
+    CallHierarchyServerCapability, CodeActionProviderCapability, CodeLensOptions,
+    CompletionOptions, DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability,
     ImplementationProviderCapability, RenameOptions, RenameProviderCapability, SaveOptions,
     SelectionRangeProviderCapability, ServerCapabilities, SignatureHelpOptions,
     TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
@@ -56,7 +56,7 @@ pub fn server_capabilities() -> ServerCapabilities {
         color_provider: None,
         execute_command_provider: None,
         workspace: None,
-        call_hierarchy_provider: None,
+        call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
         experimental: Default::default(),
     }
 }
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index e93d4ea33..562699b7c 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -9,7 +9,7 @@ use lsp_types::{
 use ra_ide::{
     translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
     FileRange, FileSystemEdit, Fold, FoldKind, InsertTextFormat, LineCol, LineIndex,
-    NavigationTarget, RangeInfo, Severity, SourceChange, SourceFileEdit,
+    NavigationTarget, RangeInfo, ReferenceAccess, Severity, SourceChange, SourceFileEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
@@ -53,6 +53,18 @@ impl Conv for SyntaxKind {
     }
 }
 
+impl Conv for ReferenceAccess {
+    type Output = ::lsp_types::DocumentHighlightKind;
+
+    fn conv(self) -> Self::Output {
+        use lsp_types::DocumentHighlightKind;
+        match self {
+            ReferenceAccess::Read => DocumentHighlightKind::Read,
+            ReferenceAccess::Write => DocumentHighlightKind::Write,
+        }
+    }
+}
+
 impl Conv for CompletionItemKind {
     type Output = ::lsp_types::CompletionItemKind;
 
@@ -490,6 +502,24 @@ impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<Vec<NavigationTarget>>)
     }
 }
 
+pub fn to_call_hierarchy_item(
+    file_id: FileId,
+    range: TextRange,
+    world: &WorldSnapshot,
+    line_index: &LineIndex,
+    nav: NavigationTarget,
+) -> Result<lsp_types::CallHierarchyItem> {
+    Ok(lsp_types::CallHierarchyItem {
+        name: nav.name().to_string(),
+        kind: nav.kind().conv(),
+        tags: None,
+        detail: nav.description().map(|it| it.to_string()),
+        uri: file_id.try_conv_with(&world)?,
+        range: nav.range().conv_with(&line_index),
+        selection_range: range.conv_with(&line_index),
+    })
+}
+
 pub fn to_location(
     file_id: FileId,
     range: TextRange,
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 4336583fe..7a49cad86 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -62,6 +62,22 @@ pub fn main_loop(
 
     let mut loop_state = LoopState::default();
     let mut world_state = {
+        let feature_flags = {
+            let mut ff = FeatureFlags::default();
+            for (flag, value) in config.feature_flags {
+                if ff.set(flag.as_str(), value).is_err() {
+                    log::error!("unknown feature flag: {:?}", flag);
+                    show_message(
+                        req::MessageType::Error,
+                        format!("unknown feature flag: {:?}", flag),
+                        &connection.sender,
+                    );
+                }
+            }
+            ff
+        };
+        log::info!("feature_flags: {:#?}", feature_flags);
+
         // FIXME: support dynamic workspace loading.
         let workspaces = {
             let mut loaded_workspaces = Vec::new();
@@ -75,7 +91,12 @@ pub fn main_loop(
                     Ok(workspace) => loaded_workspaces.push(workspace),
                     Err(e) => {
                         log::error!("loading workspace failed: {}", e);
-
+                        if let Some(ra_project_model::CargoTomlNotFoundError(_)) = e.downcast_ref()
+                        {
+                            if !feature_flags.get("notifications.cargo-toml-not-found") {
+                                continue;
+                            }
+                        }
                         show_message(
                             req::MessageType::Error,
                             format!("rust-analyzer failed to load workspace: {}", e),
@@ -136,22 +157,6 @@ pub fn main_loop(
             }
         };
 
-        let feature_flags = {
-            let mut ff = FeatureFlags::default();
-            for (flag, value) in config.feature_flags {
-                if ff.set(flag.as_str(), value).is_err() {
-                    log::error!("unknown feature flag: {:?}", flag);
-                    show_message(
-                        req::MessageType::Error,
-                        format!("unknown feature flag: {:?}", flag),
-                        &connection.sender,
-                    );
-                }
-            }
-            ff
-        };
-        log::info!("feature_flags: {:#?}", feature_flags);
-
         WorldState::new(
             ws_roots,
             workspaces,
@@ -499,6 +504,9 @@ fn on_request(
         .on::<req::Formatting>(handlers::handle_formatting)?
         .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)?
         .on::<req::InlayHints>(handlers::handle_inlay_hints)?
+        .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)?
+        .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)?
+        .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)?
         .finish();
     Ok(())
 }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 331beab13..a592f0a12 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -5,13 +5,16 @@ use std::{fmt::Write as _, io::Write as _};
 
 use lsp_server::ErrorCode;
 use lsp_types::{
+    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
+    CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
     CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
     DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeParams,
     Hover, HoverContents, Location, MarkupContent, MarkupKind, Position, PrepareRenameResponse,
     Range, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
-    AssistId, FileId, FilePosition, FileRange, Query, Runnable, RunnableKind, SearchScope,
+    AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
+    SearchScope,
 };
 use ra_prof::profile;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextUnit};
@@ -21,7 +24,10 @@ use serde_json::to_value;
 
 use crate::{
     cargo_target_spec::{runnable_args, CargoTargetSpec},
-    conv::{to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith, TryConvWithToVec},
+    conv::{
+        to_call_hierarchy_item, to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith,
+        TryConvWithToVec,
+    },
     req::{self, Decoration, InlayHint, InlayHintsParams, InlayKind},
     world::WorldSnapshot,
     LspError, Result,
@@ -530,18 +536,32 @@ pub fn handle_references(
 
     let locations = if params.context.include_declaration {
         refs.into_iter()
-            .filter_map(|r| {
-                let line_index = world.analysis().file_line_index(r.file_id).ok()?;
-                to_location(r.file_id, r.range, &world, &line_index).ok()
+            .filter_map(|reference| {
+                let line_index =
+                    world.analysis().file_line_index(reference.file_range.file_id).ok()?;
+                to_location(
+                    reference.file_range.file_id,
+                    reference.file_range.range,
+                    &world,
+                    &line_index,
+                )
+                .ok()
             })
             .collect()
     } else {
         // Only iterate over the references if include_declaration was false
         refs.references()
             .iter()
-            .filter_map(|r| {
-                let line_index = world.analysis().file_line_index(r.file_id).ok()?;
-                to_location(r.file_id, r.range, &world, &line_index).ok()
+            .filter_map(|reference| {
+                let line_index =
+                    world.analysis().file_line_index(reference.file_range.file_id).ok()?;
+                to_location(
+                    reference.file_range.file_id,
+                    reference.file_range.range,
+                    &world,
+                    &line_index,
+                )
+                .ok()
             })
             .collect()
     };
@@ -830,8 +850,11 @@ pub fn handle_document_highlight(
 
     Ok(Some(
         refs.into_iter()
-            .filter(|r| r.file_id == file_id)
-            .map(|r| DocumentHighlight { range: r.range.conv_with(&line_index), kind: None })
+            .filter(|reference| reference.file_range.file_id == file_id)
+            .map(|reference| DocumentHighlight {
+                range: reference.file_range.range.conv_with(&line_index),
+                kind: reference.access.map(|it| it.conv()),
+            })
             .collect(),
     ))
 }
@@ -933,3 +956,91 @@ pub fn handle_inlay_hints(
         })
         .collect())
 }
+
+pub fn handle_call_hierarchy_prepare(
+    world: WorldSnapshot,
+    params: CallHierarchyPrepareParams,
+) -> Result<Option<Vec<CallHierarchyItem>>> {
+    let _p = profile("handle_call_hierarchy_prepare");
+    let position = params.text_document_position_params.try_conv_with(&world)?;
+    let file_id = position.file_id;
+
+    let nav_info = match world.analysis().call_hierarchy(position)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let RangeInfo { range, info: navs } = nav_info;
+    let res = navs
+        .into_iter()
+        .filter(|it| it.kind() == SyntaxKind::FN_DEF)
+        .filter_map(|it| to_call_hierarchy_item(file_id, range, &world, &line_index, it).ok())
+        .collect();
+
+    Ok(Some(res))
+}
+
+pub fn handle_call_hierarchy_incoming(
+    world: WorldSnapshot,
+    params: CallHierarchyIncomingCallsParams,
+) -> Result<Option<Vec<CallHierarchyIncomingCall>>> {
+    let _p = profile("handle_call_hierarchy_incoming");
+    let item = params.item;
+
+    let doc = TextDocumentIdentifier::new(item.uri);
+    let frange: FileRange = (&doc, item.range).try_conv_with(&world)?;
+    let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
+
+    let call_items = match world.analysis().incoming_calls(fpos)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+
+    let mut res = vec![];
+
+    for call_item in call_items.into_iter() {
+        let file_id = call_item.target.file_id();
+        let line_index = world.analysis().file_line_index(file_id)?;
+        let range = call_item.target.range();
+        let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?;
+        res.push(CallHierarchyIncomingCall {
+            from: item,
+            from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(),
+        });
+    }
+
+    Ok(Some(res))
+}
+
+pub fn handle_call_hierarchy_outgoing(
+    world: WorldSnapshot,
+    params: CallHierarchyOutgoingCallsParams,
+) -> Result<Option<Vec<CallHierarchyOutgoingCall>>> {
+    let _p = profile("handle_call_hierarchy_outgoing");
+    let item = params.item;
+
+    let doc = TextDocumentIdentifier::new(item.uri);
+    let frange: FileRange = (&doc, item.range).try_conv_with(&world)?;
+    let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
+
+    let call_items = match world.analysis().outgoing_calls(fpos)? {
+        None => return Ok(None),
+        Some(it) => it,
+    };
+
+    let mut res = vec![];
+
+    for call_item in call_items.into_iter() {
+        let file_id = call_item.target.file_id();
+        let line_index = world.analysis().file_line_index(file_id)?;
+        let range = call_item.target.range();
+        let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?;
+        res.push(CallHierarchyOutgoingCall {
+            to: item,
+            from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(),
+        });
+    }
+
+    Ok(Some(res))
+}
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 40edaf677..8098ff31d 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -6,13 +6,15 @@ use serde::{Deserialize, Serialize};
 
 pub use lsp_types::{
     notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
-    CodeLensParams, CompletionParams, CompletionResponse, DidChangeConfigurationParams,
-    DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions,
-    DocumentOnTypeFormattingParams, DocumentSymbolParams, DocumentSymbolResponse,
-    FileSystemWatcher, Hover, InitializeResult, MessageType, ProgressParams, ProgressParamsValue,
-    ProgressToken, PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams,
-    SelectionRange, SelectionRangeParams, ShowMessageParams, SignatureHelp, TextDocumentEdit,
-    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams,
+    CodeLensParams, CompletionParams, CompletionResponse, DiagnosticTag,
+    DidChangeConfigurationParams, DidChangeWatchedFilesParams,
+    DidChangeWatchedFilesRegistrationOptions, DocumentOnTypeFormattingParams, DocumentSymbolParams,
+    DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
+    PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,
+    PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams, SelectionRange,
+    SelectionRangeParams, ServerCapabilities, ShowMessageParams, SignatureHelp, SymbolKind,
+    TextDocumentEdit, TextDocumentPositionParams, TextEdit, WorkDoneProgressParams, WorkspaceEdit,
+    WorkspaceSymbolParams,
 };
 
 pub enum AnalyzerStatus {}
diff --git a/crates/ra_parser/src/grammar/items/traits.rs b/crates/ra_parser/src/grammar/items/traits.rs
index 964fd3041..03dae3cdb 100644
--- a/crates/ra_parser/src/grammar/items/traits.rs
+++ b/crates/ra_parser/src/grammar/items/traits.rs
@@ -10,6 +10,16 @@ pub(super) fn trait_def(p: &mut Parser) {
     p.bump(T![trait]);
     name_r(p, ITEM_RECOVERY_SET);
     type_params::opt_type_param_list(p);
+    // test trait_alias
+    // trait Z<U> = T<U>;
+    // trait Z<U> = T<U> where U: Copy;
+    // trait Z<U> = where Self: T<U>;
+    if p.eat(T![=]) {
+        type_params::bounds_without_colon(p);
+        type_params::opt_where_clause(p);
+        p.expect(T![;]);
+        return;
+    }
     if p.at(T![:]) {
         type_params::bounds(p);
     }
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index d71b7031a..b7f6a9b57 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -23,9 +23,19 @@ pub use crate::{
     sysroot::Sysroot,
 };
 
-// FIXME use proper error enum
 pub type Result<T> = ::std::result::Result<T, Box<dyn Error + Send + Sync>>;
 
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct CargoTomlNotFoundError(pub PathBuf);
+
+impl std::fmt::Display for CargoTomlNotFoundError {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(fmt, "can't find Cargo.toml at {}", self.0.display())
+    }
+}
+
+impl Error for CargoTomlNotFoundError {}
+
 #[derive(Debug, Clone)]
 pub enum ProjectWorkspace {
     /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
@@ -362,7 +372,7 @@ fn find_cargo_toml(path: &Path) -> Result<PathBuf> {
         }
         curr = path.parent();
     }
-    Err(format!("can't find Cargo.toml at {}", path.display()))?
+    Err(CargoTomlNotFoundError(path.to_path_buf()))?
 }
 
 pub fn get_rustc_cfg_options() -> CfgOptions {
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index 10ca391b6..34d066b1e 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -53,9 +53,10 @@ impl Sysroot {
         if !src.exists() {
             Err(format!(
                 "can't load standard library from sysroot\n\
-                 {:?}\n\
+                 {}\n\
+                 (discovered via `rustc --print sysroot`)\n\
                  try running `rustup component add rust-src` or set `RUST_SRC_PATH`",
-                src,
+                src.display(),
             ))?;
         }
 
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index b6ebb129d..c5a3d1999 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 
 [dependencies]
 itertools = "0.8.0"
-rowan = "0.8.0"
+rowan = "0.9.0"
 rustc_lexer = "0.1.0"
 rustc-hash = "1.0.1"
 arrayvec = "0.5.1"
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index e4061e994..2b2b295f9 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -214,8 +214,7 @@ fn with_children(
     new_children: Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
 ) -> SyntaxNode {
     let len = new_children.iter().map(|it| it.text_len()).sum::<TextUnit>();
-    let new_node =
-        rowan::GreenNode::new(rowan::cursor::SyntaxKind(parent.kind() as u16), new_children);
+    let new_node = rowan::GreenNode::new(rowan::SyntaxKind(parent.kind() as u16), new_children);
     let new_root_node = parent.replace_with(new_node);
     let new_root_node = SyntaxNode::new_root(new_root_node);
 
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index 23b6aa901..3dfecfe76 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -144,6 +144,7 @@ impl BinOp {
         }
     }
 }
+
 impl ast::BinExpr {
     pub fn op_details(&self) -> Option<(SyntaxToken, BinOp)> {
         self.syntax().children_with_tokens().filter_map(|it| it.into_token()).find_map(|c| {
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index 65b8aa10d..06bdda11d 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -70,8 +70,7 @@ fn reparse_token<'node>(
                 }
             }
 
-            let new_token =
-                GreenToken::new(rowan::cursor::SyntaxKind(token.kind().into()), text.into());
+            let new_token = GreenToken::new(rowan::SyntaxKind(token.kind().into()), text.into());
             Some((token.replace_with(new_token), token.text_range()))
         }
         _ => None,
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index 041c6ea8d..b3eb5da63 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -21,18 +21,18 @@ pub enum RustLanguage {}
 impl Language for RustLanguage {
     type Kind = SyntaxKind;
 
-    fn kind_from_raw(raw: rowan::cursor::SyntaxKind) -> SyntaxKind {
+    fn kind_from_raw(raw: rowan::SyntaxKind) -> SyntaxKind {
         SyntaxKind::from(raw.0)
     }
 
-    fn kind_to_raw(kind: SyntaxKind) -> rowan::cursor::SyntaxKind {
-        rowan::cursor::SyntaxKind(kind.into())
+    fn kind_to_raw(kind: SyntaxKind) -> rowan::SyntaxKind {
+        rowan::SyntaxKind(kind.into())
     }
 }
 
 pub type SyntaxNode = rowan::SyntaxNode<RustLanguage>;
 pub type SyntaxToken = rowan::SyntaxToken<RustLanguage>;
-pub type SyntaxElement = rowan::NodeOrToken<SyntaxNode, SyntaxToken>;
+pub type SyntaxElement = rowan::SyntaxElement<RustLanguage>;
 pub type SyntaxNodeChildren = rowan::SyntaxNodeChildren<RustLanguage>;
 pub type SyntaxElementChildren = rowan::SyntaxElementChildren<RustLanguage>;
 
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.rs b/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.rs
new file mode 100644
index 000000000..4bd428ee4
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.rs
@@ -0,0 +1,3 @@
+trait Z<U> = T<U>;
+trait Z<U> = T<U> where U: Copy;
+trait Z<U> = where Self: T<U>;
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.txt b/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.txt
new file mode 100644
index 000000000..de1536ef0
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0151_trait_alias.txt
@@ -0,0 +1,128 @@
+SOURCE_FILE@[0; 83)
+  TRAIT_DEF@[0; 18)
+    TRAIT_KW@[0; 5) "trait"
+    WHITESPACE@[5; 6) " "
+    NAME@[6; 7)
+      IDENT@[6; 7) "Z"
+    TYPE_PARAM_LIST@[7; 10)
+      L_ANGLE@[7; 8) "<"
+      TYPE_PARAM@[8; 9)
+        NAME@[8; 9)
+          IDENT@[8; 9) "U"
+      R_ANGLE@[9; 10) ">"
+    WHITESPACE@[10; 11) " "
+    EQ@[11; 12) "="
+    WHITESPACE@[12; 13) " "
+    TYPE_BOUND_LIST@[13; 17)
+      TYPE_BOUND@[13; 17)
+        PATH_TYPE@[13; 17)
+          PATH@[13; 17)
+            PATH_SEGMENT@[13; 17)
+              NAME_REF@[13; 14)
+                IDENT@[13; 14) "T"
+              TYPE_ARG_LIST@[14; 17)
+                L_ANGLE@[14; 15) "<"
+                TYPE_ARG@[15; 16)
+                  PATH_TYPE@[15; 16)
+                    PATH@[15; 16)
+                      PATH_SEGMENT@[15; 16)
+                        NAME_REF@[15; 16)
+                          IDENT@[15; 16) "U"
+                R_ANGLE@[16; 17) ">"
+    SEMI@[17; 18) ";"
+  WHITESPACE@[18; 19) "\n"
+  TRAIT_DEF@[19; 51)
+    TRAIT_KW@[19; 24) "trait"
+    WHITESPACE@[24; 25) " "
+    NAME@[25; 26)
+      IDENT@[25; 26) "Z"
+    TYPE_PARAM_LIST@[26; 29)
+      L_ANGLE@[26; 27) "<"
+      TYPE_PARAM@[27; 28)
+        NAME@[27; 28)
+          IDENT@[27; 28) "U"
+      R_ANGLE@[28; 29) ">"
+    WHITESPACE@[29; 30) " "
+    EQ@[30; 31) "="
+    WHITESPACE@[31; 32) " "
+    TYPE_BOUND_LIST@[32; 36)
+      TYPE_BOUND@[32; 36)
+        PATH_TYPE@[32; 36)
+          PATH@[32; 36)
+            PATH_SEGMENT@[32; 36)
+              NAME_REF@[32; 33)
+                IDENT@[32; 33) "T"
+              TYPE_ARG_LIST@[33; 36)
+                L_ANGLE@[33; 34) "<"
+                TYPE_ARG@[34; 35)
+                  PATH_TYPE@[34; 35)
+                    PATH@[34; 35)
+                      PATH_SEGMENT@[34; 35)
+                        NAME_REF@[34; 35)
+                          IDENT@[34; 35) "U"
+                R_ANGLE@[35; 36) ">"
+    WHITESPACE@[36; 37) " "
+    WHERE_CLAUSE@[37; 50)
+      WHERE_KW@[37; 42) "where"
+      WHITESPACE@[42; 43) " "
+      WHERE_PRED@[43; 50)
+        PATH_TYPE@[43; 44)
+          PATH@[43; 44)
+            PATH_SEGMENT@[43; 44)
+              NAME_REF@[43; 44)
+                IDENT@[43; 44) "U"
+        COLON@[44; 45) ":"
+        WHITESPACE@[45; 46) " "
+        TYPE_BOUND_LIST@[46; 50)
+          TYPE_BOUND@[46; 50)
+            PATH_TYPE@[46; 50)
+              PATH@[46; 50)
+                PATH_SEGMENT@[46; 50)
+                  NAME_REF@[46; 50)
+                    IDENT@[46; 50) "Copy"
+    SEMI@[50; 51) ";"
+  WHITESPACE@[51; 52) "\n"
+  TRAIT_DEF@[52; 82)
+    TRAIT_KW@[52; 57) "trait"
+    WHITESPACE@[57; 58) " "
+    NAME@[58; 59)
+      IDENT@[58; 59) "Z"
+    TYPE_PARAM_LIST@[59; 62)
+      L_ANGLE@[59; 60) "<"
+      TYPE_PARAM@[60; 61)
+        NAME@[60; 61)
+          IDENT@[60; 61) "U"
+      R_ANGLE@[61; 62) ">"
+    WHITESPACE@[62; 63) " "
+    EQ@[63; 64) "="
+    WHITESPACE@[64; 65) " "
+    TYPE_BOUND_LIST@[65; 65)
+    WHERE_CLAUSE@[65; 81)
+      WHERE_KW@[65; 70) "where"
+      WHITESPACE@[70; 71) " "
+      WHERE_PRED@[71; 81)
+        PATH_TYPE@[71; 75)
+          PATH@[71; 75)
+            PATH_SEGMENT@[71; 75)
+              NAME_REF@[71; 75)
+                IDENT@[71; 75) "Self"
+        COLON@[75; 76) ":"
+        WHITESPACE@[76; 77) " "
+        TYPE_BOUND_LIST@[77; 81)
+          TYPE_BOUND@[77; 81)
+            PATH_TYPE@[77; 81)
+              PATH@[77; 81)
+                PATH_SEGMENT@[77; 81)
+                  NAME_REF@[77; 78)
+                    IDENT@[77; 78) "T"
+                  TYPE_ARG_LIST@[78; 81)
+                    L_ANGLE@[78; 79) "<"
+                    TYPE_ARG@[79; 80)
+                      PATH_TYPE@[79; 80)
+                        PATH@[79; 80)
+                          PATH_SEGMENT@[79; 80)
+                            NAME_REF@[79; 80)
+                              IDENT@[79; 80) "U"
+                    R_ANGLE@[80; 81) ">"
+    SEMI@[81; 82) ";"
+  WHITESPACE@[82; 83) "\n"