232 files changed, 3685 insertions, 1271 deletions

diff --git a/crates/gen_lsp_server/src/lib.rs b/crates/gen_lsp_server/src/lib.rs
index e45a6b5e2..5dab8f408 100644
--- a/crates/gen_lsp_server/src/lib.rs
+++ b/crates/gen_lsp_server/src/lib.rs
@@ -1,4 +1,4 @@
-//! A language server scaffold, exposing synchroneous crossbeam-channel based API.
+//! A language server scaffold, exposing a synchronous crossbeam-channel based API.
 //! This crate handles protocol handshaking and parsing messages, while you
 //! control the message dispatch loop yourself.
 //!
diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion/mod.rs
index 7c3476e5c..2e082705e 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -1,20 +1,20 @@
+mod reference_completion;
+
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    algo::visit::{visitor, visitor_ctx, Visitor, VisitorCtx},
-    ast::{self, AstChildren, LoopBodyOwner, ModuleItemOwner},
-    AstNode, AtomEdit, File,
-    SyntaxKind::*,
-    SyntaxNodeRef, TextUnit,
+    algo::find_leaf_at_offset,
+    algo::visit::{visitor_ctx, VisitorCtx},
+    ast,
+    AstNode, AtomEdit,
+    SyntaxNodeRef,
 };
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::{FxHashMap};
 
 use crate::{
     db::{self, SyntaxDatabase},
-    descriptors::function::FnScopes,
-    descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
-    descriptors::DescriptorDatabase,
-    input::FilesDatabase,
-    Cancelable, FilePosition,
+    descriptors::{DescriptorDatabase, module::ModuleSource},
+    input::{FilesDatabase},
+    Cancelable, FilePosition
 };
 
 #[derive(Debug)]
@@ -27,175 +27,65 @@ pub struct CompletionItem {
     pub snippet: Option<String>,
 }
 
-pub(crate) fn resolve_based_completion(
+pub(crate) fn completions(
     db: &db::RootDatabase,
     position: FilePosition,
 ) -> Cancelable<Option<Vec<CompletionItem>>> {
-    let source_root_id = db.file_source_root(position.file_id);
-    let file = db.file_syntax(position.file_id);
-    let module_tree = db.module_tree(source_root_id)?;
-    let module_id = match module_tree.any_module_for_source(ModuleSource::File(position.file_id)) {
-        None => return Ok(None),
-        Some(it) => it,
-    };
+    let original_file = db.file_syntax(position.file_id);
+    // Insert a fake ident to get a valid parse tree
     let file = {
         let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
-        file.reparse(&edit)
+        original_file.reparse(&edit)
+    };
+
+    let leaf = match find_leaf_at_offset(original_file.syntax(), position.offset).left_biased() {
+        None => return Ok(None),
+        Some(it) => it,
     };
-    let target_module_id = match find_target_module(&module_tree, module_id, &file, position.offset)
-    {
+    let source_root_id = db.file_source_root(position.file_id);
+    let module_tree = db.module_tree(source_root_id)?;
+    let module_source = ModuleSource::for_node(position.file_id, leaf);
+    let module_id = match module_tree.any_module_for_source(module_source) {
         None => return Ok(None),
         Some(it) => it,
     };
-    let module_scope = db.module_scope(source_root_id, target_module_id)?;
-    let res: Vec<_> = module_scope
-        .entries()
-        .iter()
-        .map(|entry| CompletionItem {
-            label: entry.name().to_string(),
-            lookup: None,
-            snippet: None,
-        })
-        .collect();
-    Ok(Some(res))
-}
-
-pub(crate) fn find_target_module(
-    module_tree: &ModuleTree,
-    module_id: ModuleId,
-    file: &File,
-    offset: TextUnit,
-) -> Option<ModuleId> {
-    let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), offset)?;
-    let mut crate_path = crate_path(name_ref)?;
-
-    crate_path.pop();
-    let mut target_module = module_id.root(&module_tree);
-    for name in crate_path {
-        target_module = target_module.child(module_tree, name.text().as_str())?;
-    }
-    Some(target_module)
-}
 
-fn crate_path(name_ref: ast::NameRef) -> Option<Vec<ast::NameRef>> {
-    let mut path = name_ref
-        .syntax()
-        .parent()
-        .and_then(ast::PathSegment::cast)?
-        .parent_path();
     let mut res = Vec::new();
-    loop {
-        let segment = path.segment()?;
-        match segment.kind()? {
-            ast::PathSegmentKind::Name(name) => res.push(name),
-            ast::PathSegmentKind::CrateKw => break,
-            ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
-        }
-        path = path.qualifier()?;
-    }
-    res.reverse();
-    Some(res)
-}
-
-pub(crate) fn scope_completion(
-    db: &db::RootDatabase,
-    position: FilePosition,
-) -> Option<Vec<CompletionItem>> {
-    let original_file = db.file_syntax(position.file_id);
-    // Insert a fake ident to get a valid parse tree
-    let file = {
-        let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
-        original_file.reparse(&edit)
-    };
     let mut has_completions = false;
-    let mut res = Vec::new();
+    // First, let's try to complete a reference to some declaration.
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
         has_completions = true;
-        complete_name_ref(&file, name_ref, &mut res);
+        reference_completion::completions(
+            &mut res,
+            db,
+            source_root_id,
+            &module_tree,
+            module_id,
+            &file,
+            name_ref,
+        )?;
         // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
         if is_node::<ast::Param>(name_ref.syntax()) {
             param_completions(name_ref.syntax(), &mut res);
         }
-        let name_range = name_ref.syntax().range();
-        let top_node = name_ref
-            .syntax()
-            .ancestors()
-            .take_while(|it| it.range() == name_range)
-            .last()
-            .unwrap();
-        match top_node.parent().map(|it| it.kind()) {
-            Some(ROOT) | Some(ITEM_LIST) => complete_mod_item_snippets(&mut res),
-            _ => (),
-        }
     }
+
+    // Otherwise, if this is a declaration, use heuristics to suggest a name.
     if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
         if is_node::<ast::Param>(name.syntax()) {
             has_completions = true;
             param_completions(name.syntax(), &mut res);
         }
     }
-    if has_completions {
-        Some(res)
-    } else {
-        None
-    }
-}
-
-fn complete_module_items(
-    file: &File,
-    items: AstChildren<ast::ModuleItem>,
-    this_item: Option<ast::NameRef>,
-    acc: &mut Vec<CompletionItem>,
-) {
-    let scope = ModuleScope::new(items); // FIXME
-    acc.extend(
-        scope
-            .entries()
-            .iter()
-            .filter(|entry| {
-                let syntax = entry.ptr().resolve(file);
-                Some(syntax.borrowed()) != this_item.map(|it| it.syntax())
-            })
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-}
-
-fn complete_name_ref(file: &File, name_ref: ast::NameRef, acc: &mut Vec<CompletionItem>) {
-    if !is_node::<ast::Path>(name_ref.syntax()) {
-        return;
-    }
-    let mut visited_fn = false;
-    for node in name_ref.syntax().ancestors() {
-        if let Some(items) = visitor()
-            .visit::<ast::Root, _>(|it| Some(it.items()))
-            .visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
-            .accept(node)
-        {
-            if let Some(items) = items {
-                complete_module_items(file, items, Some(name_ref), acc);
-            }
-            break;
-        } else if !visited_fn {
-            if let Some(fn_def) = ast::FnDef::cast(node) {
-                visited_fn = true;
-                complete_expr_keywords(&file, fn_def, name_ref, acc);
-                complete_expr_snippets(acc);
-                let scopes = FnScopes::new(fn_def);
-                complete_fn(name_ref, &scopes, acc);
-            }
-        }
-    }
+    let res = if has_completions { Some(res) } else { None };
+    Ok(res)
 }
 
 fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
     let mut params = FxHashMap::default();
     for node in ctx.ancestors() {
         let _ = visitor_ctx(&mut params)
-            .visit::<ast::Root, _>(process)
+            .visit::<ast::SourceFile, _>(process)
             .visit::<ast::ItemList, _>(process)
             .accept(node);
     }
@@ -238,140 +128,6 @@ fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
     }
 }
 
