24 files changed, 795 insertions, 68 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_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/lib.rs b/crates/ra_ide/src/lib.rs
index 779a81b2c..7b187eba3 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,7 @@ pub use crate::{
     inlay_hints::{InlayHint, InlayKind},
     line_index::{LineCol, LineIndex},
     line_index_utils::translate_offset_with_edit,
-    references::{ReferenceSearchResult, SearchScope},
+    references::{Reference, ReferenceKind, ReferenceSearchResult, SearchScope},
     runnables::{Runnable, RunnableKind},
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
     syntax_highlighting::HighlightedRange,
@@ -412,6 +414,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 a0226b1bc..5a3ec4eb9 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -214,7 +214,7 @@ fn process_definition(
 mod tests {
     use crate::{
         mock_analysis::{analysis_and_position, single_file_with_position, MockAnalysis},
-        ReferenceSearchResult, SearchScope,
+        Reference, ReferenceKind, ReferenceSearchResult, SearchScope,
     };
 
     #[test]
@@ -232,7 +232,12 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15)",
+            ReferenceKind::Other,
+            &["FileId(1) [142; 145) StructLiteral"],
+        );
     }
 
     #[test]
@@ -251,7 +256,17 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 5);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [33; 34)",
+            ReferenceKind::Other,
+            &[
+                "FileId(1) [67; 68) Other",
+                "FileId(1) [71; 72) Other",
+                "FileId(1) [101; 102) Other",
+                "FileId(1) [127; 128) Other",
+            ],
+        );
     }
 
     #[test]
@@ -262,7 +277,12 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13)",
+            ReferenceKind::Other,
+            &["FileId(1) [38; 39) Other"],
+        );
     }
 
     #[test]
@@ -273,7 +293,12 @@ mod tests {
     }"#;
 
         let refs = get_all_refs(code);
-        assert_eq!(refs.len(), 2);
+        check_result(
+            refs,
+            "i BIND_PAT FileId(1) [12; 13)",
+            ReferenceKind::Other,
+            &["FileId(1) [38; 39) Other"],
+        );
     }
 
     #[test]
@@ -290,7 +315,12 @@ 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)",
+            ReferenceKind::Other,
+            &["FileId(1) [152; 156) Other"],
+        );
     }
 
     #[test]
@@ -304,7 +334,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)", ReferenceKind::Other, &[]);
     }
 
     #[test]
@@ -319,7 +349,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)", ReferenceKind::Other, &[]);
     }
 
     #[test]
@@ -358,7 +388,12 @@ 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)",
+            ReferenceKind::Other,
+            &["FileId(1) [52; 55) StructLiteral", "FileId(3) [77; 80) StructLiteral"],
+        );
     }
 
     // `mod foo;` is not in the results because `foo` is an `ast::Name`.
@@ -384,7 +419,12 @@ 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)",
+            ReferenceKind::Other,
+            &["FileId(1) [13; 16) Other"],
+        );
     }
 
     #[test]
@@ -409,7 +449,12 @@ 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)",
+            ReferenceKind::Other,
+            &["FileId(2) [20; 23) Other", "FileId(2) [46; 49) StructLiteral"],
+        );
     }
 
     #[test]
@@ -433,11 +478,21 @@ 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)",
+            ReferenceKind::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)",
+            ReferenceKind::Other,
+            &["FileId(3) [16; 20) Other"],
+        );
     }
 
     #[test]
@@ -452,11 +507,40 @@ 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)",
+            ReferenceKind::Other,
+            &["FileId(1) [96; 98) Other", "FileId(1) [114; 116) Other"],
+        );
     }
 
     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,
+        decl_kind: ReferenceKind,
+        expected_refs: &[&str],
+    ) {
+        res.declaration().assert_match(expected_decl);
+        assert_eq!(res.declaration_kind, decl_kind);
+
+        assert_eq!(res.references.len(), expected_refs.len());
+        res.references().iter().enumerate().for_each(|(i, r)| r.assert_match(expected_refs[i]));
+    }
+
+    impl Reference {
+        fn debug_render(&self) -> String {
+            format!("{:?} {:?} {:?}", self.file_range.file_id, self.file_range.range, self.kind)
+        }
+
+        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_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..c260b51c4 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -490,6 +490,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 c8f52eb0e..a5b6f48af 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,
@@ -936,3 +942,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/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"