-fn complete_expr_keywords(
-    file: &File,
-    fn_def: ast::FnDef,
-    name_ref: ast::NameRef,
-    acc: &mut Vec<CompletionItem>,
-) {
-    acc.push(keyword("if", "if $0 {}"));
-    acc.push(keyword("match", "match $0 {}"));
-    acc.push(keyword("while", "while $0 {}"));
-    acc.push(keyword("loop", "loop {$0}"));
-
-    if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
-        if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
-            if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
-                acc.push(keyword("else", "else {$0}"));
-                acc.push(keyword("else if", "else if $0 {}"));
-            }
-        }
-    }
-    if is_in_loop_body(name_ref) {
-        acc.push(keyword("continue", "continue"));
-        acc.push(keyword("break", "break"));
-    }
-    acc.extend(complete_return(fn_def, name_ref));
-}
-
-fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
-    for node in name_ref.syntax().ancestors() {
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
-        }
-        let loop_body = visitor()
-            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
-            .accept(node);
-        if let Some(Some(body)) = loop_body {
-            if name_ref
-                .syntax()
-                .range()
-                .is_subrange(&body.syntax().range())
-            {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
-    // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
-    //     .next()
-    //     .and_then(|it| it.syntax().parent())
-    //     .and_then(ast::Block::cast)
-    //     .is_some();
-
-    // if is_last_in_block {
-    //     return None;
-    // }
-
-    let is_stmt = match name_ref
-        .syntax()
-        .ancestors()
-        .filter_map(ast::ExprStmt::cast)
-        .next()
-    {
-        None => false,
-        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
-    };
-    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
-        (true, true) => "return $0;",
-        (true, false) => "return;",
-        (false, true) => "return $0",
-        (false, false) => "return",
-    };
-    Some(keyword("return", snip))
-}
-
-fn keyword(kw: &str, snip: &str) -> CompletionItem {
-    CompletionItem {
-        label: kw.to_string(),
-        lookup: None,
-        snippet: Some(snip.to_string()),
-    }
-}
-
-fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "pd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "ppd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
-    });
-}
-
-fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "tfn".to_string(),
-        lookup: None,
-        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "pub(crate)".to_string(),
-        lookup: None,
-        snippet: Some("pub(crate) $0".to_string()),
-    })
-}
-
-fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
-    let mut shadowed = FxHashSet::default();
-    acc.extend(
-        scopes
-            .scope_chain(name_ref.syntax())
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-    if scopes.self_param.is_some() {
-        acc.push(CompletionItem {
-            label: "self".to_string(),
-            lookup: None,
-            snippet: None,
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use test_utils::assert_eq_dbg;
@@ -382,7 +138,8 @@ mod tests {
 
     fn check_scope_completion(code: &str, expected_completions: &str) {
         let (analysis, position) = single_file_with_position(code);
-        let completions = scope_completion(&analysis.imp.db, position)
+        let completions = completions(&analysis.imp.db, position)
+            .unwrap()
             .unwrap()
             .into_iter()
             .filter(|c| c.snippet.is_none())
@@ -392,7 +149,8 @@ mod tests {
 
     fn check_snippet_completion(code: &str, expected_completions: &str) {
         let (analysis, position) = single_file_with_position(code);
-        let completions = scope_completion(&analysis.imp.db, position)
+        let completions = completions(&analysis.imp.db, position)
+            .unwrap()
             .unwrap()
             .into_iter()
             .filter(|c| c.snippet.is_some())
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
new file mode 100644
index 000000000..6c5fd0be6
--- /dev/null
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -0,0 +1,316 @@
+use rustc_hash::{FxHashSet};
+use ra_editor::find_node_at_offset;
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    SourceFileNode, AstNode,
+    ast::{self, LoopBodyOwner},
+    SyntaxKind::*,
+};
+
+use crate::{
+    db::RootDatabase,
+    input::{SourceRootId},
+    completion::CompletionItem,
+    descriptors::module::{ModuleId, ModuleTree},
+    descriptors::function::FnScopes,
+    descriptors::DescriptorDatabase,
+    Cancelable
+};
+
+pub(super) fn completions(
+    acc: &mut Vec<CompletionItem>,
+    db: &RootDatabase,
+    source_root_id: SourceRootId,
+    module_tree: &ModuleTree,
+    module_id: ModuleId,
+    file: &SourceFileNode,
+    name_ref: ast::NameRef,
+) -> Cancelable<()> {
+    let kind = match classify_name_ref(name_ref) {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+
+    match kind {
+        NameRefKind::LocalRef { enclosing_fn } => {
+            if let Some(fn_def) = enclosing_fn {
+                let scopes = FnScopes::new(fn_def);
+                complete_fn(name_ref, &scopes, acc);
+                complete_expr_keywords(&file, fn_def, name_ref, acc);
+                complete_expr_snippets(acc);
+            }
+
+            let module_scope = db.module_scope(source_root_id, module_id)?;
+            acc.extend(
+                module_scope
+                    .entries()
+                    .iter()
+                    .filter(|entry| {
+                        // Don't expose this item
+                        !entry.ptr().range().is_subrange(&name_ref.syntax().range())
+                    })
+                    .map(|entry| CompletionItem {
+                        label: entry.name().to_string(),
+                        lookup: None,
+                        snippet: None,
+                    }),
+            );
+        }
+        NameRefKind::CratePath(path) => {
+            complete_path(acc, db, source_root_id, module_tree, module_id, path)?
+        }
+        NameRefKind::BareIdentInMod => {
+            let name_range = name_ref.syntax().range();
+            let top_node = name_ref
+                .syntax()
+                .ancestors()
+                .take_while(|it| it.range() == name_range)
+                .last()
+                .unwrap();
+            match top_node.parent().map(|it| it.kind()) {
+                Some(SOURCE_FILE) | Some(ITEM_LIST) => complete_mod_item_snippets(acc),
+                _ => (),
+            }
+        }
+    }
+    Ok(())
+}
+
+enum NameRefKind<'a> {
+    /// NameRef is a part of single-segment path, for example, a refernece to a
+    /// local variable.
+    LocalRef {
+        enclosing_fn: Option<ast::FnDef<'a>>,
+    },
+    /// NameRef is the last segment in crate:: path
+    CratePath(Vec<ast::NameRef<'a>>),
+    /// NameRef is bare identifier at the module's root.
+    /// Used for keyword completion
+    BareIdentInMod,
+}
+
+fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
+    let name_range = name_ref.syntax().range();
+    let top_node = name_ref
+        .syntax()
+        .ancestors()
+        .take_while(|it| it.range() == name_range)
+        .last()
+        .unwrap();
+    match top_node.parent().map(|it| it.kind()) {
+        Some(SOURCE_FILE) | Some(ITEM_LIST) => return Some(NameRefKind::BareIdentInMod),
+        _ => (),
+    }
+
+    let parent = name_ref.syntax().parent()?;
+    if let Some(segment) = ast::PathSegment::cast(parent) {
+        let path = segment.parent_path();
+        if let Some(crate_path) = crate_path(path) {
+            return Some(NameRefKind::CratePath(crate_path));
+        }
+        if path.qualifier().is_none() {
+            let enclosing_fn = name_ref
+                .syntax()
+                .ancestors()
+                .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+                .find_map(ast::FnDef::cast);
+            return Some(NameRefKind::LocalRef { enclosing_fn });
+        }
+    }
+    None
+}
+
+fn crate_path(mut path: ast::Path) -> Option<Vec<ast::NameRef>> {
+    let mut res = Vec::new();
+    loop {
+        let segment = path.segment()?;
+        match segment.kind()? {
+            ast::PathSegmentKind::Name(name) => res.push(name),
+            ast::PathSegmentKind::CrateKw => break,
+            ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
+        }
+        path = qualifier(path)?;
+    }
+    res.reverse();
+    return Some(res);
+
+    fn qualifier(path: ast::Path) -> Option<ast::Path> {
+        if let Some(q) = path.qualifier() {
+            return Some(q);
+        }
+        // TODO: this bottom up traversal is not too precise.
+        // Should we handle do a top-down analysiss, recording results?
+        let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
+        let use_tree = use_tree_list.parent_use_tree();
+        use_tree.path()
+    }
+}
+
+fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
+    let mut shadowed = FxHashSet::default();
+    acc.extend(
+        scopes
+            .scope_chain(name_ref.syntax())
+            .flat_map(|scope| scopes.entries(scope).iter())
+            .filter(|entry| shadowed.insert(entry.name()))
+            .map(|entry| CompletionItem {
+                label: entry.name().to_string(),
+                lookup: None,
+                snippet: None,
+            }),
+    );
+    if scopes.self_param.is_some() {
+        acc.push(CompletionItem {
+            label: "self".to_string(),
+            lookup: None,
+            snippet: None,
+        })
+    }
+}
+
+fn complete_path(
+    acc: &mut Vec<CompletionItem>,
+    db: &RootDatabase,
+    source_root_id: SourceRootId,
+    module_tree: &ModuleTree,
+    module_id: ModuleId,
+    crate_path: Vec<ast::NameRef>,
+) -> Cancelable<()> {
+    let target_module_id = match find_target_module(module_tree, module_id, crate_path) {
+        None => return Ok(()),
+        Some(it) => it,
+    };
+    let module_scope = db.module_scope(source_root_id, target_module_id)?;
+    let completions = module_scope.entries().iter().map(|entry| CompletionItem {
+        label: entry.name().to_string(),
+        lookup: None,
+        snippet: None,
+    });
+    acc.extend(completions);
+    Ok(())
+}
+
+fn find_target_module(
+    module_tree: &ModuleTree,
+    module_id: ModuleId,
+    mut crate_path: Vec<ast::NameRef>,
+) -> Option<ModuleId> {
+    crate_path.pop();
+    let mut target_module = module_id.root(&module_tree);
+    for name in crate_path {
+        target_module = target_module.child(module_tree, name.text().as_str())?;
+    }
+    Some(target_module)
+}
+
+fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
+    acc.push(CompletionItem {
+        label: "tfn".to_string(),
+        lookup: None,
+        snippet: Some("#[test]\nfn $1() {\n    $0\n}".to_string()),
+    });
+    acc.push(CompletionItem {
+        label: "pub(crate)".to_string(),
+        lookup: None,
+        snippet: Some("pub(crate) $0".to_string()),
+    })
+}
+
+fn complete_expr_keywords(
+    file: &SourceFileNode,
+    fn_def: ast::FnDef,
+    name_ref: ast::NameRef,
+    acc: &mut Vec<CompletionItem>,
+) {
+    acc.push(keyword("if", "if $0 {}"));
+    acc.push(keyword("match", "match $0 {}"));
+    acc.push(keyword("while", "while $0 {}"));
+    acc.push(keyword("loop", "loop {$0}"));
+
+    if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
+        if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
+            if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
+                acc.push(keyword("else", "else {$0}"));
+                acc.push(keyword("else if", "else if $0 {}"));
+            }
+        }
+    }
+    if is_in_loop_body(name_ref) {
+        acc.push(keyword("continue", "continue"));
+        acc.push(keyword("break", "break"));
+    }
+    acc.extend(complete_return(fn_def, name_ref));
+}
+
+fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
+    for node in name_ref.syntax().ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = visitor()
+            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
+            .accept(node);
+        if let Some(Some(body)) = loop_body {
+            if name_ref
+                .syntax()
+                .range()
+                .is_subrange(&body.syntax().range())
+            {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
+    // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
+    //     .next()
+    //     .and_then(|it| it.syntax().parent())
+    //     .and_then(ast::Block::cast)
+    //     .is_some();
+
+    // if is_last_in_block {
+    //     return None;
+    // }
+
+    let is_stmt = match name_ref
+        .syntax()
+        .ancestors()
+        .filter_map(ast::ExprStmt::cast)
+        .next()
+    {
+        None => false,
+        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
+    };
+    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
+        (true, true) => "return $0;",
+        (true, false) => "return;",
+        (false, true) => "return $0",
+        (false, false) => "return",
+    };
+    Some(keyword("return", snip))
+}
+
+fn keyword(kw: &str, snip: &str) -> CompletionItem {
+    CompletionItem {
+        label: kw.to_string(),
+        lookup: None,
+        snippet: Some(snip.to_string()),
+    }
+}
+
+fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
+    acc.push(CompletionItem {
+        label: "pd".to_string(),
+        lookup: None,
+        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
+    });
+    acc.push(CompletionItem {
+        label: "ppd".to_string(),
+        lookup: None,
+        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
+    });
+}
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 627512553..194f1a6b0 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use ra_editor::LineIndex;
-use ra_syntax::{File, SyntaxNode};
+use ra_syntax::{SourceFileNode, SyntaxNode};
 use salsa::{self, Database};
 
 use crate::{
@@ -85,7 +85,7 @@ salsa::database_storage! {
 
 salsa::query_group! {
     pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase {
-        fn file_syntax(file_id: FileId) -> File {
+        fn file_syntax(file_id: FileId) -> SourceFileNode {
             type FileSyntaxQuery;
         }
         fn file_lines(file_id: FileId) -> Arc<LineIndex> {
@@ -103,9 +103,9 @@ salsa::query_group! {
     }
 }
 
-fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> File {
+fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
     let text = db.file_text(file_id);
-    File::parse(&*text)
+    SourceFileNode::parse(&*text)
 }
 fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
     let text = db.file_text(file_id);
diff --git a/crates/ra_analysis/src/descriptors/function/scope.rs b/crates/ra_analysis/src/descriptors/function/scope.rs
index 62b46ffba..bbe16947c 100644
--- a/crates/ra_analysis/src/descriptors/function/scope.rs
+++ b/crates/ra_analysis/src/descriptors/function/scope.rs
@@ -272,7 +272,7 @@ pub fn resolve_local_name<'a>(
 #[cfg(test)]
 mod tests {
     use ra_editor::find_node_at_offset;
-    use ra_syntax::File;
+    use ra_syntax::SourceFileNode;
     use test_utils::extract_offset;
 
     use super::*;
@@ -287,7 +287,7 @@ mod tests {
             buf.push_str(&code[off..]);
             buf
         };
-        let file = File::parse(&code);
+        let file = SourceFileNode::parse(&code);
         let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
         let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
         let scopes = FnScopes::new(fn_def);
@@ -376,7 +376,7 @@ mod tests {
 
     fn do_check_local_name(code: &str, expected_offset: u32) {
         let (off, code) = extract_offset(code);
-        let file = File::parse(&code);
+        let file = SourceFileNode::parse(&code);
         let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
         let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
 
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs
index b5c232ea4..ade96ddc0 100644
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ b/crates/ra_analysis/src/descriptors/module/imp.rs
@@ -41,8 +41,8 @@ pub(crate) fn submodules(
     db::check_canceled(db)?;
     let file_id = source.file_id();
     let submodules = match source.resolve(db) {
-        ModuleSourceNode::Root(it) => collect_submodules(file_id, it.borrowed()),
-        ModuleSourceNode::Inline(it) => it
+        ModuleSourceNode::SourceFile(it) => collect_submodules(file_id, it.borrowed()),
+        ModuleSourceNode::Module(it) => it
             .borrowed()
             .item_list()
             .map(|it| collect_submodules(file_id, it))
@@ -89,8 +89,8 @@ pub(crate) fn module_scope(
     let tree = db.module_tree(source_root_id)?;
     let source = module_id.source(&tree).resolve(db);
     let res = match source {
-        ModuleSourceNode::Root(root) => ModuleScope::new(root.borrowed().items()),
-        ModuleSourceNode::Inline(inline) => match inline.borrowed().item_list() {
+        ModuleSourceNode::SourceFile(it) => ModuleScope::new(it.borrowed().items()),
+        ModuleSourceNode::Module(it) => match it.borrowed().item_list() {
             Some(items) => ModuleScope::new(items.items()),
             None => ModuleScope::new(std::iter::empty()),
         },
@@ -121,7 +121,7 @@ fn create_module_tree<'a>(
 
     let source_root = db.source_root(source_root);
     for &file_id in source_root.files.iter() {
-        let source = ModuleSource::File(file_id);
+        let source = ModuleSource::SourceFile(file_id);
         if visited.contains(&source) {
             continue; // TODO: use explicit crate_roots here
         }
@@ -181,7 +181,7 @@ fn build_subtree(
                             visited,
                             roots,
                             Some(link),
-                            ModuleSource::File(file_id),
+                            ModuleSource::SourceFile(file_id),
                         ),
                     })
                     .collect::<Cancelable<Vec<_>>>()?;
@@ -213,8 +213,8 @@ fn resolve_submodule(
     file_resolver: &FileResolverImp,
 ) -> (Vec<FileId>, Option<Problem>) {
     let file_id = match source {
-        ModuleSource::File(it) => it,
-        ModuleSource::Inline(..) => {
+        ModuleSource::SourceFile(it) => it,
+        ModuleSource::Module(..) => {
             // TODO
             return (Vec::new(), None);
         }
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
index 03330240d..bc1148b22 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -3,7 +3,7 @@ pub(crate) mod scope;
 
 use ra_syntax::{
     ast::{self, AstNode, NameOwner},
-    SmolStr, SyntaxNode,
+    SmolStr, SyntaxNode, SyntaxNodeRef,
 };
 use relative_path::RelativePathBuf;
 
@@ -41,19 +41,18 @@ impl ModuleTree {
 
 /// `ModuleSource` is the syntax tree element that produced this module:
 /// either a file, or an inlinde module.
-/// TODO: we don't produce Inline modules yet
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(crate) enum ModuleSource {
-    File(FileId),
+    SourceFile(FileId),
     #[allow(dead_code)]
-    Inline(SyntaxPtr),
+    Module(SyntaxPtr),
 }
 
 /// An owned syntax node for a module. Unlike `ModuleSource`,
 /// this holds onto the AST for the whole file.
 enum ModuleSourceNode {
-    Root(ast::RootNode),
-    Inline(ast::ModuleNode),
+    SourceFile(ast::SourceFileNode),
+    Module(ast::ModuleNode),
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
@@ -135,14 +134,14 @@ impl LinkId {
     ) -> ast::ModuleNode {
         let owner = self.owner(tree);
         match owner.source(tree).resolve(db) {
-            ModuleSourceNode::Root(root) => {
+            ModuleSourceNode::SourceFile(root) => {
                 let ast = imp::modules(root.borrowed())
                     .find(|(name, _)| name == &tree.link(self).name)
                     .unwrap()
                     .1;
                 ast.owned()
             }
-            ModuleSourceNode::Inline(it) => it,
+            ModuleSourceNode::Module(it) => it,
         }
     }
 }
@@ -155,37 +154,47 @@ struct ModuleData {
 }
 
 impl ModuleSource {
+    pub(crate) fn for_node(file_id: FileId, node: SyntaxNodeRef) -> ModuleSource {
+        for node in node.ancestors() {
+            if let Some(m) = ast::Module::cast(node) {
+                if !m.has_semi() {
+                    return ModuleSource::new_inline(file_id, m);
+                }
+            }
+        }
+        ModuleSource::SourceFile(file_id)
+    }
     pub(crate) fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
         assert!(!module.has_semi());
         let ptr = SyntaxPtr::new(file_id, module.syntax());
-        ModuleSource::Inline(ptr)
+        ModuleSource::Module(ptr)
     }
 
     pub(crate) fn as_file(self) -> Option<FileId> {
         match self {
-            ModuleSource::File(f) => Some(f),
-            ModuleSource::Inline(..) => None,
+            ModuleSource::SourceFile(f) => Some(f),
+            ModuleSource::Module(..) => None,
         }
     }
 
     pub(crate) fn file_id(self) -> FileId {
         match self {
-            ModuleSource::File(f) => f,
-            ModuleSource::Inline(ptr) => ptr.file_id(),
+            ModuleSource::SourceFile(f) => f,
+            ModuleSource::Module(ptr) => ptr.file_id(),
         }
     }
 
     fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
         match self {
-            ModuleSource::File(file_id) => {
+            ModuleSource::SourceFile(file_id) => {
                 let syntax = db.file_syntax(file_id);
-                ModuleSourceNode::Root(syntax.ast().owned())
+                ModuleSourceNode::SourceFile(syntax.ast().owned())
             }
-            ModuleSource::Inline(ptr) => {
+            ModuleSource::Module(ptr) => {
                 let syntax = db.resolve_syntax_ptr(ptr);
                 let syntax = syntax.borrowed();
                 let module = ast::Module::cast(syntax).unwrap();
-                ModuleSourceNode::Inline(module.owned())
+                ModuleSourceNode::Module(module.owned())
             }
         }
     }
diff --git a/crates/ra_analysis/src/descriptors/module/scope.rs b/crates/ra_analysis/src/descriptors/module/scope.rs
index 215b31f8e..4490228e4 100644
--- a/crates/ra_analysis/src/descriptors/module/scope.rs
+++ b/crates/ra_analysis/src/descriptors/module/scope.rs
@@ -25,7 +25,7 @@ enum EntryKind {
 }
 
 impl ModuleScope {
-    pub(crate) fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> ModuleScope {
+    pub(super) fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> ModuleScope {
         let mut entries = Vec::new();
         for item in items {
             let entry = match item {
@@ -95,10 +95,10 @@ fn collect_imports(tree: ast::UseTree, acc: &mut Vec<Entry>) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ra_syntax::{ast::ModuleItemOwner, File};
+    use ra_syntax::{ast::ModuleItemOwner, SourceFileNode};
 
     fn do_check(code: &str, expected: &[&str]) {
-        let file = File::parse(&code);
+        let file = SourceFileNode::parse(&code);
         let scope = ModuleScope::new(file.ast().items());
         let actual = scope.entries.iter().map(|it| it.name()).collect::<Vec<_>>();
         assert_eq!(expected, actual.as_slice());
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 819827b95..74c248a96 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -7,7 +7,7 @@ use std::{
 use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit};
 use ra_syntax::{
     ast::{self, ArgListOwner, Expr, NameOwner},
-    AstNode, File, SmolStr,
+    AstNode, SourceFileNode, SmolStr,
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
@@ -17,7 +17,7 @@ use rustc_hash::FxHashSet;
 use salsa::{Database, ParallelDatabase};
 
 use crate::{
-    completion::{resolve_based_completion, scope_completion, CompletionItem},
+    completion::{completions, CompletionItem},
     db::{self, FileSyntaxQuery, SyntaxDatabase},
     descriptors::{
         function::{FnDescriptor, FnId},
@@ -27,7 +27,7 @@ use crate::{
     input::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE},
     symbol_index::SymbolIndex,
     AnalysisChange, Cancelable, CrateGraph, CrateId, Diagnostic, FileId, FileResolver,
-    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileEdit,
+    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
 };
 
 #[derive(Clone, Debug)]
@@ -180,7 +180,7 @@ impl fmt::Debug for AnalysisImpl {
 }
 
 impl AnalysisImpl {
-    pub fn file_syntax(&self, file_id: FileId) -> File {
+    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
         self.db.file_syntax(file_id)
     }
     pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
@@ -226,7 +226,7 @@ impl AnalysisImpl {
         let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
         {
             Some(m) if !m.has_semi() => ModuleSource::new_inline(position.file_id, m),
-            _ => ModuleSource::File(position.file_id),
+            _ => ModuleSource::SourceFile(position.file_id),
         };
 
         let res = module_tree
@@ -254,7 +254,7 @@ impl AnalysisImpl {
         let module_tree = self.module_tree(file_id)?;
         let crate_graph = self.db.crate_graph();
         let res = module_tree
-            .modules_for_source(ModuleSource::File(file_id))
+            .modules_for_source(ModuleSource::SourceFile(file_id))
             .into_iter()
             .map(|it| it.root(&module_tree))
             .filter_map(|it| it.source(&module_tree).as_file())
@@ -267,18 +267,7 @@ impl AnalysisImpl {
         self.db.crate_graph().crate_roots[&crate_id]
     }
     pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        let mut res = Vec::new();
-        let mut has_completions = false;
-        if let Some(scope_based) = scope_completion(&self.db, position) {
-            res.extend(scope_based);
-            has_completions = true;
-        }
-        if let Some(scope_based) = resolve_based_completion(&self.db, position)? {
-            res.extend(scope_based);
-            has_completions = true;
-        }
-        let res = if has_completions { Some(res) } else { None };
-        Ok(res)
+        completions(&self.db, position)
     }
     pub fn approximately_resolve_symbol(
         &self,
@@ -364,6 +353,16 @@ impl AnalysisImpl {
         ret
     }
 
+    pub fn doc_comment_for(
+        &self,
+        file_id: FileId,
+        symbol: FileSymbol,
+    ) -> Cancelable<Option<String>> {
+        let file = self.db.file_syntax(file_id);
+
+        Ok(symbol.docs(&file))
+    }
+
     pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
         let module_tree = self.module_tree(file_id)?;
         let syntax = self.db.file_syntax(file_id);
@@ -376,7 +375,7 @@ impl AnalysisImpl {
                 fix: None,
             })
             .collect::<Vec<_>>();
-        if let Some(m) = module_tree.any_module_for_source(ModuleSource::File(file_id)) {
+        if let Some(m) = module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
             for (name_node, problem) in m.problems(&module_tree, &*self.db) {
                 let diag = match problem {
                     Problem::UnresolvedModule { candidate } => {
@@ -538,7 +537,7 @@ impl AnalysisImpl {
             Some(name) => name.text(),
             None => return Vec::new(),
         };
-        let module_id = match module_tree.any_module_for_source(ModuleSource::File(file_id)) {
+        let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
             Some(id) => id,
             None => return Vec::new(),
         };
@@ -552,7 +551,7 @@ impl AnalysisImpl {
 
 impl SourceChange {
     pub(crate) fn from_local_edit(file_id: FileId, label: &str, edit: LocalEdit) -> SourceChange {
-        let file_edit = SourceFileEdit {
+        let file_edit = SourceFileNodeEdit {
             file_id,
             edits: edit.edit.into_atoms(),
         };
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 0ea9ebee7..ab0e3cb0c 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -1,5 +1,5 @@
 //! ra_analyzer crate is the brain of Rust analyzer. It relies on the `salsa`
-//! crate, which provides and incremental on-deman database of facts.
+//! crate, which provides and incremental on-demand database of facts.
 
 extern crate fst;
 extern crate ra_editor;
@@ -20,7 +20,7 @@ pub mod mock_analysis;
 
 use std::{fmt, sync::Arc};
 
-use ra_syntax::{AtomEdit, File, TextRange, TextUnit};
+use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit};
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
 
@@ -128,13 +128,13 @@ pub struct FilePosition {
 #[derive(Debug)]
 pub struct SourceChange {
     pub label: String,
-    pub source_file_edits: Vec<SourceFileEdit>,
+    pub source_file_edits: Vec<SourceFileNodeEdit>,
     pub file_system_edits: Vec<FileSystemEdit>,
     pub cursor_position: Option<FilePosition>,
 }
 
 #[derive(Debug)]
-pub struct SourceFileEdit {
+pub struct SourceFileNodeEdit {
     pub file_id: FileId,
     pub edits: Vec<AtomEdit>,
 }
@@ -204,16 +204,16 @@ pub struct Analysis {
 }
 
 impl Analysis {
-    pub fn file_syntax(&self, file_id: FileId) -> File {
+    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
         self.imp.file_syntax(file_id).clone()
     }
     pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
         self.imp.file_line_index(file_id)
     }
-    pub fn extend_selection(&self, file: &File, range: TextRange) -> TextRange {
+    pub fn extend_selection(&self, file: &SourceFileNode, range: TextRange) -> TextRange {
         ra_editor::extend_selection(file, range).unwrap_or(range)
     }
-    pub fn matching_brace(&self, file: &File, offset: TextUnit) -> Option<TextUnit> {
+    pub fn matching_brace(&self, file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
         ra_editor::matching_brace(file, offset)
     }
     pub fn syntax_tree(&self, file_id: FileId) -> String {
@@ -258,6 +258,13 @@ impl Analysis {
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
         Ok(self.imp.find_all_refs(position))
     }
+    pub fn doc_comment_for(
+        &self,
+        file_id: FileId,
+        symbol: FileSymbol,
+    ) -> Cancelable<Option<String>> {
+        self.imp.doc_comment_for(file_id, symbol)
+    }
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp.parent_module(position)
     }
@@ -302,7 +309,7 @@ pub struct LibraryData {
 impl LibraryData {
     pub fn prepare(files: Vec<(FileId, String)>, file_resolver: Arc<FileResolver>) -> LibraryData {
         let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, text)| {
-            let file = File::parse(text);
+            let file = SourceFileNode::parse(text);
             (*file_id, file)
         }));
         LibraryData {
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index b57ad5d33..3a0667ecd 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -6,7 +6,7 @@ use std::{
 use fst::{self, Streamer};
 use ra_editor::{file_symbols, FileSymbol};
 use ra_syntax::{
-    File,
+    SourceFileNode,
     SyntaxKind::{self, *},
 };
 use rayon::prelude::*;
@@ -34,7 +34,9 @@ impl Hash for SymbolIndex {
 }
 
 impl SymbolIndex {
-    pub(crate) fn for_files(files: impl ParallelIterator<Item = (FileId, File)>) -> SymbolIndex {
+    pub(crate) fn for_files(
+        files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
+    ) -> SymbolIndex {
         let mut symbols = files
             .flat_map(|(file_id, file)| {
                 file_symbols(&file)
@@ -51,7 +53,7 @@ impl SymbolIndex {
         SymbolIndex { symbols, map }
     }
 
-    pub(crate) fn for_file(file_id: FileId, file: File) -> SymbolIndex {
+    pub(crate) fn for_file(file_id: FileId, file: SourceFileNode) -> SymbolIndex {
         SymbolIndex::for_files(rayon::iter::once((file_id, file)))
     }
 }
diff --git a/crates/ra_analysis/src/syntax_ptr.rs b/crates/ra_analysis/src/syntax_ptr.rs
index 4afb1fc93..194b94584 100644
--- a/crates/ra_analysis/src/syntax_ptr.rs
+++ b/crates/ra_analysis/src/syntax_ptr.rs
@@ -1,4 +1,4 @@
-use ra_syntax::{File, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
+use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
 
 use crate::db::SyntaxDatabase;
 use crate::FileId;
@@ -43,7 +43,7 @@ impl LocalSyntaxPtr {
         }
     }
 
-    pub(crate) fn resolve(self, file: &File) -> SyntaxNode {
+    pub(crate) fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
         let mut curr = file.syntax();
         loop {
             if curr.range() == self.range && curr.kind() == self.kind {
@@ -62,12 +62,17 @@ impl LocalSyntaxPtr {
             local: self,
         }
     }
+
+    // Seems unfortunate to expose
+    pub(crate) fn range(self) -> TextRange {
+        self.range
+    }
 }
 
 #[test]
 fn test_local_syntax_ptr() {
     use ra_syntax::{ast, AstNode};
-    let file = File::parse("struct Foo { f: u32, }");
+    let file = SourceFileNode::parse("struct Foo { f: u32, }");
     let field = file
         .syntax()
         .descendants()
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index c605d34f0..719c166b5 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -452,3 +452,44 @@ fn test_complete_crate_path() {
         &completions,
     );
 }
+
+#[test]
+fn test_complete_crate_path_with_braces() {
+    let (analysis, position) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo;
+        struct Spam;
+        //- /foo.rs
+        use crate::{Sp<|>};
+    ",
+    );
+    let completions = analysis.completions(position).unwrap().unwrap();
+    assert_eq_dbg(
+        r#"[CompletionItem { label: "foo", lookup: None, snippet: None },
+            CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
+        &completions,
+    );
+}
+
+#[test]
+fn test_complete_crate_path_in_nested_tree() {
+    let (analysis, position) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo;
+        pub mod bar {
+            pub mod baz {
+                pub struct Spam;
+            }
+        }
+        //- /foo.rs
+        use crate::{bar::{baz::Sp<|>}};
+    ",
+    );
+    let completions = analysis.completions(position).unwrap().unwrap();
+    assert_eq_dbg(
+        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
+        &completions,
+    );
+}
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 239d846b3..5ca86df4d 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -11,7 +11,7 @@ use std::{fs, io::Read, path::Path, time::Instant};
 use clap::{App, Arg, SubCommand};
 use join_to_string::join;
 use ra_editor::{extend_selection, file_structure, syntax_tree};
-use ra_syntax::{File, TextRange};
+use ra_syntax::{SourceFileNode, TextRange};
 use tools::collect_tests;
 
 type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -79,9 +79,9 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn file() -> Result<File> {
+fn file() -> Result<SourceFileNode> {
     let text = read_stdin()?;
-    Ok(File::parse(&text))
+    Ok(SourceFileNode::parse(&text))
 }
 
 fn read_stdin() -> Result<String> {
@@ -100,12 +100,12 @@ fn render_test(file: &Path, line: usize) -> Result<(String, String)> {
         None => bail!("No test found at line {} at {}", line, file.display()),
         Some((_start_line, test)) => test,
     };
-    let file = File::parse(&test.text);
+    let file = SourceFileNode::parse(&test.text);
     let tree = syntax_tree(&file);
     Ok((test.text, tree))
 }
 
-fn selections(file: &File, start: u32, end: u32) -> String {
+fn selections(file: &SourceFileNode, start: u32, end: u32) -> String {
     let mut ranges = Vec::new();
     let mut cur = Some(TextRange::from_to((start - 1).into(), (end - 1).into()));
     while let Some(r) = cur {
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index ef6df0d53..0139b19d3 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -3,7 +3,7 @@ use join_to_string::join;
 use ra_syntax::{
     algo::{find_covering_node, find_leaf_at_offset},
     ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
-    Direction, File,
+    Direction, SourceFileNode,
     SyntaxKind::{COMMA, WHITESPACE},
     SyntaxNodeRef, TextRange, TextUnit,
 };
@@ -16,7 +16,10 @@ pub struct LocalEdit {
     pub cursor_position: Option<TextUnit>,
 }
 
-pub fn flip_comma<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() -> LocalEdit + 'a> {
+pub fn flip_comma<'a>(
+    file: &'a SourceFileNode,
+    offset: TextUnit,
+) -> Option<impl FnOnce() -> LocalEdit + 'a> {
     let syntax = file.syntax();
 
     let comma = find_leaf_at_offset(syntax, offset).find(|leaf| leaf.kind() == COMMA)?;
@@ -33,7 +36,10 @@ pub fn flip_comma<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce()
     })
 }
 
-pub fn add_derive<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() -> LocalEdit + 'a> {
+pub fn add_derive<'a>(
+    file: &'a SourceFileNode,
+    offset: TextUnit,
+) -> Option<impl FnOnce() -> LocalEdit + 'a> {
     let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
     Some(move || {
         let derive_attr = nominal
@@ -58,7 +64,10 @@ pub fn add_derive<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce()
     })
 }
 
-pub fn add_impl<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() -> LocalEdit + 'a> {
+pub fn add_impl<'a>(
+    file: &'a SourceFileNode,
+    offset: TextUnit,
+) -> Option<impl FnOnce() -> LocalEdit + 'a> {
     let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
     let name = nominal.name()?;
 
@@ -98,7 +107,7 @@ pub fn add_impl<'a>(file: &'a File, offset: TextUnit) -> Option<impl FnOnce() ->
 }
 
 pub fn introduce_variable<'a>(
-    file: &'a File,
+    file: &'a SourceFileNode,
     range: TextRange,
 ) -> Option<impl FnOnce() -> LocalEdit + 'a> {
     let node = find_covering_node(file.syntax(), range);
diff --git a/crates/ra_editor/src/extend_selection.rs b/crates/ra_editor/src/extend_selection.rs
index 9d8df25c3..8f11d5364 100644
--- a/crates/ra_editor/src/extend_selection.rs
+++ b/crates/ra_editor/src/extend_selection.rs
@@ -1,11 +1,11 @@
 use ra_syntax::{
     algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
-    Direction, File,
+    Direction, SourceFileNode,
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
 
-pub fn extend_selection(file: &File, range: TextRange) -> Option<TextRange> {
+pub fn extend_selection(file: &SourceFileNode, range: TextRange) -> Option<TextRange> {
     let syntax = file.syntax();
     extend(syntax.borrowed(), range)
 }
@@ -120,7 +120,7 @@ mod tests {
 
     fn do_check(before: &str, afters: &[&str]) {
         let (cursor, before) = extract_offset(before);
-        let file = File::parse(&before);
+        let file = SourceFileNode::parse(&before);
         let mut range = TextRange::offset_len(cursor, 0.into());
         for &after in afters {
             range = extend_selection(&file, range).unwrap();
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index 0803c8891..2a8fa3cda 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -1,7 +1,7 @@
 use rustc_hash::FxHashSet;
 
 use ra_syntax::{
-    ast, AstNode, Direction, File,
+    ast, AstNode, Direction, SourceFileNode,
     SyntaxKind::{self, *},
     SyntaxNodeRef, TextRange,
 };
@@ -18,7 +18,7 @@ pub struct Fold {
     pub kind: FoldKind,
 }
 
-pub fn folding_ranges(file: &File) -> Vec<Fold> {
+pub fn folding_ranges(file: &SourceFileNode) -> Vec<Fold> {
     let mut res = vec![];
     let mut visited_comments = FxHashSet::default();
     let mut visited_imports = FxHashSet::default();
@@ -171,7 +171,7 @@ mod tests {
 
     fn do_check(text: &str, fold_kinds: &[FoldKind]) {
         let (ranges, text) = extract_ranges(text);
-        let file = File::parse(&text);
+        let file = SourceFileNode::parse(&text);
         let folds = folding_ranges(&file);
 
         assert_eq!(
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index f92181b86..ff4e8303d 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -30,7 +30,7 @@ pub use ra_syntax::AtomEdit;
 use ra_syntax::{
     algo::find_leaf_at_offset,
     ast::{self, AstNode, NameOwner},
-    File,
+    SourceFileNode,
     Location,
     SyntaxKind::{self, *},
     SyntaxNodeRef, TextRange, TextUnit,
@@ -60,7 +60,7 @@ pub enum RunnableKind {
     Bin,
 }
 
-pub fn matching_brace(file: &File, offset: TextUnit) -> Option<TextUnit> {
+pub fn matching_brace(file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
     const BRACES: &[SyntaxKind] = &[
         L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE,
     ];
@@ -78,7 +78,7 @@ pub fn matching_brace(file: &File, offset: TextUnit) -> Option<TextUnit> {
     Some(matching_node.range().start())
 }
 
-pub fn highlight(file: &File) -> Vec<HighlightedRange> {
+pub fn highlight(file: &SourceFileNode) -> Vec<HighlightedRange> {
     let mut res = Vec::new();
     for node in file.syntax().descendants() {
         let tag = match node.kind() {
@@ -100,7 +100,7 @@ pub fn highlight(file: &File) -> Vec<HighlightedRange> {
     res
 }
 
-pub fn diagnostics(file: &File) -> Vec<Diagnostic> {
+pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
     fn location_to_range(location: Location) -> TextRange {
         match location {
             Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
@@ -117,11 +117,11 @@ pub fn diagnostics(file: &File) -> Vec<Diagnostic> {
         .collect()
 }
 
-pub fn syntax_tree(file: &File) -> String {
+pub fn syntax_tree(file: &SourceFileNode) -> String {
     ::ra_syntax::utils::dump_tree(file.syntax())
 }
 
-pub fn runnables(file: &File) -> Vec<Runnable> {
+pub fn runnables(file: &SourceFileNode) -> Vec<Runnable> {
     file.syntax()
         .descendants()
         .filter_map(ast::FnDef::cast)
@@ -163,7 +163,7 @@ mod tests {
 
     #[test]
     fn test_highlighting() {
-        let file = File::parse(
+        let file = SourceFileNode::parse(
             r#"
 // comment
 fn main() {}
@@ -184,7 +184,7 @@ fn main() {}
 
     #[test]
     fn test_runnables() {
-        let file = File::parse(
+        let file = SourceFileNode::parse(
             r#"
 fn main() {}
 
@@ -209,7 +209,7 @@ fn test_foo() {}
     fn test_matching_brace() {
         fn do_check(before: &str, after: &str) {
             let (pos, before) = extract_offset(before);
-            let file = File::parse(&before);
+            let file = SourceFileNode::parse(&before);
             let new_pos = match matching_brace(&file, pos) {
                 None => pos,
                 Some(pos) => pos,
diff --git a/crates/ra_editor/src/line_index.rs b/crates/ra_editor/src/line_index.rs
index 9abbb0d09..aab7e4081 100644
--- a/crates/ra_editor/src/line_index.rs
+++ b/crates/ra_editor/src/line_index.rs
@@ -1,43 +1,124 @@
 use crate::TextUnit;
+use rustc_hash::FxHashMap;
 use superslice::Ext;
 
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LineIndex {
     newlines: Vec<TextUnit>,
+    utf16_lines: FxHashMap<u32, Vec<Utf16Char>>,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct LineCol {
     pub line: u32,
-    pub col: TextUnit,
+    pub col_utf16: u32,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+struct Utf16Char {
+    start: TextUnit,
+    end: TextUnit,
+}
+
+impl Utf16Char {
+    fn len(&self) -> TextUnit {
+        self.end - self.start
+    }
 }
 
 impl LineIndex {
     pub fn new(text: &str) -> LineIndex {
+        let mut utf16_lines = FxHashMap::default();
+        let mut utf16_chars = Vec::new();
+
         let mut newlines = vec![0.into()];
-        let mut curr = 0.into();
+        let mut curr_row = 0.into();
+        let mut curr_col = 0.into();
+        let mut line = 0;
         for c in text.chars() {
-            curr += TextUnit::of_char(c);
+            curr_row += TextUnit::of_char(c);
             if c == '\n' {
-                newlines.push(curr);
+                newlines.push(curr_row);
+
+                // Save any utf-16 characters seen in the previous line
+                if utf16_chars.len() > 0 {
+                    utf16_lines.insert(line, utf16_chars);
+                    utf16_chars = Vec::new();
+                }
+
+                // Prepare for processing the next line
+                curr_col = 0.into();
+                line += 1;
+                continue;
             }
+
+            let char_len = TextUnit::of_char(c);
+            if char_len.to_usize() > 1 {
+                utf16_chars.push(Utf16Char {
+                    start: curr_col,
+                    end: curr_col + char_len,
+                });
+            }
+
+            curr_col += char_len;
+        }
+        LineIndex {
+            newlines,
+            utf16_lines,
         }
-        LineIndex { newlines }
     }
 
     pub fn line_col(&self, offset: TextUnit) -> LineCol {
         let line = self.newlines.upper_bound(&offset) - 1;
         let line_start_offset = self.newlines[line];
         let col = offset - line_start_offset;
+
         LineCol {
             line: line as u32,
-            col,
+            col_utf16: self.utf8_to_utf16_col(line as u32, col) as u32,
         }
     }
 
     pub fn offset(&self, line_col: LineCol) -> TextUnit {
         //TODO: return Result
-        self.newlines[line_col.line as usize] + line_col.col
+        let col = self.utf16_to_utf8_col(line_col.line, line_col.col_utf16);
+        self.newlines[line_col.line as usize] + col
+    }
+
+    fn utf8_to_utf16_col(&self, line: u32, mut col: TextUnit) -> usize {
+        if let Some(utf16_chars) = self.utf16_lines.get(&line) {
+            let mut correction = TextUnit::from_usize(0);
+            for c in utf16_chars {
+                if col >= c.end {
+                    correction += c.len() - TextUnit::from_usize(1);
+                } else {
+                    // From here on, all utf16 characters come *after* the character we are mapping,
+                    // so we don't need to take them into account
+                    break;
+                }
+            }
+
+            col -= correction;
+        }
+
+        col.to_usize()
+    }
+
+    fn utf16_to_utf8_col(&self, line: u32, col: u32) -> TextUnit {
+        let mut col: TextUnit = col.into();
+        if let Some(utf16_chars) = self.utf16_lines.get(&line) {
+            for c in utf16_chars {
+                if col >= c.start {
+                    col += c.len() - TextUnit::from_usize(1);
+                } else {
+                    // From here on, all utf16 characters come *after* the character we are mapping,
+                    // so we don't need to take them into account
+                    break;
+                }
+            }
+        }
+
+        col
     }
 }
 
@@ -49,63 +130,63 @@ fn test_line_index() {
         index.line_col(0.into()),
         LineCol {
             line: 0,
-            col: 0.into()
+            col_utf16: 0
         }
     );
     assert_eq!(
         index.line_col(1.into()),
         LineCol {
             line: 0,
-            col: 1.into()
+            col_utf16: 1
         }
     );
     assert_eq!(
         index.line_col(5.into()),
         LineCol {
             line: 0,
-            col: 5.into()
+            col_utf16: 5
         }
     );
     assert_eq!(
         index.line_col(6.into()),
         LineCol {
             line: 1,
-            col: 0.into()
+            col_utf16: 0
         }
     );
     assert_eq!(
         index.line_col(7.into()),
         LineCol {
             line: 1,
-            col: 1.into()
+            col_utf16: 1
         }
     );
     assert_eq!(
         index.line_col(8.into()),
         LineCol {
             line: 1,
-            col: 2.into()
+            col_utf16: 2
         }
     );
     assert_eq!(
         index.line_col(10.into()),
         LineCol {
             line: 1,
-            col: 4.into()
+            col_utf16: 4
         }
     );
     assert_eq!(
         index.line_col(11.into()),
         LineCol {
             line: 1,
-            col: 5.into()
+            col_utf16: 5
         }
     );
     assert_eq!(
         index.line_col(12.into()),
         LineCol {
             line: 1,
-            col: 6.into()
+            col_utf16: 6
         }
     );
 
@@ -115,35 +196,129 @@ fn test_line_index() {
         index.line_col(0.into()),
         LineCol {
             line: 0,
-            col: 0.into()
+            col_utf16: 0
         }
     );
     assert_eq!(
         index.line_col(1.into()),
         LineCol {
             line: 1,
-            col: 0.into()
+            col_utf16: 0
         }
     );
     assert_eq!(
         index.line_col(2.into()),
         LineCol {
             line: 1,
-            col: 1.into()
+            col_utf16: 1
         }
     );
     assert_eq!(
         index.line_col(6.into()),
         LineCol {
             line: 1,
-            col: 5.into()
+            col_utf16: 5
         }
     );
     assert_eq!(
         index.line_col(7.into()),
         LineCol {
             line: 2,
-            col: 0.into()
+            col_utf16: 0
         }
     );
 }
+
+#[cfg(test)]
+mod test_utf8_utf16_conv {
+    use super::*;
+
+    #[test]
+    fn test_char_len() {
+        assert_eq!('メ'.len_utf8(), 3);
+        assert_eq!('メ'.len_utf16(), 1);
+    }
+
+    #[test]
+    fn test_empty_index() {
+        let col_index = LineIndex::new(
+            "
+const C: char = 'x';
+",
+        );
+        assert_eq!(col_index.utf16_lines.len(), 0);
+    }
+
+    #[test]
+    fn test_single_char() {
+        let col_index = LineIndex::new(
+            "
+const C: char = 'メ';
+",
+        );
+
+        assert_eq!(col_index.utf16_lines.len(), 1);
+        assert_eq!(col_index.utf16_lines[&1].len(), 1);
+        assert_eq!(
+            col_index.utf16_lines[&1][0],
+            Utf16Char {
+                start: 17.into(),
+                end: 20.into()
+            }
+        );
+
+        // UTF-8 to UTF-16, no changes
+        assert_eq!(col_index.utf8_to_utf16_col(1, 15.into()), 15);
+
+        // UTF-8 to UTF-16
+        assert_eq!(col_index.utf8_to_utf16_col(1, 22.into()), 20);
+
+        // UTF-16 to UTF-8, no changes
+        assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextUnit::from(15));
+
+        // UTF-16 to UTF-8
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextUnit::from(21));
+    }
+
+    #[test]
+    fn test_string() {
+        let col_index = LineIndex::new(
+            "
+const C: char = \"メ メ\";
+",
+        );
+
+        assert_eq!(col_index.utf16_lines.len(), 1);
+        assert_eq!(col_index.utf16_lines[&1].len(), 2);
+        assert_eq!(
+            col_index.utf16_lines[&1][0],
+            Utf16Char {
+                start: 17.into(),
+                end: 20.into()
+            }
+        );
+        assert_eq!(
+            col_index.utf16_lines[&1][1],
+            Utf16Char {
+                start: 21.into(),
+                end: 24.into()
+            }
+        );
+
+        // UTF-8 to UTF-16
+        assert_eq!(col_index.utf8_to_utf16_col(1, 15.into()), 15);
+
+        assert_eq!(col_index.utf8_to_utf16_col(1, 21.into()), 19);
+        assert_eq!(col_index.utf8_to_utf16_col(1, 25.into()), 21);
+
+        assert!(col_index.utf8_to_utf16_col(2, 15.into()) == 15);
+
+        // UTF-16 to UTF-8
+        assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextUnit::from_usize(15));
+
+        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextUnit::from_usize(20));
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextUnit::from_usize(23));
+
+        assert_eq!(col_index.utf16_to_utf8_col(2, 15), TextUnit::from_usize(15));
+    }
+}
diff --git a/crates/ra_editor/src/symbols.rs b/crates/ra_editor/src/symbols.rs
index 4e602d0e3..6d3b0514a 100644
--- a/crates/ra_editor/src/symbols.rs
+++ b/crates/ra_editor/src/symbols.rs
@@ -2,8 +2,8 @@ use crate::TextRange;
 
 use ra_syntax::{
     algo::visit::{visitor, Visitor},
-    ast::{self, NameOwner},
-    AstNode, File, SmolStr, SyntaxKind, SyntaxNodeRef, WalkEvent,
+    ast::{self, DocCommentsOwner, NameOwner},
+    AstNode, SourceFileNode, SmolStr, SyntaxKind, SyntaxNodeRef, WalkEvent,
 };
 
 #[derive(Debug, Clone)]
@@ -22,7 +22,37 @@ pub struct FileSymbol {
     pub kind: SyntaxKind,
 }
 
-pub fn file_symbols(file: &File) -> Vec<FileSymbol> {
+impl FileSymbol {
+    pub fn docs(&self, file: &SourceFileNode) -> Option<String> {
+        file.syntax()
+            .descendants()
+            .filter(|node| node.kind() == self.kind && node.range() == self.node_range)
+            .filter_map(|node: SyntaxNodeRef| {
+                fn doc_comments<'a, N: DocCommentsOwner<'a>>(node: N) -> Option<String> {
+                    let comments = node.doc_comment_text();
+                    if comments.is_empty() {
+                        None
+                    } else {
+                        Some(comments)
+                    }
+                }
+
+                visitor()
+                    .visit(doc_comments::<ast::FnDef>)
+                    .visit(doc_comments::<ast::StructDef>)
+                    .visit(doc_comments::<ast::EnumDef>)
+                    .visit(doc_comments::<ast::TraitDef>)
+                    .visit(doc_comments::<ast::Module>)
+                    .visit(doc_comments::<ast::TypeDef>)
+                    .visit(doc_comments::<ast::ConstDef>)
+                    .visit(doc_comments::<ast::StaticDef>)
+                    .accept(node)?
+            })
+            .nth(0)
+    }
+}
+
+pub fn file_symbols(file: &SourceFileNode) -> Vec<FileSymbol> {
     file.syntax().descendants().filter_map(to_symbol).collect()
 }
 
@@ -47,7 +77,7 @@ fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
         .accept(node)?
 }
 
-pub fn file_structure(file: &File) -> Vec<StructureNode> {
+pub fn file_structure(file: &SourceFileNode) -> Vec<StructureNode> {
     let mut res = Vec::new();
     let mut stack = Vec::new();
 
@@ -123,7 +153,7 @@ mod tests {
 
     #[test]
     fn test_file_structure() {
-        let file = File::parse(
+        let file = SourceFileNode::parse(
             r#"
 struct Foo {
     x: i32
diff --git a/crates/ra_editor/src/test_utils.rs b/crates/ra_editor/src/test_utils.rs
index bc3d700f6..cbeb6433b 100644
--- a/crates/ra_editor/src/test_utils.rs
+++ b/crates/ra_editor/src/test_utils.rs
@@ -1,10 +1,14 @@
 use crate::LocalEdit;
 pub use crate::_test_utils::*;
-use ra_syntax::{File, TextRange, TextUnit};
+use ra_syntax::{SourceFileNode, TextRange, TextUnit};
 
-pub fn check_action<F: Fn(&File, TextUnit) -> Option<LocalEdit>>(before: &str, after: &str, f: F) {
+pub fn check_action<F: Fn(&SourceFileNode, TextUnit) -> Option<LocalEdit>>(
+    before: &str,
+    after: &str,
+    f: F,
+) {
     let (before_cursor_pos, before) = extract_offset(before);
-    let file = File::parse(&before);
+    let file = SourceFileNode::parse(&before);
     let result = f(&file, before_cursor_pos).expect("code action is not applicable");
     let actual = result.edit.apply(&before);
     let actual_cursor_pos = match result.cursor_position {
@@ -15,13 +19,13 @@ pub fn check_action<F: Fn(&File, TextUnit) -> Option<LocalEdit>>(before: &str, a
     assert_eq_text!(after, &actual);
 }
 
-pub fn check_action_range<F: Fn(&File, TextRange) -> Option<LocalEdit>>(
+pub fn check_action_range<F: Fn(&SourceFileNode, TextRange) -> Option<LocalEdit>>(
     before: &str,
     after: &str,
     f: F,
 ) {
     let (range, before) = extract_range(before);
-    let file = File::parse(&before);
+    let file = SourceFileNode::parse(&before);
     let result = f(&file, range).expect("code action is not applicable");
     let actual = result.edit.apply(&before);
     let actual_cursor_pos = match result.cursor_position {
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 5a457d148..f894d8392 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -4,14 +4,14 @@ use ra_syntax::{
     algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
     ast,
     text_utils::{contains_offset_nonstrict, intersect},
-    AstNode, File, SyntaxKind,
+    AstNode, SourceFileNode, SyntaxKind,
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
 
 use crate::{find_node_at_offset, EditBuilder, LocalEdit};
 
-pub fn join_lines(file: &File, range: TextRange) -> LocalEdit {
+pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
     let range = if range.is_empty() {
         let syntax = file.syntax();
         let text = syntax.text().slice(range.start()..);
@@ -55,7 +55,7 @@ pub fn join_lines(file: &File, range: TextRange) -> LocalEdit {
     }
 }
 
-pub fn on_enter(file: &File, offset: TextUnit) -> Option<LocalEdit> {
+pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
     let comment = find_leaf_at_offset(file.syntax(), offset)
         .left_biased()
         .and_then(ast::Comment::cast)?;
@@ -80,7 +80,7 @@ pub fn on_enter(file: &File, offset: TextUnit) -> Option<LocalEdit> {
     })
 }
 
-fn node_indent<'a>(file: &'a File, node: SyntaxNodeRef) -> Option<&'a str> {
+fn node_indent<'a>(file: &'a SourceFileNode, node: SyntaxNodeRef) -> Option<&'a str> {
     let ws = match find_leaf_at_offset(file.syntax(), node.range().start()) {
         LeafAtOffset::Between(l, r) => {
             assert!(r == node);
@@ -100,7 +100,7 @@ fn node_indent<'a>(file: &'a File, node: SyntaxNodeRef) -> Option<&'a str> {
     Some(&text[pos..])
 }
 
-pub fn on_eq_typed(file: &File, offset: TextUnit) -> Option<LocalEdit> {
+pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
     let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
     if let_stmt.has_semi() {
         return None;
@@ -390,7 +390,7 @@ fn foo() {
 
     fn check_join_lines_sel(before: &str, after: &str) {
         let (sel, before) = extract_range(before);
-        let file = File::parse(&before);
+        let file = SourceFileNode::parse(&before);
         let result = join_lines(&file, sel);
         let actual = result.edit.apply(&before);
         assert_eq_text!(after, &actual);
@@ -469,7 +469,7 @@ pub fn handle_find_matching_brace() {
     fn test_on_eq_typed() {
         fn do_check(before: &str, after: &str) {
             let (offset, before) = extract_offset(before);
-            let file = File::parse(&before);
+            let file = SourceFileNode::parse(&before);
             let result = on_eq_typed(&file, offset).unwrap();
             let actual = result.edit.apply(&before);
             assert_eq_text!(after, &actual);
@@ -513,7 +513,7 @@ fn foo() {
     fn test_on_enter() {
         fn apply_on_enter(before: &str) -> Option<String> {
             let (offset, before) = extract_offset(before);
-            let file = File::parse(&before);
+            let file = SourceFileNode::parse(&before);
             let result = on_enter(&file, offset)?;
             let actual = result.edit.apply(&before);
             let actual = add_cursor(&actual, result.cursor_position.unwrap());
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index f29dafc17..79d86f9b2 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -14,7 +14,7 @@ serde = "1.0.71"
 serde_derive = "1.0.71"
 drop_bomb = "0.1.0"
 crossbeam-channel = "0.2.4"
-flexi_logger = "0.9.1"
+flexi_logger = "0.10.0"
 log = "0.4.3"
 url_serde = "0.2.0"
 languageserver-types = "0.51.0"
diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs
index 0d02c8073..bcf857fce 100644
--- a/crates/ra_lsp_server/src/caps.rs
+++ b/crates/ra_lsp_server/src/caps.rs
@@ -16,7 +16,7 @@ pub fn server_capabilities() -> ServerCapabilities {
                 save: None,
             },
         )),
-        hover_provider: None,
+        hover_provider: Some(true),
         completion_provider: Some(CompletionOptions {
             resolve_provider: None,
             trigger_characters: None,
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index fa04f4b00..5d5a0c55e 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -2,7 +2,7 @@ use languageserver_types::{
     Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
     TextDocumentItem, TextDocumentPositionParams, TextEdit, Url, VersionedTextDocumentIdentifier,
 };
-use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition};
+use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileNodeEdit, FilePosition};
 use ra_editor::{AtomEdit, Edit, LineCol, LineIndex};
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 
@@ -49,10 +49,9 @@ impl ConvWith for Position {
     type Output = TextUnit;
 
     fn conv_with(self, line_index: &LineIndex) -> TextUnit {
-        // TODO: UTF-16
         let line_col = LineCol {
             line: self.line as u32,
-            col: (self.character as u32).into(),
+            col_utf16: self.character as u32,
         };
         line_index.offset(line_col)
     }
@@ -64,8 +63,10 @@ impl ConvWith for TextUnit {
 
     fn conv_with(self, line_index: &LineIndex) -> Position {
         let line_col = line_index.line_col(self);
-        // TODO: UTF-16
-        Position::new(u64::from(line_col.line), u64::from(u32::from(line_col.col)))
+        Position::new(
+            u64::from(line_col.line),
+            u64::from(u32::from(line_col.col_utf16)),
+        )
     }
 }
 
@@ -203,8 +204,10 @@ impl TryConvWith for SourceChange {
                     .map(|it| it.edits.as_slice())
                     .unwrap_or(&[]);
                 let line_col = translate_offset_with_edit(&*line_index, pos.offset, edits);
-                let position =
-                    Position::new(u64::from(line_col.line), u64::from(u32::from(line_col.col)));
+                let position = Position::new(
+                    u64::from(line_col.line),
+                    u64::from(u32::from(line_col.col_utf16)),
+                );
                 Some(TextDocumentPositionParams {
                     text_document: TextDocumentIdentifier::new(pos.file_id.try_conv_with(world)?),
                     position,
@@ -247,17 +250,17 @@ fn translate_offset_with_edit(
     if in_edit_line_col.line == 0 {
         LineCol {
             line: edit_line_col.line,
-            col: edit_line_col.col + in_edit_line_col.col,
+            col_utf16: edit_line_col.col_utf16 + in_edit_line_col.col_utf16,
         }
     } else {
         LineCol {
             line: edit_line_col.line + in_edit_line_col.line,
-            col: in_edit_line_col.col,
+            col_utf16: in_edit_line_col.col_utf16,
         }
     }
 }
 
-impl TryConvWith for SourceFileEdit {
+impl TryConvWith for SourceFileNodeEdit {
     type Ctx = ServerWorld;
     type Output = TextDocumentEdit;
     fn try_conv_with(self, world: &ServerWorld) -> Result<TextDocumentEdit> {
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index c07eb0140..26bcddd8e 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -2,10 +2,14 @@
 extern crate log;
 #[macro_use]
 extern crate failure;
+#[macro_use]
+extern crate serde_derive;
+extern crate serde;
 extern crate flexi_logger;
 extern crate gen_lsp_server;
 extern crate ra_lsp_server;
 
+use serde::Deserialize;
 use flexi_logger::{Duplicate, Logger};
 use gen_lsp_server::{run_server, stdio_transport};
 use ra_lsp_server::Result;
@@ -30,6 +34,12 @@ fn main() -> Result<()> {
     }
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct InitializationOptions {
+    publish_decorations: bool,
+}
+
 fn main_inner() -> Result<()> {
     let (receiver, sender, threads) = stdio_transport();
     let cwd = ::std::env::current_dir()?;
@@ -42,7 +52,12 @@ fn main_inner() -> Result<()> {
                 .root_uri
                 .and_then(|it| it.to_file_path().ok())
                 .unwrap_or(cwd);
-            ra_lsp_server::main_loop(false, root, r, s)
+            let publish_decorations = params
+                .initialization_options
+                .and_then(|v| InitializationOptions::deserialize(v).ok())
+                .map(|it| it.publish_decorations)
+                == Some(true);
+            ra_lsp_server::main_loop(false, root, publish_decorations, r, s)
         },
     )?;
     info!("shutting down IO...");
@@ -50,3 +65,27 @@ fn main_inner() -> Result<()> {
     info!("... IO is down");
     Ok(())
 }
+
+/*
+                    (let ((backend (eglot-xref-backend)))
+                      (mapcar
+                       (lambda (xref)
+                         (let ((loc (xref-item-location xref)))
+                           (propertize
+                            (concat
+                             (when (xref-file-location-p loc)
+                               (with-slots (file line column) loc
+                                 (format "%s:%s:%s:"
+                                         (propertize (file-relative-name file)
+                                                     'face 'compilation-info)
+                                         (propertize (format "%s" line)
+                                                     'face 'compilation-line
+                                                     )
+                                         column)))
+                             (xref-item-summary xref))
+                            'xref xref)))
+                       (xref-backend-apropos backend "Analysis"))
+                      )
+
+
+*/
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 5314a333e..c872b0dc4 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -4,9 +4,9 @@ use gen_lsp_server::ErrorCode;
 use languageserver_types::{
     CodeActionResponse, Command, CompletionItem, CompletionItemKind, Diagnostic,
     DiagnosticSeverity, DocumentSymbol, Documentation, FoldingRange, FoldingRangeKind,
-    FoldingRangeParams, InsertTextFormat, Location, MarkupContent, MarkupKind, Position,
+    FoldingRangeParams, InsertTextFormat, Location, MarkupContent, MarkupKind, MarkedString, Position,
     PrepareRenameResponse, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit,
-    WorkspaceEdit, ParameterInformation, SignatureInformation,
+    WorkspaceEdit, ParameterInformation, SignatureInformation, Hover, HoverContents,
 };
 use ra_analysis::{FileId, FoldKind, Query, RunnableKind, FilePosition};
 use ra_syntax::text_utils::contains_offset_nonstrict;
@@ -478,6 +478,30 @@ pub fn handle_signature_help(
     }
 }
 
+pub fn handle_hover(
+    world: ServerWorld,
+    params: req::TextDocumentPositionParams,
+) -> Result<Option<Hover>> {
+    let position = params.try_conv_with(&world)?;
+    let line_index = world.analysis().file_line_index(position.file_id);
+
+    for (file_id, symbol) in world.analysis().approximately_resolve_symbol(position)? {
+        let range = symbol.node_range.conv_with(&line_index);
+        let comment = world.analysis.doc_comment_for(file_id, symbol)?;
+
+        if comment.is_some() {
+            let contents = HoverContents::Scalar(MarkedString::String(comment.unwrap()));
+
+            return Ok(Some(Hover {
+                contents,
+                range: Some(range),
+            }));
+        }
+    }
+
+    Ok(None)
+}
+
 pub fn handle_prepare_rename(
     world: ServerWorld,
     params: req::TextDocumentPositionParams,
diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop/mod.rs
index 229d1b0f7..78d93741a 100644
--- a/crates/ra_lsp_server/src/main_loop/mod.rs
+++ b/crates/ra_lsp_server/src/main_loop/mod.rs
@@ -48,6 +48,7 @@ enum Task {
 pub fn main_loop(
     internal_mode: bool,
     root: PathBuf,
+    publish_decorations: bool,
     msg_receiver: &Receiver<RawMessage>,
     msg_sender: &Sender<RawMessage>,
 ) -> Result<()> {
@@ -67,6 +68,7 @@ pub fn main_loop(
     let mut subs = Subscriptions::new();
     let main_res = main_loop_inner(
         internal_mode,
+        publish_decorations,
         root,
         &pool,
         msg_sender,
@@ -99,6 +101,7 @@ pub fn main_loop(
 
 fn main_loop_inner(
     internal_mode: bool,
+    publish_decorations: bool,
     ws_root: PathBuf,
     pool: &ThreadPool,
     msg_sender: &Sender<RawMessage>,
@@ -210,6 +213,7 @@ fn main_loop_inner(
             update_file_notifications_on_threadpool(
                 pool,
                 state.snapshot(),
+                publish_decorations,
                 task_sender.clone(),
                 subs.subscriptions(),
             )
@@ -259,6 +263,7 @@ fn on_request(
         .on::<req::CodeActionRequest>(handlers::handle_code_action)?
         .on::<req::FoldingRangeRequest>(handlers::handle_folding_range)?
         .on::<req::SignatureHelpRequest>(handlers::handle_signature_help)?
+        .on::<req::HoverRequest>(handlers::handle_hover)?
         .on::<req::PrepareRenameRequest>(handlers::handle_prepare_rename)?
         .on::<req::Rename>(handlers::handle_rename)?
         .on::<req::References>(handlers::handle_references)?
@@ -415,6 +420,7 @@ impl<'a> PoolDispatcher<'a> {
 fn update_file_notifications_on_threadpool(
     pool: &ThreadPool,
     world: ServerWorld,
+    publish_decorations: bool,
     sender: Sender<Task>,
     subscriptions: Vec<FileId>,
 ) {
@@ -431,15 +437,17 @@ fn update_file_notifications_on_threadpool(
                     sender.send(Task::Notify(not));
                 }
             }
-            match handlers::publish_decorations(&world, file_id) {
-                Err(e) => {
-                    if !is_canceled(&e) {
-                        error!("failed to compute decorations: {:?}", e);
+            if publish_decorations {
+                match handlers::publish_decorations(&world, file_id) {
+                    Err(e) => {
+                        if !is_canceled(&e) {
+                            error!("failed to compute decorations: {:?}", e);
+                        }
+                    }
+                    Ok(params) => {
+                        let not = RawNotification::new::<req::PublishDecorations>(&params);
+                        sender.send(Task::Notify(not))
                     }
-                }
-                Ok(params) => {
-                    let not = RawNotification::new::<req::PublishDecorations>(&params);
-                    sender.send(Task::Notify(not))
                 }
             }
         }
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/ra_lsp_server/tests/heavy_tests/support.rs
index b90d21135..88d379bfa 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/support.rs
@@ -55,7 +55,7 @@ impl Server {
             "test server",
             128,
             move |mut msg_receiver, mut msg_sender| {
-                main_loop(true, path, &mut msg_receiver, &mut msg_sender).unwrap()
+                main_loop(true, path, true, &mut msg_receiver, &mut msg_sender).unwrap()
             },
         );
         let res = Server {
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 97d259570..54ee72386 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -8,6 +8,7 @@ description = "Comment and whitespace preserving parser for the Rust langauge"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 
 [dependencies]
+arrayvec = "0.4.7"
 unicode-xid = "0.1.0"
 itertools = "0.7.8"
 drop_bomb = "0.1.4"
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 420d9090c..bf056131e 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -9,6 +9,8 @@
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 
+use std::hash::{Hash, Hasher};
+
 use crate::{
     ast,
     SyntaxNode, SyntaxNodeRef, AstNode,
@@ -17,12 +19,20 @@ use crate::{
 };
 
 // ArgList
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ArgListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ArgList<'a> = ArgListNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArgListNode<R1>> for ArgListNode<R2> {
+    fn eq(&self, other: &ArgListNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ArgListNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArgListNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ArgList<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -50,12 +60,20 @@ impl<'a> ArgList<'a> {
 }
 
 // ArrayExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ArrayExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ArrayExpr<'a> = ArrayExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayExprNode<R1>> for ArrayExprNode<R2> {
+    fn eq(&self, other: &ArrayExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ArrayExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArrayExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ArrayExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -79,12 +97,20 @@ impl<R: TreeRoot<RaTypes>> ArrayExprNode<R> {
 impl<'a> ArrayExpr<'a> {}
 
 // ArrayType
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ArrayTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ArrayType<'a> = ArrayTypeNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayTypeNode<R1>> for ArrayTypeNode<R2> {
+    fn eq(&self, other: &ArrayTypeNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ArrayTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ArrayTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ArrayType<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -108,12 +134,20 @@ impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> {
 impl<'a> ArrayType<'a> {}
 
 // Attr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct AttrNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type Attr<'a> = AttrNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<AttrNode<R1>> for AttrNode<R2> {
+    fn eq(&self, other: &AttrNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for AttrNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for AttrNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for Attr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -141,12 +175,20 @@ impl<'a> Attr<'a> {
 }
 
 // BinExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct BinExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type BinExpr<'a> = BinExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BinExprNode<R1>> for BinExprNode<R2> {
+    fn eq(&self, other: &BinExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BinExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BinExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for BinExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -170,12 +212,20 @@ impl<R: TreeRoot<RaTypes>> BinExprNode<R> {
 impl<'a> BinExpr<'a> {}
 
 // BindPat
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct BindPatNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type BindPat<'a> = BindPatNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BindPatNode<R1>> for BindPatNode<R2> {
+    fn eq(&self, other: &BindPatNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BindPatNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BindPatNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for BindPat<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -200,12 +250,20 @@ impl<'a> ast::NameOwner<'a> for BindPat<'a> {}
 impl<'a> BindPat<'a> {}
 
 // Block
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct BlockNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type Block<'a> = BlockNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockNode<R1>> for BlockNode<R2> {
+    fn eq(&self, other: &BlockNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BlockNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BlockNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for Block<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -237,12 +295,20 @@ impl<'a> Block<'a> {
 }
 
 // BlockExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct BlockExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type BlockExpr<'a> = BlockExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockExprNode<R1>> for BlockExprNode<R2> {
+    fn eq(&self, other: &BlockExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BlockExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BlockExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for BlockExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -270,12 +336,20 @@ impl<'a> BlockExpr<'a> {
 }
 
 // BreakExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct BreakExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type BreakExpr<'a> = BreakExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BreakExprNode<R1>> for BreakExprNode<R2> {
+    fn eq(&self, other: &BreakExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for BreakExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for BreakExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for BreakExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -298,13 +372,95 @@ impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
 
 impl<'a> BreakExpr<'a> {}
 
+// Byte
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type Byte<'a> = ByteNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteNode<R1>> for ByteNode<R2> {
+    fn eq(&self, other: &ByteNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for Byte<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BYTE => Some(Byte { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> ByteNode<R> {
+    pub fn borrowed(&self) -> Byte {
+        ByteNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ByteNode {
+        ByteNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> Byte<'a> {}
+
+// ByteString
+#[derive(Debug, Clone, Copy,)]
+pub struct ByteStringNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type ByteString<'a> = ByteStringNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteStringNode<R1>> for ByteStringNode<R2> {
+    fn eq(&self, other: &ByteStringNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ByteStringNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ByteStringNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for ByteString<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            BYTE_STRING => Some(ByteString { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> ByteStringNode<R> {
+    pub fn borrowed(&self) -> ByteString {
+        ByteStringNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ByteStringNode {
+        ByteStringNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> ByteString<'a> {}
+
 // CallExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type CallExpr<'a> = CallExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CallExprNode<R1>> for CallExprNode<R2> {
+    fn eq(&self, other: &CallExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for CallExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CallExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for CallExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -333,12 +489,20 @@ impl<'a> CallExpr<'a> {
 }
 
 // CastExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct CastExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type CastExpr<'a> = CastExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CastExprNode<R1>> for CastExprNode<R2> {
+    fn eq(&self, other: &CastExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for CastExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CastExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for CastExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -362,12 +526,20 @@ impl<R: TreeRoot<RaTypes>> CastExprNode<R> {
 impl<'a> CastExpr<'a> {}
 
 // Char
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct CharNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type Char<'a> = CharNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CharNode<R1>> for CharNode<R2> {
+    fn eq(&self, other: &CharNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for CharNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CharNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for Char<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -391,12 +563,20 @@ impl<R: TreeRoot<RaTypes>> CharNode<R> {
 impl<'a> Char<'a> {}
 
 // Comment
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct CommentNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type Comment<'a> = CommentNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CommentNode<R1>> for CommentNode<R2> {
+    fn eq(&self, other: &CommentNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for CommentNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for CommentNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for Comment<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -420,12 +600,20 @@ impl<R: TreeRoot<RaTypes>> CommentNode<R> {
 impl<'a> Comment<'a> {}
 
 // Condition
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ConditionNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type Condition<'a> = ConditionNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConditionNode<R1>> for ConditionNode<R2> {
+    fn eq(&self, other: &ConditionNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ConditionNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ConditionNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for Condition<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -457,12 +645,20 @@ impl<'a> Condition<'a> {
 }
 
 // ConstDef
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ConstDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ConstDef<'a> = ConstDefNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ConstDefNode<R1>> for ConstDefNode<R2> {
+    fn eq(&self, other: &ConstDefNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ConstDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ConstDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ConstDef<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -486,15 +682,24 @@ impl<R: TreeRoot<RaTypes>> ConstDefNode<R> {
 impl<'a> ast::NameOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {}
+impl<'a> ast::DocCommentsOwner<'a> for ConstDef<'a> {}
 impl<'a> ConstDef<'a> {}
 
 // ContinueExpr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ContinueExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ContinueExpr<'a> = ContinueExprNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ContinueExprNode<R1>> for ContinueExprNode<R2> {
+    fn eq(&self, other: &ContinueExprNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ContinueExprNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ContinueExprNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ContinueExpr<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -518,12 +723,20 @@ impl<R: TreeRoot<RaTypes>> ContinueExprNode<R> {
 impl<'a> ContinueExpr<'a> {}
 
 // DynTraitType
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct DynTraitTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type DynTraitType<'a> = DynTraitTypeNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<DynTraitTypeNode<R1>> for DynTraitTypeNode<R2> {
+    fn eq(&self, other: &DynTraitTypeNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for DynTraitTypeNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for DynTraitTypeNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for DynTraitType<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -547,12 +760,20 @@ impl<R: TreeRoot<RaTypes>> DynTraitTypeNode<R> {
 impl<'a> DynTraitType<'a> {}
 
 // EnumDef
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct EnumDefNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type EnumDef<'a> = EnumDefNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<EnumDefNode<R1>> for EnumDefNode<R2> {
+    fn eq(&self, other: &EnumDefNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for EnumDefNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for EnumDefNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for EnumDef<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -576,10 +797,11 @@ impl<R: TreeRoot<RaTypes>> EnumDefNode<R> {
 impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
+impl<'a> ast::DocCommentsOwner<'a> for EnumDef<'a> {}
 impl<'a> EnumDef<'a> {}
 
 // Expr
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Expr<'a> {
     TupleExpr(TupleExpr<'a>),
     ArrayExpr(ArrayExpr<'a>),
@@ -694,12 +916,20 @@ impl<'a> AstNode<'a> for Expr<'a> {
 impl<'a> Expr<'a> {}
 
 // ExprStmt
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ExprStmtNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ExprStmt<'a> = ExprStmtNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExprStmtNode<R1>> for ExprStmtNode<R2> {
+    fn eq(&self, other: &ExprStmtNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ExprStmtNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for ExprStmtNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
 impl<'a> AstNode<'a> for ExprStmt<'a> {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
         match syntax.kind() {
@@ -727,12 +957,20 @@ impl<'a> ExprStmt<'a> {
 }
 
 // ExternCrateItem
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy,)]
 pub struct ExternCrateItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    syntax: SyntaxNode<R>,
+    pub(crate) syntax: SyntaxNode<R>,
 }
 pub type ExternCrateItem<'a> = ExternCrateItemNode<RefRoot<'a>>;
 
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ExternCrateItemNode<R1>> for ExternCrateItemNode<R2> {
+    fn eq(&self, other: &ExternCrateItemNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for ExternCrateItemNode<R> {}