87 files changed, 2051 insertions, 918 deletions
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index c0174cdc5..11c78ced8 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -10,9 +10,10 @@ log = "0.4.5"
 relative-path = "0.4.0"
 rayon = "1.0.2"
 fst = "0.3.1"
-salsa = "0.9.0"
+salsa = "0.9.1"
 rustc-hash = "1.0"
 parking_lot = "0.7.0"
+unicase = "2.2.0"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
diff --git a/crates/ra_analysis/src/completion/complete_dot.rs b/crates/ra_analysis/src/completion/complete_dot.rs
index f24835d17..031d8b98f 100644
--- a/crates/ra_analysis/src/completion/complete_dot.rs
+++ b/crates/ra_analysis/src/completion/complete_dot.rs
@@ -73,6 +73,21 @@ mod tests {
    }
    #[test]
+    fn test_struct_field_completion_self() {
+        check_ref_completion(
+            r"
+            struct A { the_field: u32 }
+            impl A {
+                fn foo(self) {
+                    self.<|>
+                }
+            }
+            ",
+            r#"the_field"#,
+        );
+    }
+    #[test]
    fn test_no_struct_field_completion_for_method_call() {
        check_ref_completion(
            r"
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index d7740f0c4..5422a400b 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -105,6 +105,7 @@ salsa::database_storage! {
            fn type_for_field() for hir::db::TypeForFieldQuery;
            fn struct_data() for hir::db::StructDataQuery;
            fn enum_data() for hir::db::EnumDataQuery;
+            fn impls_in_module() for hir::db::ImplsInModuleQuery;
        }
    }
 }
diff --git a/crates/ra_analysis/src/goto_defenition.rs b/crates/ra_analysis/src/goto_defenition.rs
new file mode 100644
index 000000000..607a25115
--- /dev/null
+++ b/crates/ra_analysis/src/goto_defenition.rs
@@ -0,0 +1,73 @@
+use ra_db::FileId;
+use ra_syntax::ast;
+use crate::db::RootDatabase;
+pub fn goto_defenition(db: &RootDatabase, position: FilePosition,
+) -> Cancelable<Option<Vec<NavigationTarget>>> {
+    let file = db.source_file(position.file_id);
+    let syntax = file.syntax();
+    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+        return Ok(Some(reference_defenition(db, position.file_id, name_ref)));
+    }
+    if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset)  {
+        return Ok(Some(name_defenition(db, position.file_idname)));
+    }
+    Ok(None)
+}
+fn reference_defenition(db: &RootDatabase, file_id: FileId, name_ref: ast::NameRef) -> Cancelable<Vec<Nav>> {
+    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
+        let mut rr = ReferenceResolution::new(name_ref.syntax().range());
+        if let Some(fn_descr) =
+            source_binder::function_from_child_node(self, position.file_id, name_ref.syntax())?
+        {
+            let scope = fn_descr.scopes(self);
+            // First try to resolve the symbol locally
+            if let Some(entry) = scope.resolve_local_name(name_ref) {
+                rr.resolves_to.push(NavigationTarget {
+                    file_id: position.file_id,
+                    name: entry.name().to_string().into(),
+                    range: entry.ptr().range(),
+                    kind: NAME,
+                    ptr: None,
+                });
+                return Ok(Some(rr));
+            };
+        }
+        // If that fails try the index based approach.
+        rr.resolves_to.extend(
+            self.index_resolve(name_ref)?
+                .into_iter()
+                .map(NavigationTarget::from_symbol),
+        );
+        return Ok(Some(rr));
+    }
+        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
+            let mut rr = ReferenceResolution::new(name.syntax().range());
+            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
+                if module.has_semi() {
+                    if let Some(child_module) =
+                        source_binder::module_from_declaration(self, position.file_id, module)?
+                    {
+                        let file_id = child_module.file_id();
+                        let name = match child_module.name() {
+                            Some(name) => name.to_string().into(),
+                            None => "".into(),
+                        };
+                        let symbol = NavigationTarget {
+                            file_id,
+                            name,
+                            range: TextRange::offset_len(0.into(), 0.into()),
+                            kind: MODULE,
+                            ptr: None,
+                        };
+                        rr.resolves_to.push(symbol);
+                        return Ok(Some(rr));
+                    }
+                }
+            }
+        }
+        Ok(None)
+}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index b812c3441..eae73c2c4 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -6,7 +6,7 @@ use hir::{
    self, FnSignatureInfo, Problem, source_binder,
 };
 use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
-use ra_editor::{self, find_node_at_offset, LocalEdit, Severity};
+use ra_editor::{self, find_node_at_offset, assists, LocalEdit, Severity};
 use ra_syntax::{
    algo::{find_covering_node, visit::{visitor, Visitor}},
    ast::{self, ArgListOwner, Expr, FnDef, NameOwner},
@@ -165,9 +165,11 @@ impl db::RootDatabase {
                };
            }
            // If that fails try the index based approach.
-            for (file_id, symbol) in self.index_resolve(name_ref)? {
+            rr.resolves_to.extend(
-                rr.add_resolution(file_id, symbol);
+                self.index_resolve(name_ref)?
-            }
+                    .into_iter()
+                    .map(NavigationTarget::from_symbol),
+            );
            return Ok(Some(rr));
        }
        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
@@ -333,19 +335,9 @@ impl db::RootDatabase {
    pub(crate) fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
        let file = self.source_file(frange.file_id);
-        let offset = frange.range.start();
+        assists::assists(&file, frange.range)
-        let actions = vec![
-            ra_editor::flip_comma(&file, offset).map(|f| f()),
-            ra_editor::add_derive(&file, offset).map(|f| f()),
-            ra_editor::add_impl(&file, offset).map(|f| f()),
-            ra_editor::make_pub_crate(&file, offset).map(|f| f()),
-            ra_editor::introduce_variable(&file, frange.range).map(|f| f()),
-        ];
-        actions
            .into_iter()
-            .filter_map(|local_edit| {
+            .map(|local_edit| SourceChange::from_local_edit(frange.file_id, local_edit))
-                Some(SourceChange::from_local_edit(frange.file_id, local_edit?))
-            })
            .collect()
    }
@@ -362,13 +354,15 @@ impl db::RootDatabase {
        // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
        let file_symbols = self.index_resolve(name_ref)?;
-        for (fn_file_id, fs) in file_symbols {
+        for symbol in file_symbols {
-            if fs.ptr.kind() == FN_DEF {
+            if symbol.ptr.kind() == FN_DEF {
-                let fn_file = self.source_file(fn_file_id);
+                let fn_file = self.source_file(symbol.file_id);
-                let fn_def = fs.ptr.resolve(&fn_file);
+                let fn_def = symbol.ptr.resolve(&fn_file);
                let fn_def = ast::FnDef::cast(fn_def.borrowed()).unwrap();
                let descr = ctry!(source_binder::function_from_source(
-                    self, fn_file_id, fn_def
+                    self,
+                    symbol.file_id,
+                    fn_def
                )?);
                if let Some(descriptor) = descr.signature_info(self) {
                    // If we have a calling expression let's find which argument we are on
@@ -440,7 +434,7 @@ impl db::RootDatabase {
            .map(|(file_id, text_range)| SourceFileEdit {
                file_id: *file_id,
                edit: {
-                    let mut builder = ra_text_edit::TextEditBuilder::new();
+                    let mut builder = ra_text_edit::TextEditBuilder::default();
                    builder.replace(*text_range, new_name.into());
                    builder.finish()
                },
@@ -448,7 +442,7 @@ impl db::RootDatabase {
            .collect::<Vec<_>>();
        Ok(res)
    }
-    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+    fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
        let name = name_ref.text();
        let mut query = Query::new(name.to_string());
        query.exact();
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 61af676b2..1e26a2889 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -237,11 +237,11 @@ pub struct NavigationTarget {
 }
 impl NavigationTarget {
-    fn from_symbol(file_id: FileId, symbol: FileSymbol) -> NavigationTarget {
+    fn from_symbol(symbol: FileSymbol) -> NavigationTarget {
        NavigationTarget {
+            file_id: symbol.file_id,
            name: symbol.name.clone(),
            kind: symbol.ptr.kind(),
-            file_id,
            range: symbol.ptr.range(),
            ptr: Some(symbol.ptr.clone()),
        }
@@ -278,11 +278,6 @@ impl ReferenceResolution {
            resolves_to: Vec::new(),
        }
    }
-    fn add_resolution(&mut self, file_id: FileId, symbol: FileSymbol) {
-        self.resolves_to
-            .push(NavigationTarget::from_symbol(file_id, symbol))
-    }
 }
 /// `AnalysisHost` stores the current state of the world.
@@ -380,7 +375,7 @@ impl Analysis {
    pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<NavigationTarget>> {
        let res = symbol_index::world_symbols(&*self.db, query)?
            .into_iter()
-            .map(|(file_id, symbol)| NavigationTarget::from_symbol(file_id, symbol))
+            .map(NavigationTarget::from_symbol)
            .collect();
        Ok(res)
    }
@@ -399,7 +394,7 @@ impl Analysis {
    pub fn doc_text_for(&self, nav: NavigationTarget) -> Cancelable<Option<String>> {
        self.db.doc_text_for(nav)
    }
-    /// Returns a `mod name;` declaration whihc created the current module.
+    /// Returns a `mod name;` declaration which created the current module.
    pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
        self.db.parent_module(position)
    }
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 960529404..846c76cfe 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -4,7 +4,7 @@ use relative_path::RelativePathBuf;
 use test_utils::{extract_offset, extract_range, parse_fixture, CURSOR_MARKER};
 use ra_db::mock::FileMap;
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition, FileRange, SourceRootId};
+use crate::{Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, FilePosition, FileRange, SourceRootId};
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -87,12 +87,17 @@ impl MockAnalysis {
        let source_root = SourceRootId(0);
        let mut change = AnalysisChange::new();
        change.add_root(source_root, true);
+        let mut crate_graph = CrateGraph::default();
        for (path, contents) in self.files.into_iter() {
            assert!(path.starts_with('/'));
            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
            let file_id = file_map.add(path.clone());
+            if path == "/lib.rs" || path == "/main.rs" {
+                crate_graph.add_crate_root(file_id);
+            }
            change.add_file(source_root, file_id, path, Arc::new(contents));
        }
+        change.set_crate_graph(crate_graph);
        // change.set_file_resolver(Arc::new(file_map));
        host.apply_change(change);
        host
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 10d8e8059..e2b1c88fe 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -20,6 +20,7 @@
 //! file in the current workspace, and run a query aginst the union of all
 //! thouse fsts.
 use std::{
+    cmp::Ordering,
    hash::{Hash, Hasher},
    sync::Arc,
 };
@@ -27,11 +28,11 @@ use std::{
 use fst::{self, Streamer};
 use ra_syntax::{
    SyntaxNodeRef, SourceFileNode, SmolStr,
-    algo::visit::{visitor, Visitor},
+    algo::{visit::{visitor, Visitor}, find_covering_node},
    SyntaxKind::{self, *},
    ast::{self, NameOwner},
 };
-use ra_db::{SyntaxDatabase, SourceRootId, FilesDatabase, LocalSyntaxPtr};
+use ra_db::{SourceRootId, FilesDatabase, LocalSyntaxPtr};
 use salsa::ParallelDatabase;
 use rayon::prelude::*;
@@ -41,7 +42,7 @@ use crate::{
 };
 salsa::query_group! {
-    pub(crate) trait SymbolsDatabase: SyntaxDatabase {
+    pub(crate) trait SymbolsDatabase: hir::db::HirDatabase {
        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
            type FileSymbolsQuery;
        }
@@ -52,16 +53,26 @@ salsa::query_group! {
    }
 }
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
    db.check_canceled()?;
-    let syntax = db.source_file(file_id);
+    let source_file = db.source_file(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
+    let mut symbols = source_file
+        .syntax()
+        .descendants()
+        .filter_map(to_symbol)
+        .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
+        .collect::<Vec<_>>();
+    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id)? {
+        let node = find_covering_node(source_file.syntax(), text_range);
+        let ptr = LocalSyntaxPtr::new(node);
+        symbols.push(FileSymbol { file_id, name, ptr })
+    }
+    Ok(Arc::new(SymbolIndex::new(symbols)))
 }
-pub(crate) fn world_symbols(
+pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Cancelable<Vec<FileSymbol>> {
-    db: &RootDatabase,
-    query: Query,
-) -> Cancelable<Vec<(FileId, FileSymbol)>> {
    /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
    struct Snap(salsa::Snapshot<RootDatabase>);
    impl Clone for Snap {
@@ -95,7 +106,7 @@ pub(crate) fn world_symbols(
 #[derive(Default, Debug)]
 pub(crate) struct SymbolIndex {
-    symbols: Vec<(FileId, FileSymbol)>,
+    symbols: Vec<FileSymbol>,
    map: fst::Map,
 }
@@ -114,6 +125,17 @@ impl Hash for SymbolIndex {
 }
 impl SymbolIndex {
+    fn new(mut symbols: Vec<FileSymbol>) -> SymbolIndex {
+        fn cmp(s1: &FileSymbol, s2: &FileSymbol) -> Ordering {
+            unicase::Ascii::new(s1.name.as_str()).cmp(&unicase::Ascii::new(s2.name.as_str()))
+        }
+        symbols.par_sort_by(cmp);
+        symbols.dedup_by(|s1, s2| cmp(s1, s2) == Ordering::Equal);
+        let names = symbols.iter().map(|it| it.name.as_str().to_lowercase());
+        let map = fst::Map::from_iter(names.into_iter().zip(0u64..)).unwrap();
+        SymbolIndex { symbols, map }
+    }
    pub(crate) fn len(&self) -> usize {
        self.symbols.len()
    }
@@ -121,30 +143,21 @@ impl SymbolIndex {
    pub(crate) fn for_files(
        files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
    ) -> SymbolIndex {
-        let mut symbols = files
+        let symbols = files
            .flat_map(|(file_id, file)| {
                file.syntax()
                    .descendants()
                    .filter_map(to_symbol)
-                    .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
+                    .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
                    .collect::<Vec<_>>()
            })
            .collect::<Vec<_>>();
-        symbols.par_sort_by(|s1, s2| s1.0.cmp(&s2.0));
+        SymbolIndex::new(symbols)
-        symbols.dedup_by(|s1, s2| s1.0 == s2.0);
-        let (names, symbols): (Vec<String>, Vec<(FileId, FileSymbol)>) =
-            symbols.into_iter().unzip();
-        let map = fst::Map::from_iter(names.into_iter().zip(0u64..)).unwrap();
-        SymbolIndex { symbols, map }
-    }
-    pub(crate) fn for_file(file_id: FileId, file: SourceFileNode) -> SymbolIndex {
-        SymbolIndex::for_files(rayon::iter::once((file_id, file)))
    }
 }
 impl Query {
-    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<(FileId, FileSymbol)> {
+    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<FileSymbol> {
        let mut op = fst::map::OpBuilder::new();
        for file_symbols in indices.iter() {
            let automaton = fst::automaton::Subsequence::new(&self.lowercased);
@@ -160,14 +173,14 @@ impl Query {
                let file_symbols = &indices[indexed_value.index];
                let idx = indexed_value.value as usize;
-                let (file_id, symbol) = &file_symbols.symbols[idx];
+                let symbol = &file_symbols.symbols[idx];
                if self.only_types && !is_type(symbol.ptr.kind()) {
                    continue;
                }
                if self.exact && symbol.name != self.query {
                    continue;
                }
-                res.push((*file_id, symbol.clone()));
+                res.push(symbol.clone());
            }
        }
        res
@@ -185,17 +198,16 @@ fn is_type(kind: SyntaxKind) -> bool {
 /// possible.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct FileSymbol {
+    pub(crate) file_id: FileId,
    pub(crate) name: SmolStr,
    pub(crate) ptr: LocalSyntaxPtr,
 }
-fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
+fn to_symbol(node: SyntaxNodeRef) -> Option<(SmolStr, LocalSyntaxPtr)> {
-    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<FileSymbol> {
+    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<(SmolStr, LocalSyntaxPtr)> {
-        let name = node.name()?;
+        let name = node.name()?.text();
-        Some(FileSymbol {
+        let ptr = LocalSyntaxPtr::new(node.syntax());
-            name: name.text(),
+        Some((name, ptr))
-            ptr: LocalSyntaxPtr::new(node.syntax()),
-        })
    }
    visitor()
        .visit(decl::<ast::FnDef>)
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
index ccea4aee3..35e153ca0 100644
--- a/crates/ra_analysis/src/syntax_highlighting.rs
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -43,6 +43,7 @@ mod tests {
            "
            fn main() {
                ctry!({ let x = 92; x});
+                vec![{ let x = 92; x}];
            }
            ",
        );
@@ -53,10 +54,17 @@ mod tests {
                HighlightedRange { range: [41; 46), tag: "macro" },
                HighlightedRange { range: [49; 52), tag: "keyword" },
                HighlightedRange { range: [57; 59), tag: "literal" },
+                HighlightedRange { range: [82; 86), tag: "macro" },
+                HighlightedRange { range: [89; 92), tag: "keyword" },
+                HighlightedRange { range: [97; 99), tag: "literal" },
                HighlightedRange { range: [49; 52), tag: "keyword" },
                HighlightedRange { range: [53; 54), tag: "function" },
                HighlightedRange { range: [57; 59), tag: "literal" },
-                HighlightedRange { range: [61; 62), tag: "text" }]"#,
+                HighlightedRange { range: [61; 62), tag: "text" },
+                HighlightedRange { range: [89; 92), tag: "keyword" },
+                HighlightedRange { range: [93; 94), tag: "function" },
+                HighlightedRange { range: [97; 99), tag: "literal" },
+                HighlightedRange { range: [101; 102), tag: "text" }]"#,
            &highlights,
        )
    }
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/test/main.rs
index bcf29d29c..beeae1e19 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/test/main.rs
@@ -1,9 +1,12 @@
+mod runnables;
+mod type_of;
 use ra_syntax::TextRange;
 use test_utils::{assert_eq_dbg, assert_eq_text};
 use ra_analysis::{
    mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis},
-    AnalysisChange, CrateGraph, FileId, FnSignatureInfo,
+    AnalysisChange, CrateGraph, FileId, FnSignatureInfo, Query
 };
 fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
@@ -135,14 +138,14 @@ fn test_resolve_parent_module_for_inline() {
 fn test_resolve_crate_root() {
    let mock = MockAnalysis::with_files(
        "
-        //- /lib.rs
+        //- /bar.rs
        mod foo;
-        //- /foo.rs
+        //- /bar/foo.rs
        // emtpy <|>
    ",
    );
-    let root_file = mock.id_of("/lib.rs");
+    let root_file = mock.id_of("/bar.rs");
-    let mod_file = mock.id_of("/foo.rs");
+    let mod_file = mock.id_of("/bar/foo.rs");
    let mut host = mock.analysis_host();
    assert!(host.analysis().crate_for(mod_file).unwrap().is_empty());
@@ -246,7 +249,8 @@ fn bar() {
 fn test_fn_signature_with_docs_simple() {
    let (desc, param) = get_signature(
        r#"
-// test
+/// test
+// non-doc-comment
 fn foo(j: u32) -> u32 {
    j
 }
@@ -528,10 +532,11 @@ fn test_rename_for_mut_param() {
    }"#,
    );
 }
 fn test_rename(text: &str, new_name: &str, expected: &str) {
    let (analysis, position) = single_file_with_position(text);
    let edits = analysis.rename(position, new_name).unwrap();
-    let mut text_edit_bulder = ra_text_edit::TextEditBuilder::new();
+    let mut text_edit_bulder = ra_text_edit::TextEditBuilder::default();
    let mut file_id: Option<FileId> = None;
    for edit in edits {
        file_id = Some(edit.file_id);
@@ -544,3 +549,19 @@ fn test_rename(text: &str, new_name: &str, expected: &str) {
        .apply(&*analysis.file_text(file_id.unwrap()));
    assert_eq_text!(expected, &*result);
 }
+#[test]
+fn world_symbols_include_stuff_from_macros() {
+    let (analysis, _) = single_file(
+        "
+salsa::query_group! {
+pub trait HirDatabase: SyntaxDatabase {}
+}
+    ",
+    );
+    let mut symbols = analysis.symbol_search(Query::new("Hir".into())).unwrap();
+    let s = symbols.pop().unwrap();
+    assert_eq!(s.name(), "HirDatabase");
+    assert_eq!(s.range(), TextRange::from_to(33.into(), 44.into()));
+}
diff --git a/crates/ra_analysis/tests/runnables.rs b/crates/ra_analysis/tests/test/runnables.rs
index 9e5342c46..e6e0afbc3 100644
--- a/crates/ra_analysis/tests/runnables.rs
+++ b/crates/ra_analysis/tests/test/runnables.rs
@@ -1,15 +1,6 @@
-extern crate ra_analysis;
-extern crate ra_editor;
-extern crate ra_syntax;
-extern crate relative_path;
-extern crate rustc_hash;
-extern crate test_utils;
 use test_utils::assert_eq_dbg;
-use ra_analysis::{
+use ra_analysis::mock_analysis::analysis_and_position;
-    mock_analysis::{analysis_and_position},
-};
 #[test]
 fn test_runnables() {
diff --git a/crates/ra_analysis/tests/type_of.rs b/crates/ra_analysis/tests/test/type_of.rs
index 375f808bb..9d15b52a8 100644
--- a/crates/ra_analysis/tests/type_of.rs
+++ b/crates/ra_analysis/tests/test/type_of.rs
@@ -1,6 +1,4 @@
-use ra_analysis::{
+use ra_analysis::mock_analysis::single_file_with_range;
-    mock_analysis::{single_file_with_range},
-};
 #[test]
 fn test_type_of_for_function() {
diff --git a/crates/ra_arena/Cargo.toml b/crates/ra_arena/Cargo.toml
new file mode 100644
index 000000000..9594e2d0f
--- /dev/null
+++ b/crates/ra_arena/Cargo.toml
@@ -0,0 +1,5 @@
+[package]
+edition = "2018"
+name = "ra_arena"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
diff --git a/crates/ra_arena/src/lib.rs b/crates/ra_arena/src/lib.rs
new file mode 100644
index 000000000..a5eeb4118
--- /dev/null
+++ b/crates/ra_arena/src/lib.rs
@@ -0,0 +1,97 @@
+//! Yet another index-based arena.
+use std::{
+    fmt,
+    marker::PhantomData,
+    ops::{Index, IndexMut},
+};
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct RawId(u32);
+impl From<RawId> for u32 {
+    fn from(raw: RawId) -> u32 {
+        raw.0
+    }
+}
+impl From<u32> for RawId {
+    fn from(id: u32) -> RawId {
+        RawId(id)
+    }
+}
+impl fmt::Debug for RawId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+impl fmt::Display for RawId {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Arena<ID: ArenaId, T> {
+    data: Vec<T>,
+    _ty: PhantomData<ID>,
+}
+#[macro_export]
+macro_rules! impl_arena_id {
+    ($name:ident) => {
+        impl $crate::ArenaId for $name {
+            fn from_raw(raw: $crate::RawId) -> Self {
+                $name(raw)
+            }
+            fn into_raw(self) -> $crate::RawId {
+                self.0
+            }
+        }
+    };
+}
+pub trait ArenaId {
+    fn from_raw(raw: RawId) -> Self;
+    fn into_raw(self) -> RawId;
+}
+impl<ID: ArenaId, T> Arena<ID, T> {
+    pub fn alloc(&mut self, value: T) -> ID {
+        let id = RawId(self.data.len() as u32);
+        self.data.push(value);
+        ID::from_raw(id)
+    }
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item = (ID, &'a T)> {
+        self.data
+            .iter()
+            .enumerate()
+            .map(|(idx, value)| (ID::from_raw(RawId(idx as u32)), value))
+    }
+}
+impl<ID: ArenaId, T> Default for Arena<ID, T> {
+    fn default() -> Arena<ID, T> {
+        Arena {
+            data: Vec::new(),
+            _ty: PhantomData,
+        }
+    }
+}
+impl<ID: ArenaId, T> Index<ID> for Arena<ID, T> {
+    type Output = T;
+    fn index(&self, idx: ID) -> &T {
+        let idx = idx.into_raw().0 as usize;
+        &self.data[idx]
+    }
+}
+impl<ID: ArenaId, T> IndexMut<ID> for Arena<ID, T> {
+    fn index_mut(&mut self, idx: ID) -> &mut T {
+        let idx = idx.into_raw().0 as usize;
+        &mut self.data[idx]
+    }
+}
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
index ecc56d953..c0e83a140 100644
--- a/crates/ra_db/Cargo.toml
+++ b/crates/ra_db/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["Aleksey Kladov <[email protected]>"]
 [dependencies]
 relative-path = "0.4.0"
-salsa = "0.9.0"
+salsa = "0.9.1"
 rustc-hash = "1.0"
 parking_lot = "0.7.0"
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_editor/src/assists.rs b/crates/ra_editor/src/assists.rs
new file mode 100644
index 000000000..57b78342a
--- /dev/null
+++ b/crates/ra_editor/src/assists.rs
@@ -0,0 +1,188 @@
+//! This modules contains various "assits": suggestions for source code edits
+//! which are likely to occur at a given cursor positon. For example, if the
+//! cursor is on the `,`, a possible assist is swapping the elments around the
+//! comma.
+mod flip_comma;
+mod add_derive;
+mod add_impl;
+mod introduce_variable;
+mod change_visibility;
+mod split_import;
+use ra_text_edit::{TextEdit, TextEditBuilder};
+use ra_syntax::{
+    Direction, SyntaxNodeRef, TextUnit, TextRange,SourceFileNode, AstNode,
+    algo::{find_leaf_at_offset, find_covering_node, LeafAtOffset},
+};
+use crate::find_node_at_offset;
+pub use self::{
+    flip_comma::flip_comma,
+    add_derive::add_derive,
+    add_impl::add_impl,
+    introduce_variable::introduce_variable,
+    change_visibility::change_visibility,
+    split_import::split_import,
+};
+/// Return all the assists applicable at the given position.
+pub fn assists(file: &SourceFileNode, range: TextRange) -> Vec<LocalEdit> {
+    let ctx = AssistCtx::new(file, range);
+    [
+        flip_comma,
+        add_derive,
+        add_impl,
+        introduce_variable,
+        change_visibility,
+        split_import,
+    ]
+    .iter()
+    .filter_map(|&assist| ctx.clone().apply(assist))
+    .collect()
+}
+#[derive(Debug)]
+pub struct LocalEdit {
+    pub label: String,
+    pub edit: TextEdit,
+    pub cursor_position: Option<TextUnit>,
+}
+fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<SyntaxNodeRef> {
+    node.siblings(direction)
+        .skip(1)
+        .find(|node| !node.kind().is_trivia())
+}
+/// `AssistCtx` allows to apply an assist or check if it could be applied.
+///
+/// Assists use a somewhat overengeneered approach, given the current needs. The
+/// assists workflow consists of two phases. In the first phase, a user asks for
+/// the list of available assists. In the second phase, the user picks a
+/// particular assist and it gets applied.
+///
+/// There are two peculiarities here:
+///
+/// * first, we ideally avoid computing more things then neccessary to answer
+///   "is assist applicable" in the first phase.
+/// * second, when we are appling assist, we don't have a gurantee that there
+///   weren't any changes between the point when user asked for assists and when
+///   they applied a particular assist. So, when applying assist, we need to do
+///   all the checks from scratch.
+///
+/// To avoid repeating the same code twice for both "check" and "apply"
+/// functions, we use an approach remeniscent of that of Django's function based
+/// views dealing with forms. Each assist receives a runtime parameter,
+/// `should_compute_edit`. It first check if an edit is applicable (potentially
+/// computing info required to compute the actual edit). If it is applicable,
+/// and `should_compute_edit` is `true`, it then computes the actual edit.
+///
+/// So, to implement the original assists workflow, we can first apply each edit
+/// with `should_compute_edit = false`, and then applying the selected edit
+/// again, with `should_compute_edit = true` this time.
+///
+/// Note, however, that we don't actually use such two-phase logic at the
+/// moment, because the LSP API is pretty awkward in this place, and it's much
+/// easier to just compute the edit eagarly :-)
+#[derive(Debug, Clone)]
+pub struct AssistCtx<'a> {
+    source_file: &'a SourceFileNode,
+    range: TextRange,
+    should_compute_edit: bool,
+}
+#[derive(Debug)]
+pub enum Assist {
+    Applicable,
+    Edit(LocalEdit),
+}
+#[derive(Default)]
+struct AssistBuilder {
+    edit: TextEditBuilder,
+    cursor_position: Option<TextUnit>,
+}
+impl<'a> AssistCtx<'a> {
+    pub fn new(source_file: &'a SourceFileNode, range: TextRange) -> AssistCtx {
+        AssistCtx {
+            source_file,
+            range,
+            should_compute_edit: false,
+        }
+    }
+    pub fn apply(mut self, assist: fn(AssistCtx) -> Option<Assist>) -> Option<LocalEdit> {
+        self.should_compute_edit = true;
+        match assist(self) {
+            None => None,
+            Some(Assist::Edit(e)) => Some(e),
+            Some(Assist::Applicable) => unreachable!(),
+        }
+    }
+    pub fn check(mut self, assist: fn(AssistCtx) -> Option<Assist>) -> bool {
+        self.should_compute_edit = false;
+        match assist(self) {
+            None => false,
+            Some(Assist::Edit(_)) => unreachable!(),
+            Some(Assist::Applicable) => true,
+        }
+    }
+    fn build(self, label: impl Into<String>, f: impl FnOnce(&mut AssistBuilder)) -> Option<Assist> {
+        if !self.should_compute_edit {
+            return Some(Assist::Applicable);
+        }
+        let mut edit = AssistBuilder::default();
+        f(&mut edit);
+        Some(Assist::Edit(LocalEdit {
+            label: label.into(),
+            edit: edit.edit.finish(),
+            cursor_position: edit.cursor_position,
+        }))
+    }
+    pub(crate) fn leaf_at_offset(&self) -> LeafAtOffset<SyntaxNodeRef<'a>> {
+        find_leaf_at_offset(self.source_file.syntax(), self.range.start())
+    }
+    pub(crate) fn node_at_offset<N: AstNode<'a>>(&self) -> Option<N> {
+        find_node_at_offset(self.source_file.syntax(), self.range.start())
+    }
+    pub(crate) fn covering_node(&self) -> SyntaxNodeRef<'a> {
+        find_covering_node(self.source_file.syntax(), self.range)
+    }
+}
+impl AssistBuilder {
+    fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
+        self.edit.replace(range, replace_with.into())
+    }
+    #[allow(unused)]
+    fn delete(&mut self, range: TextRange) {
+        self.edit.delete(range)
+    }
+    fn insert(&mut self, offset: TextUnit, text: impl Into<String>) {
+        self.edit.insert(offset, text.into())
+    }
+    fn set_cursor(&mut self, offset: TextUnit) {
+        self.cursor_position = Some(offset)
+    }
+}
+#[cfg(test)]
+fn check_assist(assist: fn(AssistCtx) -> Option<Assist>, before: &str, after: &str) {
+    crate::test_utils::check_action(before, after, |file, off| {
+        let range = TextRange::offset_len(off, 0.into());
+        AssistCtx::new(file, range).apply(assist)
+    })
+}
+#[cfg(test)]
+fn check_assist_range(assist: fn(AssistCtx) -> Option<Assist>, before: &str, after: &str) {
+    crate::test_utils::check_action_range(before, after, |file, range| {
+        AssistCtx::new(file, range).apply(assist)
+    })
+}
diff --git a/crates/ra_editor/src/assists/add_derive.rs b/crates/ra_editor/src/assists/add_derive.rs
new file mode 100644
index 000000000..1e2cd4f30
--- /dev/null
+++ b/crates/ra_editor/src/assists/add_derive.rs
@@ -0,0 +1,84 @@
+use ra_syntax::{
+    ast::{self, AstNode, AttrsOwner},
+    SyntaxKind::{WHITESPACE, COMMENT},
+    TextUnit,
+};
+use crate::assists::{AssistCtx, Assist};
+pub fn add_derive(ctx: AssistCtx) -> Option<Assist> {
+    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
+    let node_start = derive_insertion_offset(nominal)?;
+    ctx.build("add `#[derive]`", |edit| {
+        let derive_attr = nominal
+            .attrs()
+            .filter_map(|x| x.as_call())
+            .filter(|(name, _arg)| name == "derive")
+            .map(|(_name, arg)| arg)
+            .next();
+        let offset = match derive_attr {
+            None => {
+                edit.insert(node_start, "#[derive()]\n");
+                node_start + TextUnit::of_str("#[derive(")
+            }
+            Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
+        };
+        edit.set_cursor(offset)
+    })
+}
+// Insert `derive` after doc comments.
+fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
+    let non_ws_child = nominal
+        .syntax()
+        .children()
+        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+    Some(non_ws_child.range().start())
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+    #[test]
+    fn add_derive_new() {
+        check_assist(
+            add_derive,
+            "struct Foo { a: i32, <|>}",
+            "#[derive(<|>)]\nstruct Foo { a: i32, }",
+        );
+        check_assist(
+            add_derive,
+            "struct Foo { <|> a: i32, }",
+            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
+        );
+    }
+    #[test]
+    fn add_derive_existing() {
+        check_assist(
+            add_derive,
+            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
+            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
+        );
+    }
+    #[test]
+    fn add_derive_new_with_doc_comment() {
+        check_assist(
+            add_derive,
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+struct Foo { a: i32<|>, }
+            ",
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+#[derive(<|>)]
+struct Foo { a: i32, }
+            ",
+        );
+    }
+}
diff --git a/crates/ra_editor/src/assists/add_impl.rs b/crates/ra_editor/src/assists/add_impl.rs
new file mode 100644
index 000000000..9353e2717
--- /dev/null
+++ b/crates/ra_editor/src/assists/add_impl.rs
@@ -0,0 +1,66 @@
+use join_to_string::join;
+use ra_syntax::{
+    ast::{self, AstNode, NameOwner, TypeParamsOwner},
+    TextUnit,
+};
+use crate::assists::{AssistCtx, Assist};
+pub fn add_impl(ctx: AssistCtx) -> Option<Assist> {
+    let nominal = ctx.node_at_offset::<ast::NominalDef>()?;
+    let name = nominal.name()?;
+    ctx.build("add impl", |edit| {
+        let type_params = nominal.type_param_list();
+        let start_offset = nominal.syntax().range().end();
+        let mut buf = String::new();
+        buf.push_str("\n\nimpl");
+        if let Some(type_params) = type_params {
+            type_params.syntax().text().push_to(&mut buf);
+        }
+        buf.push_str(" ");
+        buf.push_str(name.text().as_str());
+        if let Some(type_params) = type_params {
+            let lifetime_params = type_params
+                .lifetime_params()
+                .filter_map(|it| it.lifetime())
+                .map(|it| it.text());
+            let type_params = type_params
+                .type_params()
+                .filter_map(|it| it.name())
+                .map(|it| it.text());
+            join(lifetime_params.chain(type_params))
+                .surround_with("<", ">")
+                .to_buf(&mut buf);
+        }
+        buf.push_str(" {\n");
+        edit.set_cursor(start_offset + TextUnit::of_str(&buf));
+        buf.push_str("\n}");
+        edit.insert(start_offset, buf);
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+    #[test]
+    fn test_add_impl() {
+        check_assist(
+            add_impl,
+            "struct Foo {<|>}\n",
+            "struct Foo {}\n\nimpl Foo {\n<|>\n}\n",
+        );
+        check_assist(
+            add_impl,
+            "struct Foo<T: Clone> {<|>}",
+            "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n<|>\n}",
+        );
+        check_assist(
+            add_impl,
+            "struct Foo<'a, T: Foo<'a>> {<|>}",
+            "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n<|>\n}",
+        );
+    }
+}
diff --git a/crates/ra_editor/src/assists/change_visibility.rs b/crates/ra_editor/src/assists/change_visibility.rs
new file mode 100644
index 000000000..6c8466394
--- /dev/null
+++ b/crates/ra_editor/src/assists/change_visibility.rs
@@ -0,0 +1,116 @@
+use ra_syntax::{
+    AstNode,
+    ast::{self, VisibilityOwner, NameOwner},
+    SyntaxKind::{VISIBILITY, FN_KW, MOD_KW, STRUCT_KW, ENUM_KW, TRAIT_KW, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF, IDENT},
+};
+use crate::assists::{AssistCtx, Assist};
+pub fn change_visibility(ctx: AssistCtx) -> Option<Assist> {
+    if let Some(vis) = ctx.node_at_offset::<ast::Visibility>() {
+        return change_vis(ctx, vis);
+    }
+    add_vis(ctx)
+}
+fn add_vis(ctx: AssistCtx) -> Option<Assist> {
+    let item_keyword = ctx.leaf_at_offset().find(|leaf| match leaf.kind() {
+        FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
+        _ => false,
+    });
+    let offset = if let Some(keyword) = item_keyword {
+        let parent = keyword.parent()?;
+        let def_kws = vec![FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
+        // Parent is not a definition, can't add visibility
+        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
+            return None;
+        }
+        // Already have visibility, do nothing
+        if parent.children().any(|child| child.kind() == VISIBILITY) {
+            return None;
+        }
+        parent.range().start()
+    } else {
+        let ident = ctx.leaf_at_offset().find(|leaf| leaf.kind() == IDENT)?;
+        let field = ident.ancestors().find_map(ast::NamedFieldDef::cast)?;
+        if field.name()?.syntax().range() != ident.range() && field.visibility().is_some() {
+            return None;
+        }
+        field.syntax().range().start()
+    };
+    ctx.build("make pub(crate)", |edit| {
+        edit.insert(offset, "pub(crate) ");
+        edit.set_cursor(offset);
+    })
+}
+fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
+    if vis.syntax().text() != "pub" {
+        return None;
+    }
+    ctx.build("chage to pub(crate)", |edit| {
+        edit.replace(vis.syntax().range(), "pub(crate)");
+        edit.set_cursor(vis.syntax().range().start());
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+    #[test]
+    fn change_visibility_adds_pub_crate_to_items() {
+        check_assist(
+            change_visibility,
+            "<|>fn foo() {}",
+            "<|>pub(crate) fn foo() {}",
+        );
+        check_assist(
+            change_visibility,
+            "f<|>n foo() {}",
+            "<|>pub(crate) fn foo() {}",
+        );
+        check_assist(
+            change_visibility,
+            "<|>struct Foo {}",
+            "<|>pub(crate) struct Foo {}",
+        );
+        check_assist(
+            change_visibility,
+            "<|>mod foo {}",
+            "<|>pub(crate) mod foo {}",
+        );
+        check_assist(
+            change_visibility,
+            "<|>trait Foo {}",
+            "<|>pub(crate) trait Foo {}",
+        );
+        check_assist(change_visibility, "m<|>od {}", "<|>pub(crate) mod {}");
+        check_assist(
+            change_visibility,
+            "unsafe f<|>n foo() {}",
+            "<|>pub(crate) unsafe fn foo() {}",
+        );
+    }
+    #[test]
+    fn change_visibility_works_with_struct_fields() {
+        check_assist(
+            change_visibility,
+            "struct S { <|>field: u32 }",
+            "struct S { <|>pub(crate) field: u32 }",
+        )
+    }
+    #[test]
+    fn change_visibility_pub_to_pub_crate() {
+        check_assist(
+            change_visibility,
+            "<|>pub fn foo() {}",
+            "<|>pub(crate) fn foo() {}",
+        )
+    }
+}
diff --git a/crates/ra_editor/src/assists/flip_comma.rs b/crates/ra_editor/src/assists/flip_comma.rs
new file mode 100644
index 000000000..a343413cc
--- /dev/null
+++ b/crates/ra_editor/src/assists/flip_comma.rs
@@ -0,0 +1,31 @@
+use ra_syntax::{
+    Direction,
+    SyntaxKind::COMMA,
+};
+use crate::assists::{non_trivia_sibling, AssistCtx, Assist};
+pub fn flip_comma(ctx: AssistCtx) -> Option<Assist> {
+    let comma = ctx.leaf_at_offset().find(|leaf| leaf.kind() == COMMA)?;
+    let prev = non_trivia_sibling(comma, Direction::Prev)?;
+    let next = non_trivia_sibling(comma, Direction::Next)?;
+    ctx.build("flip comma", |edit| {
+        edit.replace(prev.range(), next.text());
+        edit.replace(next.range(), prev.text());
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+    #[test]
+    fn flip_comma_works_for_function_parameters() {
+        check_assist(
+            flip_comma,
+            "fn foo(x: i32,<|> y: Result<(), ()>) {}",
+            "fn foo(y: Result<(), ()>,<|> x: i32) {}",
+        )
+    }
+}
diff --git a/crates/ra_editor/src/assists/introduce_variable.rs b/crates/ra_editor/src/assists/introduce_variable.rs
new file mode 100644
index 000000000..782861023
--- /dev/null
+++ b/crates/ra_editor/src/assists/introduce_variable.rs
@@ -0,0 +1,144 @@
+use ra_syntax::{
+    ast::{self, AstNode},
+    SyntaxKind::WHITESPACE,
+    SyntaxNodeRef, TextUnit,
+};
+use crate::assists::{AssistCtx, Assist};
+pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
+    let node = ctx.covering_node();
+    let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
+    let anchor_stmt = anchor_stmt(expr)?;
+    let indent = anchor_stmt.prev_sibling()?;
+    if indent.kind() != WHITESPACE {
+        return None;
+    }
+    ctx.build("introduce variable", move |edit| {
+        let mut buf = String::new();
+        buf.push_str("let var_name = ");
+        expr.syntax().text().push_to(&mut buf);
+        let is_full_stmt = if let Some(expr_stmt) = ast::ExprStmt::cast(anchor_stmt) {
+            Some(expr.syntax()) == expr_stmt.expr().map(|e| e.syntax())
+        } else {
+            false
+        };
+        if is_full_stmt {
+            edit.replace(expr.syntax().range(), buf);
+        } else {
+            buf.push_str(";");
+            indent.text().push_to(&mut buf);
+            edit.replace(expr.syntax().range(), "var_name".to_string());
+            edit.insert(anchor_stmt.range().start(), buf);
+        }
+        edit.set_cursor(anchor_stmt.range().start() + TextUnit::of_str("let "));
+    })
+}
+/// Statement or last in the block expression, which will follow
+/// the freshly introduced var.
+fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
+    expr.syntax().ancestors().find(|&node| {
+        if ast::Stmt::cast(node).is_some() {
+            return true;
+        }
+        if let Some(expr) = node
+            .parent()
+            .and_then(ast::Block::cast)
+            .and_then(|it| it.expr())
+        {
+            if expr.syntax() == node {
+                return true;
+            }
+        }
+        false
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist_range;
+    #[test]
+    fn test_introduce_var_simple() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn foo() {
+    foo(<|>1 + 1<|>);
+}",
+            "
+fn foo() {
+    let <|>var_name = 1 + 1;
+    foo(var_name);
+}",
+        );
+    }
+    #[test]
+    fn test_introduce_var_expr_stmt() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn foo() {
+    <|>1 + 1<|>;
+}",
+            "
+fn foo() {
+    let <|>var_name = 1 + 1;
+}",
+        );
+    }
+    #[test]
+    fn test_introduce_var_part_of_expr_stmt() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn foo() {
+    <|>1<|> + 1;
+}",
+            "
+fn foo() {
+    let <|>var_name = 1;
+    var_name + 1;
+}",
+        );
+    }
+    #[test]
+    fn test_introduce_var_last_expr() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn foo() {
+    bar(<|>1 + 1<|>)
+}",
+            "
+fn foo() {
+    let <|>var_name = 1 + 1;
+    bar(var_name)
+}",
+        );
+    }
+    #[test]
+    fn test_introduce_var_last_full_expr() {
+        check_assist_range(
+            introduce_variable,
+            "
+fn foo() {
+    <|>bar(1 + 1)<|>
+}",
+            "
+fn foo() {
+    let <|>var_name = bar(1 + 1);
+    var_name
+}",
+        );
+    }
+}
diff --git a/crates/ra_editor/src/assists/split_import.rs b/crates/ra_editor/src/assists/split_import.rs
new file mode 100644
index 000000000..75f9e8dfb
--- /dev/null
+++ b/crates/ra_editor/src/assists/split_import.rs
@@ -0,0 +1,44 @@
+use ra_syntax::{
+    TextUnit, AstNode, SyntaxKind::COLONCOLON,
+    ast,
+    algo::generate,
+};
+use crate::assists::{AssistCtx, Assist};
+pub fn split_import(ctx: AssistCtx) -> Option<Assist> {
+    let colon_colon = ctx
+        .leaf_at_offset()
+        .find(|leaf| leaf.kind() == COLONCOLON)?;
+    let path = colon_colon.parent().and_then(ast::Path::cast)?;
+    let top_path = generate(Some(path), |it| it.parent_path()).last()?;
+    let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast);
+    if use_tree.is_none() {
+        return None;
+    }
+    let l_curly = colon_colon.range().end();
+    let r_curly = top_path.syntax().range().end();
+    ctx.build("split import", |edit| {
+        edit.insert(l_curly, "{");
+        edit.insert(r_curly, "}");
+        edit.set_cursor(l_curly + TextUnit::of_str("{"));
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+    #[test]
+    fn test_split_import() {
+        check_assist(
+            split_import,
+            "use crate::<|>db::RootDatabase;",
+            "use crate::{<|>db::RootDatabase};",
+        )
+    }
+}
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
deleted file mode 100644
index 7615f37a6..000000000
--- a/crates/ra_editor/src/code_actions.rs
+++ /dev/null
@@ -1,415 +0,0 @@
-use join_to_string::join;
-use ra_syntax::{
-    algo::{find_covering_node, find_leaf_at_offset},
-    ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
-    Direction, SourceFileNode,
-    SyntaxKind::{COMMA, WHITESPACE, COMMENT, VISIBILITY, FN_KW, MOD_KW, STRUCT_KW, ENUM_KW, TRAIT_KW, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF},
-    SyntaxNodeRef, TextRange, TextUnit,
-};
-use crate::{find_node_at_offset, TextEdit, TextEditBuilder};
-#[derive(Debug)]
-pub struct LocalEdit {
-    pub label: String,
-    pub edit: TextEdit,
-    pub cursor_position: Option<TextUnit>,
-}
-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)?;
-    let prev = non_trivia_sibling(comma, Direction::Prev)?;
-    let next = non_trivia_sibling(comma, Direction::Next)?;
-    Some(move || {
-        let mut edit = TextEditBuilder::new();
-        edit.replace(prev.range(), next.text().to_string());
-        edit.replace(next.range(), prev.text().to_string());
-        LocalEdit {
-            label: "flip comma".to_string(),
-            edit: edit.finish(),
-            cursor_position: None,
-        }
-    })
-}
-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)?;
-    let node_start = derive_insertion_offset(nominal)?;
-    return Some(move || {
-        let derive_attr = nominal
-            .attrs()
-            .filter_map(|x| x.as_call())
-            .filter(|(name, _arg)| name == "derive")
-            .map(|(_name, arg)| arg)
-            .next();
-        let mut edit = TextEditBuilder::new();
-        let offset = match derive_attr {
-            None => {
-                edit.insert(node_start, "#[derive()]\n".to_string());
-                node_start + TextUnit::of_str("#[derive(")
-            }
-            Some(tt) => tt.syntax().range().end() - TextUnit::of_char(')'),
-        };
-        LocalEdit {
-            label: "add `#[derive]`".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(offset),
-        }
-    });
-    // Insert `derive` after doc comments.
-    fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
-        let non_ws_child = nominal
-            .syntax()
-            .children()
-            .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
-        Some(non_ws_child.range().start())
-    }
-}
-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()?;
-    Some(move || {
-        let type_params = nominal.type_param_list();
-        let mut edit = TextEditBuilder::new();
-        let start_offset = nominal.syntax().range().end();
-        let mut buf = String::new();
-        buf.push_str("\n\nimpl");
-        if let Some(type_params) = type_params {
-            type_params.syntax().text().push_to(&mut buf);
-        }
-        buf.push_str(" ");
-        buf.push_str(name.text().as_str());
-        if let Some(type_params) = type_params {
-            let lifetime_params = type_params
-                .lifetime_params()
-                .filter_map(|it| it.lifetime())
-                .map(|it| it.text());
-            let type_params = type_params
-                .type_params()
-                .filter_map(|it| it.name())
-                .map(|it| it.text());
-            join(lifetime_params.chain(type_params))
-                .surround_with("<", ">")
-                .to_buf(&mut buf);
-        }
-        buf.push_str(" {\n");
-        let offset = start_offset + TextUnit::of_str(&buf);
-        buf.push_str("\n}");
-        edit.insert(start_offset, buf);
-        LocalEdit {
-            label: "add impl".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(offset),
-        }
-    })
-}
-pub fn introduce_variable<'a>(
-    file: &'a SourceFileNode,
-    range: TextRange,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let node = find_covering_node(file.syntax(), range);
-    let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
-    let anchor_stmt = anchor_stmt(expr)?;
-    let indent = anchor_stmt.prev_sibling()?;
-    if indent.kind() != WHITESPACE {
-        return None;
-    }
-    return Some(move || {
-        let mut buf = String::new();
-        let mut edit = TextEditBuilder::new();
-        buf.push_str("let var_name = ");
-        expr.syntax().text().push_to(&mut buf);
-        let is_full_stmt = if let Some(expr_stmt) = ast::ExprStmt::cast(anchor_stmt) {
-            Some(expr.syntax()) == expr_stmt.expr().map(|e| e.syntax())
-        } else {
-            false
-        };
-        if is_full_stmt {
-            edit.replace(expr.syntax().range(), buf);
-        } else {
-            buf.push_str(";");
-            indent.text().push_to(&mut buf);
-            edit.replace(expr.syntax().range(), "var_name".to_string());
-            edit.insert(anchor_stmt.range().start(), buf);
-        }
-        let cursor_position = anchor_stmt.range().start() + TextUnit::of_str("let ");
-        LocalEdit {
-            label: "introduce variable".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(cursor_position),
-        }
-    });
-    /// Statement or last in the block expression, which will follow
-    /// the freshly introduced var.
-    fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
-        expr.syntax().ancestors().find(|&node| {
-            if ast::Stmt::cast(node).is_some() {
-                return true;
-            }
-            if let Some(expr) = node
-                .parent()
-                .and_then(ast::Block::cast)
-                .and_then(|it| it.expr())
-            {
-                if expr.syntax() == node {
-                    return true;
-                }
-            }
-            false
-        })
-    }
-}
-pub fn make_pub_crate<'a>(
-    file: &'a SourceFileNode,
-    offset: TextUnit,
-) -> Option<impl FnOnce() -> LocalEdit + 'a> {
-    let syntax = file.syntax();
-    let keyword = find_leaf_at_offset(syntax, offset).find(|leaf| match leaf.kind() {
-        FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
-        _ => false,
-    })?;
-    let parent = keyword.parent()?;
-    let def_kws = vec![FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
-    let node_start = parent.range().start();
-    Some(move || {
-        let mut edit = TextEditBuilder::new();
-        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind())
-            || parent.children().any(|child| child.kind() == VISIBILITY)
-        {
-            return LocalEdit {
-                label: "make pub crate".to_string(),
-                edit: edit.finish(),
-                cursor_position: Some(offset),
-            };
-        }
-        edit.insert(node_start, "pub(crate) ".to_string());
-        LocalEdit {
-            label: "make pub crate".to_string(),
-            edit: edit.finish(),
-            cursor_position: Some(node_start),
-        }
-    })
-}
-fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<SyntaxNodeRef> {
-    node.siblings(direction)
-        .skip(1)
-        .find(|node| !node.kind().is_trivia())
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::test_utils::{check_action, check_action_range};
-    #[test]
-    fn test_swap_comma() {
-        check_action(
-            "fn foo(x: i32,<|> y: Result<(), ()>) {}",
-            "fn foo(y: Result<(), ()>,<|> x: i32) {}",
-            |file, off| flip_comma(file, off).map(|f| f()),
-        )
-    }
-    #[test]
-    fn add_derive_new() {
-        check_action(
-            "struct Foo { a: i32, <|>}",
-            "#[derive(<|>)]\nstruct Foo { a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
-        );
-        check_action(
-            "struct Foo { <|> a: i32, }",
-            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
-        );
-    }
-    #[test]
-    fn add_derive_existing() {
-        check_action(
-            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
-            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
-            |file, off| add_derive(file, off).map(|f| f()),
-        );
-    }
-    #[test]
-    fn add_derive_new_with_doc_comment() {
-        check_action(
-            "
-/// `Foo` is a pretty important struct.
-/// It does stuff.
-struct Foo { a: i32<|>, }
-            ",
-            "
-/// `Foo` is a pretty important struct.
-/// It does stuff.
-#[derive(<|>)]
-struct Foo { a: i32, }
-            ",
-            |file, off| add_derive(file, off).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_add_impl() {
-        check_action(
-            "struct Foo {<|>}\n",
-            "struct Foo {}\n\nimpl Foo {\n<|>\n}\n",
-            |file, off| add_impl(file, off).map(|f| f()),
-        );
-        check_action(
-            "struct Foo<T: Clone> {<|>}",
-            "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n<|>\n}",
-            |file, off| add_impl(file, off).map(|f| f()),
-        );
-        check_action(
-            "struct Foo<'a, T: Foo<'a>> {<|>}",
-            "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n<|>\n}",
-            |file, off| add_impl(file, off).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_introduce_var_simple() {
-        check_action_range(
-            "
-fn foo() {
-    foo(<|>1 + 1<|>);
-}",
-            "
-fn foo() {
-    let <|>var_name = 1 + 1;
-    foo(var_name);
-}",
-            |file, range| introduce_variable(file, range).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_introduce_var_expr_stmt() {
-        check_action_range(
-            "
-fn foo() {
-    <|>1 + 1<|>;
-}",
-            "
-fn foo() {
-    let <|>var_name = 1 + 1;
-}",
-            |file, range| introduce_variable(file, range).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_introduce_var_part_of_expr_stmt() {
-        check_action_range(
-            "
-fn foo() {
-    <|>1<|> + 1;
-}",
-            "
-fn foo() {
-    let <|>var_name = 1;
-    var_name + 1;
-}",
-            |file, range| introduce_variable(file, range).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_introduce_var_last_expr() {
-        check_action_range(
-            "
-fn foo() {
-    bar(<|>1 + 1<|>)
-}",
-            "
-fn foo() {
-    let <|>var_name = 1 + 1;
-    bar(var_name)
-}",
-            |file, range| introduce_variable(file, range).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_introduce_var_last_full_expr() {
-        check_action_range(
-            "
-fn foo() {
-    <|>bar(1 + 1)<|>
-}",
-            "
-fn foo() {
-    let <|>var_name = bar(1 + 1);
-    var_name
-}",
-            |file, range| introduce_variable(file, range).map(|f| f()),
-        );
-    }
-    #[test]
-    fn test_make_pub_crate() {
-        check_action(
-            "<|>fn foo() {}",
-            "<|>pub(crate) fn foo() {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-        check_action(
-            "f<|>n foo() {}",
-            "<|>pub(crate) fn foo() {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-        check_action(
-            "<|>struct Foo {}",
-            "<|>pub(crate) struct Foo {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-        check_action("<|>mod foo {}", "<|>pub(crate) mod foo {}", |file, off| {
-            make_pub_crate(file, off).map(|f| f())
-        });
-        check_action(
-            "<|>trait Foo {}",
-            "<|>pub(crate) trait Foo {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-        check_action("m<|>od {}", "<|>pub(crate) mod {}", |file, off| {
-            make_pub_crate(file, off).map(|f| f())
-        });
-        check_action(
-            "pub(crate) f<|>n foo() {}",
-            "pub(crate) f<|>n foo() {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-        check_action(
-            "unsafe f<|>n foo() {}",
-            "<|>pub(crate) unsafe fn foo() {}",
-            |file, off| make_pub_crate(file, off).map(|f| f()),
-        );
-    }
-}
diff --git a/crates/ra_editor/src/diagnostics.rs b/crates/ra_editor/src/diagnostics.rs
index 1b336cfe2..199b0e502 100644
--- a/crates/ra_editor/src/diagnostics.rs
+++ b/crates/ra_editor/src/diagnostics.rs
@@ -57,7 +57,7 @@ fn check_unnecessary_braces_in_use_statement(
            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(single_use_tree)
                .unwrap_or_else(|| {
                    let to_replace = single_use_tree.syntax().text().to_string();
-                    let mut edit_builder = TextEditBuilder::new();
+                    let mut edit_builder = TextEditBuilder::default();
                    edit_builder.delete(range);
                    edit_builder.insert(range.start(), to_replace);
                    edit_builder.finish()
@@ -93,7 +93,7 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
        let start = use_tree_list_node.prev_sibling()?.range().start();
        let end = use_tree_list_node.range().end();
        let range = TextRange::from_to(start, end);
-        let mut edit_builder = TextEditBuilder::new();
+        let mut edit_builder = TextEditBuilder::default();
        edit_builder.delete(range);
        return Some(edit_builder.finish());
    }
@@ -111,7 +111,7 @@ fn check_struct_shorthand_initialization(
            let field_name = name_ref.syntax().text().to_string();
            let field_expr = expr.syntax().text().to_string();
            if field_name == field_expr {
-                let mut edit_builder = TextEditBuilder::new();
+                let mut edit_builder = TextEditBuilder::default();
                edit_builder.delete(named_field.syntax().range());
                edit_builder.insert(named_field.syntax().range().start(), field_name);
                let edit = edit_builder.finish();
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index bfc745e58..ac283e2e0 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -1,4 +1,4 @@
-mod code_actions;
+pub mod assists;
 mod extend_selection;
 mod folding_ranges;
 mod line_index;
@@ -10,7 +10,7 @@ mod typing;
 mod diagnostics;
 pub use self::{
-    code_actions::{add_derive, add_impl, flip_comma, introduce_variable, make_pub_crate, LocalEdit},
+    assists::LocalEdit,
    extend_selection::extend_selection,
    folding_ranges::{folding_ranges, Fold, FoldKind},
    line_index::{LineCol, LineIndex},
@@ -19,7 +19,7 @@ pub use self::{
    typing::{join_lines, on_enter, on_eq_typed},
    diagnostics::diagnostics
 };
-use ra_text_edit::{TextEdit, TextEditBuilder};
+use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
    algo::find_leaf_at_offset,
    ast::{self, AstNode},
diff --git a/crates/ra_editor/src/structure.rs b/crates/ra_editor/src/structure.rs
index 2292b1ddf..32d59e335 100644
--- a/crates/ra_editor/src/structure.rs
+++ b/crates/ra_editor/src/structure.rs
@@ -60,7 +60,7 @@ fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
        .visit(decl::<ast::TypeDef>)
        .visit(decl::<ast::ConstDef>)
        .visit(decl::<ast::StaticDef>)
-        .visit(|im: ast::ImplItem| {
+        .visit(|im: ast::ImplBlock| {
            let target_type = im.target_type()?;
            let target_trait = im.target_trait();
            let label = match target_trait {
@@ -121,8 +121,8 @@ impl fmt::Debug for E {}
                StructureNode { parent: None, label: "T", navigation_range: [81; 82), node_range: [76; 88), kind: TYPE_DEF },
                StructureNode { parent: None, label: "S", navigation_range: [96; 97), node_range: [89; 108), kind: STATIC_DEF },
                StructureNode { parent: None, label: "C", navigation_range: [115; 116), node_range: [109; 127), kind: CONST_DEF },
-                StructureNode { parent: None, label: "impl E", navigation_range: [134; 135), node_range: [129; 138), kind: IMPL_ITEM },
+                StructureNode { parent: None, label: "impl E", navigation_range: [134; 135), node_range: [129; 138), kind: IMPL_BLOCK },
-                StructureNode { parent: None, label: "impl fmt::Debug for E", navigation_range: [160; 161), node_range: [140; 164), kind: IMPL_ITEM }]"#,
+                StructureNode { parent: None, label: "impl fmt::Debug for E", navigation_range: [160; 161), node_range: [140; 164), kind: IMPL_BLOCK }]"#,
            &structure,
        )
    }
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 21d068a7b..1b568e96c 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -21,7 +21,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
            None => {
                return LocalEdit {
                    label: "join lines".to_string(),
-                    edit: TextEditBuilder::new().finish(),
+                    edit: TextEditBuilder::default().finish(),
                    cursor_position: None,
                };
            }
@@ -33,7 +33,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
    };
    let node = find_covering_node(file.syntax(), range);
-    let mut edit = TextEditBuilder::new();
+    let mut edit = TextEditBuilder::default();
    for node in node.descendants() {
        let text = match node.leaf_text() {
            Some(text) => text,
@@ -76,7 +76,7 @@ pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
    let indent = node_indent(file, comment.syntax())?;
    let inserted = format!("\n{}{} ", indent, prefix);
    let cursor_position = offset + TextUnit::of_str(&inserted);
-    let mut edit = TextEditBuilder::new();
+    let mut edit = TextEditBuilder::default();
    edit.insert(offset, inserted);
    Some(LocalEdit {
        label: "on enter".to_string(),
@@ -127,7 +127,7 @@ pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit>
        return None;
    }
    let offset = let_stmt.syntax().range().end();
-    let mut edit = TextEditBuilder::new();
+    let mut edit = TextEditBuilder::default();
    edit.insert(offset, ";".to_string());
    Some(LocalEdit {
        label: "add semicolon".to_string(),
@@ -188,10 +188,14 @@ fn remove_newline(
        edit.delete(TextRange::from_to(prev.range().start(), node.range().end()));
    } else if prev.kind() == COMMA && next.kind() == R_CURLY {
        // Removes: comma, newline (incl. surrounding whitespace)
-        // Adds: a single whitespace
+        let space = if let Some(left) = prev.prev_sibling() {
+            compute_ws(left, next)
+        } else {
+            " "
+        };
        edit.replace(
            TextRange::from_to(prev.range().start(), node.range().end()),
-            " ".to_string(),
+            space.to_string(),
        );
    } else if let (Some(_), Some(next)) = (ast::Comment::cast(prev), ast::Comment::cast(next)) {
        // Removes: newline (incl. surrounding whitespace), start of the next comment
@@ -256,10 +260,20 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Opti
 fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
    match left.kind() {
        L_PAREN | L_BRACK => return "",
+        L_CURLY => {
+            if let USE_TREE = right.kind() {
+                return "";
+            }
+        }
        _ => (),
    }
    match right.kind() {
        R_PAREN | R_BRACK => return "",
+        R_CURLY => {
+            if let USE_TREE = left.kind() {
+                return "";
+            }
+        }
        DOT => return "",
        _ => (),
    }
@@ -331,6 +345,48 @@ fn foo() {
    }
    #[test]
+    fn test_join_lines_use_items_left() {
+        // No space after the '{'
+        check_join_lines(
+            r"
+<|>use ra_syntax::{
+    TextUnit, TextRange,
+};",
+            r"
+<|>use ra_syntax::{TextUnit, TextRange,
+};",
+        );
+    }
+    #[test]
+    fn test_join_lines_use_items_right() {
+        // No space after the '}'
+        check_join_lines(
+            r"
+use ra_syntax::{
+<|>    TextUnit, TextRange
+};",
+            r"
+use ra_syntax::{
+<|>    TextUnit, TextRange};",
+        );
+    }
+    #[test]
+    fn test_join_lines_use_items_right_comma() {
+        // No space after the '}'
+        check_join_lines(
+            r"
+use ra_syntax::{
+<|>    TextUnit, TextRange,
+};",
+            r"
+use ra_syntax::{
+<|>    TextUnit, TextRange};",
+        );
+    }
+    #[test]
    fn test_join_lines_use_tree() {
        check_join_lines(
            r"
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index c3fbd327d..245a21ce3 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -8,12 +8,12 @@ authors = ["Aleksey Kladov <[email protected]>"]
 arrayvec = "0.4.10"
 log = "0.4.5"
 relative-path = "0.4.0"
-salsa = "0.9.0"
+salsa = "0.9.1"
 rustc-hash = "1.0"
 parking_lot = "0.7.0"
-id-arena = "2.0"
 ena = "0.11"
 ra_syntax = { path = "../ra_syntax" }
+ra_arena = { path = "../ra_arena" }
 ra_editor = { path = "../ra_editor" }
 ra_db = { path = "../ra_db" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_hir/src/arena.rs b/crates/ra_hir/src/arena.rs
deleted file mode 100644
index d4f9d9cb9..000000000
--- a/crates/ra_hir/src/arena.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! A simple id-based arena, similar to https://github.com/fitzgen/id-arena.
-//! We use our own version for more compact id's and to allow inherent impls
-//! on Ids.
-use std::{
-    fmt,
-    hash::{Hash, Hasher},
-    marker::PhantomData,
-};
-pub struct Id<T> {
-    idx: u32,
-    _ty: PhantomData<fn() -> T>,
-}
-impl<T> fmt::Debug for Id<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Id").field(&self.idx).finish()
-    }
-}
-impl<T> Copy for Id<T> {}
-impl<T> Clone for Id<T> {
-    fn clone(&self) -> Id<T> {
-        *self
-    }
-}
-impl<T> PartialEq for Id<T> {
-    fn eq(&self, other: &Id<T>) -> bool {
-        self.idx == other.idx
-    }
-}
-impl<T> Eq for Id<T> {}
-impl<T> Hash for Id<T> {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.idx.hash(h);
-    }
-}
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) struct ArenaBehavior<T> {
-    _ty: PhantomData<T>,
-}
-impl<T> id_arena::ArenaBehavior for ArenaBehavior<T> {
-    type Id = Id<T>;
-    fn new_arena_id() -> u32 {
-        0
-    }
-    fn new_id(_arena_id: u32, index: usize) -> Id<T> {
-        Id {
-            idx: index as u32,
-            _ty: PhantomData,
-        }
-    }
-    fn index(id: Id<T>) -> usize {
-        id.idx as usize
-    }
-    fn arena_id(_id: Id<T>) -> u32 {
-        0
-    }
-}
-pub(crate) type Arena<T> = id_arena::Arena<T, ArenaBehavior<T>>;
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 73a4cdc5c..58296fc6f 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -13,6 +13,7 @@ use crate::{
    nameres::{ItemMap, InputModuleItems}},
    ty::{InferenceResult, Ty},
    adt::{StructData, EnumData},
+    impl_block::ModuleImplBlocks,
 };
 salsa::query_group! {
@@ -87,6 +88,11 @@ pub trait HirDatabase: SyntaxDatabase
        type ModuleTreeQuery;
        use fn crate::module::imp::module_tree;
    }
+    fn impls_in_module(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleImplBlocks>> {
+        type ImplsInModuleQuery;
+        use fn crate::impl_block::impls_in_module;
+    }
 }
 }
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 5a44132fc..75ef308ae 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -11,11 +11,11 @@ use ra_syntax::{
    ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
-use crate::{DefId, DefKind, HirDatabase, ty::InferenceResult, Module};
+use crate::{DefId, DefKind, HirDatabase, ty::InferenceResult, Module, Crate, impl_block::ImplBlock};
 pub use self::scope::FnScopes;
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Function {
    def_id: DefId,
 }
@@ -25,6 +25,10 @@ impl Function {
        Function { def_id }
    }
+    pub fn def_id(&self) -> DefId {
+        self.def_id
+    }
    pub fn syntax(&self, db: &impl HirDatabase) -> ast::FnDefNode {
        let def_loc = self.def_id.loc(db);
        assert!(def_loc.kind == DefKind::Function);
@@ -48,6 +52,15 @@ impl Function {
    pub fn module(&self, db: &impl HirDatabase) -> Cancelable<Module> {
        self.def_id.module(db)
    }
+    pub fn krate(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
+        self.def_id.krate(db)
+    }
+    /// The containing impl block, if this is a method.
+    pub fn impl_block(&self, db: &impl HirDatabase) -> Cancelable<Option<ImplBlock>> {
+        self.def_id.impl_block(db)
+    }
 }
 #[derive(Debug, Clone)]
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 3e4cfad0c..42bfe4f32 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -5,19 +5,19 @@ use ra_syntax::{
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
 };
+use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_db::LocalSyntaxPtr;
-use crate::{
+use crate::{Name, AsName};
-    arena::{Arena, Id},
-    Name, AsName,
-};
-pub(crate) type ScopeId = Id<ScopeData>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ScopeId(RawId);
+impl_arena_id!(ScopeId);
 #[derive(Debug, PartialEq, Eq)]
 pub struct FnScopes {
    pub self_param: Option<LocalSyntaxPtr>,
-    scopes: Arena<ScopeData>,
+    scopes: Arena<ScopeId, ScopeData>,
    scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
 }
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index a09dee8b1..4d6378e02 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,10 +1,8 @@
 use ra_db::{SourceRootId, LocationIntener, Cancelable, FileId};
 use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, SourceFile, AstNode, ast};
+use ra_arena::{Arena, RawId, impl_arena_id};
-use crate::{
+use crate::{HirDatabase, PerNs, ModuleId, Module, Def, Function, Struct, Enum, ImplBlock, Crate};
-    HirDatabase, PerNs, ModuleId, Module, Def, Function, Struct, Enum,
-    arena::{Arena, Id},
-};
 /// hir makes a heavy use of ids: integer (u32) handlers to various things. You
 /// can think of id as a pointer (but without a lifetime) or a file descriptor
@@ -48,6 +46,13 @@ impl HirFileId {
        }
    }
+    pub(crate) fn as_macro_call_id(self) -> Option<MacroCallId> {
+        match self.0 {
+            HirFileIdRepr::Macro(it) => Some(it),
+            _ => None,
+        }
+    }
    pub(crate) fn hir_source_file(db: &impl HirDatabase, file_id: HirFileId) -> SourceFileNode {
        match file_id.0 {
            HirFileIdRepr::File(file_id) => db.source_file(file_id),
@@ -172,6 +177,18 @@ impl DefId {
        let loc = self.loc(db);
        Module::new(db, loc.source_root_id, loc.module_id)
    }
+    /// Returns the containing crate.
+    pub fn krate(&self, db: &impl HirDatabase) -> Cancelable<Option<Crate>> {
+        Ok(self.module(db)?.krate(db))
+    }
+    /// Returns the containing impl block, if this is an impl item.
+    pub fn impl_block(self, db: &impl HirDatabase) -> Cancelable<Option<ImplBlock>> {
+        let loc = self.loc(db);
+        let module_impls = db.impls_in_module(loc.source_root_id, loc.module_id)?;
+        Ok(ImplBlock::containing(module_impls, self))
+    }
 }
 impl DefLoc {
@@ -199,7 +216,9 @@ impl DefKind {
 /// Identifier of item within a specific file. This is stable over reparses, so
 /// it's OK to use it as a salsa key/value.
-pub(crate) type SourceFileItemId = Id<SyntaxNode>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SourceFileItemId(RawId);
+impl_arena_id!(SourceFileItemId);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SourceItemId {
@@ -212,7 +231,7 @@ pub struct SourceItemId {
 #[derive(Debug, PartialEq, Eq)]
 pub struct SourceFileItems {
    file_id: HirFileId,
-    arena: Arena<SyntaxNode>,
+    arena: Arena<SourceFileItemId, SyntaxNode>,
 }
 impl SourceFileItems {
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
new file mode 100644
index 000000000..01afa84c4
--- /dev/null
+++ b/crates/ra_hir/src/impl_block.rs
@@ -0,0 +1,180 @@
+use std::sync::Arc;
+use rustc_hash::FxHashMap;
+use ra_arena::{Arena, RawId, impl_arena_id};
+use ra_syntax::ast::{self, AstNode};
+use ra_db::{LocationIntener, Cancelable, SourceRootId};
+use crate::{
+    DefId, DefLoc, DefKind, SourceItemId, SourceFileItems,
+    Module, Function,
+    db::HirDatabase,
+    type_ref::TypeRef,
+    module::{ModuleSourceNode, ModuleId},
+};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplBlock {
+    module_impl_blocks: Arc<ModuleImplBlocks>,
+    impl_id: ImplId,
+}
+impl ImplBlock {
+    pub(crate) fn containing(
+        module_impl_blocks: Arc<ModuleImplBlocks>,
+        def_id: DefId,
+    ) -> Option<ImplBlock> {
+        let impl_id = *module_impl_blocks.impls_by_def.get(&def_id)?;
+        Some(ImplBlock {
+            module_impl_blocks,
+            impl_id,
+        })
+    }
+    fn impl_data(&self) -> &ImplData {
+        &self.module_impl_blocks.impls[self.impl_id]
+    }
+    pub fn target_trait(&self) -> Option<&TypeRef> {
+        self.impl_data().target_trait.as_ref()
+    }
+    pub fn target_type(&self) -> &TypeRef {
+        &self.impl_data().target_type
+    }
+    pub fn items(&self) -> &[ImplItem] {
+        &self.impl_data().items
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplData {
+    target_trait: Option<TypeRef>,
+    target_type: TypeRef,
+    items: Vec<ImplItem>,
+}
+impl ImplData {
+    pub(crate) fn from_ast(
+        db: &impl AsRef<LocationIntener<DefLoc, DefId>>,
+        file_items: &SourceFileItems,
+        module: &Module,
+        node: ast::ImplBlock,
+    ) -> Self {
+        let target_trait = node.target_type().map(TypeRef::from_ast);
+        let target_type = TypeRef::from_ast_opt(node.target_type());
+        let file_id = module.source().file_id();
+        let items = if let Some(item_list) = node.item_list() {
+            item_list
+                .impl_items()
+                .map(|item_node| {
+                    let kind = match item_node {
+                        ast::ImplItem::FnDef(..) => DefKind::Function,
+                        ast::ImplItem::ConstDef(..) => DefKind::Item,
+                        ast::ImplItem::TypeDef(..) => DefKind::Item,
+                    };
+                    let item_id = file_items.id_of_unchecked(item_node.syntax());
+                    let def_loc = DefLoc {
+                        kind,
+                        source_root_id: module.source_root_id,
+                        module_id: module.module_id,
+                        source_item_id: SourceItemId {
+                            file_id,
+                            item_id: Some(item_id),
+                        },
+                    };
+                    let def_id = def_loc.id(db);
+                    match item_node {
+                        ast::ImplItem::FnDef(..) => ImplItem::Method(Function::new(def_id)),
+                        ast::ImplItem::ConstDef(..) => ImplItem::Const(def_id),
+                        ast::ImplItem::TypeDef(..) => ImplItem::Type(def_id),
+                    }
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        ImplData {
+            target_trait,
+            target_type,
+            items,
+        }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ImplItem {
+    Method(Function),
+    // these don't have their own types yet
+    Const(DefId),
+    Type(DefId),
+    // Existential
+}
+impl ImplItem {
+    pub fn def_id(&self) -> DefId {
+        match self {
+            ImplItem::Method(f) => f.def_id(),
+            ImplItem::Const(def_id) => *def_id,
+            ImplItem::Type(def_id) => *def_id,
+        }
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ImplId(pub RawId);
+impl_arena_id!(ImplId);
+/// Collection of impl blocks is a two-step process: First we collect the blocks
+/// per-module; then we build an index of all impl blocks in the crate. This
+/// way, we avoid having to do this process for the whole crate whenever someone
+/// types in any file; as long as the impl blocks in the file don't change, we
+/// don't need to do the second step again.
+///
+/// (The second step does not yet exist currently.)
+#[derive(Debug, PartialEq, Eq)]
+pub struct ModuleImplBlocks {
+    impls: Arena<ImplId, ImplData>,
+    impls_by_def: FxHashMap<DefId, ImplId>,
+}
+impl ModuleImplBlocks {
+    fn new() -> Self {
+        ModuleImplBlocks {
+            impls: Arena::default(),
+            impls_by_def: FxHashMap::default(),
+        }
+    }
+    fn collect(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> {
+        let module_source_node = module.source().resolve(db);
+        let node = match &module_source_node {
+            ModuleSourceNode::SourceFile(node) => node.borrowed().syntax(),
+            ModuleSourceNode::Module(node) => node.borrowed().syntax(),
+        };
+        let source_file_items = db.file_items(module.source().file_id());
+        for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) {
+            let impl_block = ImplData::from_ast(db, &source_file_items, &module, impl_block_ast);
+            let id = self.impls.alloc(impl_block);
+            for impl_item in &self.impls[id].items {
+                self.impls_by_def.insert(impl_item.def_id(), id);
+            }
+        }
+        Ok(())
+    }
+}
+pub(crate) fn impls_in_module(
+    db: &impl HirDatabase,
+    source_root_id: SourceRootId,
+    module_id: ModuleId,
+) -> Cancelable<Arc<ModuleImplBlocks>> {
+    let mut result = ModuleImplBlocks::new();
+    let module = Module::new(db, source_root_id, module_id)?;
+    result.collect(db, module)?;
+    Ok(Arc::new(result))
+}
diff --git a/crates/ra_hir/src/krate.rs b/crates/ra_hir/src/krate.rs
index a0821d15d..5194e280b 100644
--- a/crates/ra_hir/src/krate.rs
+++ b/crates/ra_hir/src/krate.rs
@@ -5,7 +5,7 @@ use crate::{HirDatabase, Module, Name, AsName, HirFileId};
 /// hir::Crate describes a single crate. It's the main inteface with which
 /// crate's dependencies interact. Mostly, it should be just a proxy for the
 /// root module.
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Crate {
    crate_id: CrateId,
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 8ee52a466..2abcec441 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -19,7 +19,6 @@ pub mod db;
 mod mock;
 mod query_definitions;
 mod path;
-mod arena;
 pub mod source_binder;
 mod ids;
@@ -32,6 +31,7 @@ mod function;
 mod adt;
 mod type_ref;
 mod ty;
+mod impl_block;
 use crate::{
    db::HirDatabase,
@@ -49,6 +49,7 @@ pub use self::{
    function::{Function, FnScopes},
    adt::{Struct, Enum},
    ty::Ty,
+    impl_block::{ImplBlock, ImplItem},
 };
 pub use self::function::FnSignatureInfo;
diff --git a/crates/ra_hir/src/macros.rs b/crates/ra_hir/src/macros.rs
index b7b75e702..1b378c977 100644
--- a/crates/ra_hir/src/macros.rs
+++ b/crates/ra_hir/src/macros.rs
@@ -21,6 +21,7 @@ use crate::{HirDatabase, MacroCallId};
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroDef {
    CTry,
+    Vec,
    QueryGroup,
 }
@@ -40,6 +41,8 @@ impl MacroDef {
            let name_ref = path.segment()?.name_ref()?;
            if name_ref.text() == "ctry" {
                MacroDef::CTry
+            } else if name_ref.text() == "vec" {
+                MacroDef::Vec
            } else if name_ref.text() == "query_group" {
                MacroDef::QueryGroup
            } else {
@@ -59,6 +62,7 @@ impl MacroDef {
    fn expand(self, input: MacroInput) -> Option<MacroExpansion> {
        match self {
            MacroDef::CTry => self.expand_ctry(input),
+            MacroDef::Vec => self.expand_vec(input),
            MacroDef::QueryGroup => self.expand_query_group(input),
        }
    }
@@ -86,6 +90,20 @@ impl MacroDef {
        };
        Some(res)
    }
+    fn expand_vec(self, input: MacroInput) -> Option<MacroExpansion> {
+        let text = format!(r"fn dummy() {{ {}; }}", input.text);
+        let file = SourceFileNode::parse(&text);
+        let array_expr = file.syntax().descendants().find_map(ast::ArrayExpr::cast)?;
+        let ptr = LocalSyntaxPtr::new(array_expr.syntax());
+        let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
+        let ranges_map = vec![(src_range, array_expr.syntax().range())];
+        let res = MacroExpansion {
+            text,
+            ranges_map,
+            ptr,
+        };
+        Some(res)
+    }
    fn expand_query_group(self, input: MacroInput) -> Option<MacroExpansion> {
        let anchor = "trait ";
        let pos = input.text.find(anchor)? + anchor.len();
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 89b18194a..a9db932ff 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -30,6 +30,10 @@ impl MockDatabase {
        let file_id = db.add_file(&mut source_root, "/main.rs", text);
        db.query_mut(ra_db::SourceRootQuery)
            .set(WORKSPACE, Arc::new(source_root.clone()));
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(file_id);
+        db.set_crate_graph(crate_graph);
        (db, source_root, file_id)
    }
@@ -203,6 +207,7 @@ salsa::database_storage! {
            fn type_for_field() for db::TypeForFieldQuery;
            fn struct_data() for db::StructDataQuery;
            fn enum_data() for db::EnumDataQuery;
+            fn impls_in_module() for db::ImplsInModuleQuery;
        }
    }
 }
diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs
index a53b69d20..b9821115c 100644
--- a/crates/ra_hir/src/module.rs
+++ b/crates/ra_hir/src/module.rs
@@ -9,6 +9,7 @@ use ra_syntax::{
    ast::{self, AstNode, NameOwner},
    SyntaxNode,
 };
+use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_db::{SourceRootId, FileId, Cancelable};
 use relative_path::RelativePathBuf;
@@ -16,7 +17,6 @@ use crate::{
    Def, DefKind, DefLoc, DefId,
    Name, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId, Crate,
    HirFileId,
-    arena::{Arena, Id},
 };
 pub use self::nameres::{ModuleScope, Resolution, Namespace, PerNs};
@@ -71,6 +71,21 @@ impl Module {
        })
    }
+    /// Returns an iterator of all children of this module.
+    pub fn children<'a>(&'a self) -> impl Iterator<Item = (Name, Module)> + 'a {
+        self.module_id
+            .children(&self.tree)
+            .map(move |(name, module_id)| {
+                (
+                    name,
+                    Module {
+                        module_id,
+                        ..self.clone()
+                    },
+                )
+            })
+    }
    /// Returns the crate this module is part of.
    pub fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
        let root_id = self.module_id.crate_root(&self.tree);
@@ -173,6 +188,14 @@ impl Module {
    }
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ModuleId(RawId);
+impl_arena_id!(ModuleId);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LinkId(RawId);
+impl_arena_id!(LinkId);
 /// Physically, rust source is organized as a set of files, but logically it is
 /// organized as a tree of modules. Usually, a single file corresponds to a
 /// single module, but it is not nessary the case.
@@ -182,8 +205,8 @@ impl Module {
 /// always have one parent).
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ModuleTree {
-    mods: Arena<ModuleData>,
+    mods: Arena<ModuleId, ModuleData>,
-    links: Arena<LinkData>,
+    links: Arena<LinkId, LinkData>,
 }
 impl ModuleTree {
@@ -210,9 +233,6 @@ pub(crate) enum ModuleSourceNode {
    Module(ast::ModuleNode),
 }
-pub type ModuleId = Id<ModuleData>;
-type LinkId = Id<LinkData>;
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum Problem {
    UnresolvedModule {
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 40aa33ffa..3c6851a0a 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -64,14 +64,14 @@ impl ModuleScope {
 /// running name resolution.
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct InputModuleItems {
-    items: Vec<ModuleItem>,
+    pub(crate) items: Vec<ModuleItem>,
    imports: Vec<Import>,
 }
 #[derive(Debug, PartialEq, Eq)]
-struct ModuleItem {
+pub(crate) struct ModuleItem {
-    id: SourceItemId,
+    pub(crate) id: SourceItemId,
-    name: Name,
+    pub(crate) name: Name,
    kind: SyntaxKind,
    vis: Vis,
 }
@@ -233,7 +233,7 @@ impl InputModuleItems {
            ast::ModuleItem::TypeDef(it) => {
                self.items.push(ModuleItem::new(file_id, file_items, it)?)
            }
-            ast::ModuleItem::ImplItem(_) => {
+            ast::ModuleItem::ImplBlock(_) => {
                // impls don't define items
            }
            ast::ModuleItem::UseItem(it) => self.add_use_item(file_items, it),
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 51e8b3da8..017caf442 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -51,6 +51,7 @@ impl Name {
            "u128" => KnownName::U128,
            "f32" => KnownName::F32,
            "f64" => KnownName::F64,
+            "Self" => KnownName::Self_,
            _ => return None,
        };
        Some(name)
@@ -84,7 +85,7 @@ impl AsName for ra_db::Dependency {
 // const ISIZE: Name = Name::new("isize")
 // ```
 // but const-fn is not that powerful yet.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum KnownName {
    Isize,
    I8,
@@ -102,4 +103,6 @@ pub(crate) enum KnownName {
    F32,
    F64,
+    Self_,
 }
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 93f7203fe..9fdfa0d13 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -70,6 +70,11 @@ impl Path {
        self.kind == PathKind::Plain && self.segments.len() == 1
    }
+    /// `true` if this path is just a standalone `self`
+    pub fn is_self(&self) -> bool {
+        self.kind == PathKind::Self_ && self.segments.len() == 0
+    }
    /// If this path is a single identifier, like `foo`, return its name.
    pub fn as_ident(&self) -> Option<&Name> {
        if self.kind != PathKind::Plain || self.segments.len() > 1 {
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 24490d119..85bd84469 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -8,8 +8,8 @@
 use ra_db::{FileId, FilePosition, Cancelable};
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
+    SmolStr, TextRange, SyntaxNodeRef,
    ast::{self, AstNode, NameOwner},
-    SyntaxNodeRef,
 };
 use crate::{
@@ -126,3 +126,40 @@ pub fn function_from_child_node(
    let fn_def = ctry!(node.ancestors().find_map(ast::FnDef::cast));
    function_from_source(db, file_id, fn_def)
 }
+pub fn macro_symbols(
+    db: &impl HirDatabase,
+    file_id: FileId,
+) -> Cancelable<Vec<(SmolStr, TextRange)>> {
+    let module = match module_from_file_id(db, file_id)? {
+        Some(it) => it,
+        None => return Ok(Vec::new()),
+    };
+    let items = db.input_module_items(module.source_root_id, module.module_id)?;
+    let mut res = Vec::new();
+    for macro_call_id in items
+        .items
+        .iter()
+        .filter_map(|it| it.id.file_id.as_macro_call_id())
+    {
+        if let Some(exp) = db.expand_macro_invocation(macro_call_id) {
+            let loc = macro_call_id.loc(db);
+            let syntax = db.file_item(loc.source_item_id);
+            let syntax = syntax.borrowed();
+            let macro_call = ast::MacroCall::cast(syntax).unwrap();
+            let off = macro_call.token_tree().unwrap().syntax().range().start();
+            let file = exp.file();
+            for trait_def in file.syntax().descendants().filter_map(ast::TraitDef::cast) {
+                if let Some(name) = trait_def.name() {
+                    let dst_range = name.syntax().range();
+                    if let Some(src_range) = exp.map_range_back(dst_range) {
+                        res.push((name.text(), src_range + off))
+                    }
+                }
+            }
+        }
+    }
+    Ok(res)
+}
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 719b3f7cd..e33762e0d 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -31,9 +31,10 @@ use ra_syntax::{
 };
 use crate::{
-    Def, DefId, FnScopes, Module, Function, Struct, Enum, Path, Name, AsName,
+    Def, DefId, FnScopes, Module, Function, Struct, Enum, Path, Name, AsName, ImplBlock,
    db::HirDatabase,
    type_ref::{TypeRef, Mutability},
+    name::KnownName,
 };
 /// The ID of a type variable.
@@ -235,6 +236,7 @@ impl Ty {
    pub(crate) fn from_hir(
        db: &impl HirDatabase,
        module: &Module,
+        impl_block: Option<&ImplBlock>,
        type_ref: &TypeRef,
    ) -> Cancelable<Self> {
        Ok(match type_ref {
@@ -242,29 +244,29 @@ impl Ty {
            TypeRef::Tuple(inner) => {
                let inner_tys = inner
                    .iter()
-                    .map(|tr| Ty::from_hir(db, module, tr))
+                    .map(|tr| Ty::from_hir(db, module, impl_block, tr))
                    .collect::<Cancelable<Vec<_>>>()?;
                Ty::Tuple(inner_tys.into())
            }
-            TypeRef::Path(path) => Ty::from_hir_path(db, module, path)?,
+            TypeRef::Path(path) => Ty::from_hir_path(db, module, impl_block, path)?,
            TypeRef::RawPtr(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
                Ty::RawPtr(Arc::new(inner_ty), *mutability)
            }
            TypeRef::Array(_inner) => Ty::Unknown, // TODO
            TypeRef::Slice(inner) => {
-                let inner_ty = Ty::from_hir(db, module, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
                Ty::Slice(Arc::new(inner_ty))
            }
            TypeRef::Reference(inner, mutability) => {
-                let inner_ty = Ty::from_hir(db, module, inner)?;
+                let inner_ty = Ty::from_hir(db, module, impl_block, inner)?;
                Ty::Ref(Arc::new(inner_ty), *mutability)
            }
            TypeRef::Placeholder => Ty::Unknown,
            TypeRef::Fn(params) => {
                let mut inner_tys = params
                    .iter()
-                    .map(|tr| Ty::from_hir(db, module, tr))
+                    .map(|tr| Ty::from_hir(db, module, impl_block, tr))
                    .collect::<Cancelable<Vec<_>>>()?;
                let return_ty = inner_tys
                    .pop()
@@ -279,9 +281,21 @@ impl Ty {
        })
    }
+    pub(crate) fn from_hir_opt(
+        db: &impl HirDatabase,
+        module: &Module,
+        impl_block: Option<&ImplBlock>,
+        type_ref: Option<&TypeRef>,
+    ) -> Cancelable<Self> {
+        type_ref
+            .map(|t| Ty::from_hir(db, module, impl_block, t))
+            .unwrap_or(Ok(Ty::Unknown))
+    }
    pub(crate) fn from_hir_path(
        db: &impl HirDatabase,
        module: &Module,
+        impl_block: Option<&ImplBlock>,
        path: &Path,
    ) -> Cancelable<Self> {
        if let Some(name) = path.as_ident() {
@@ -291,6 +305,8 @@ impl Ty {
                return Ok(Ty::Uint(uint_ty));
            } else if let Some(float_ty) = primitive::FloatTy::from_name(name) {
                return Ok(Ty::Float(float_ty));
+            } else if name.as_known_name() == Some(KnownName::Self_) {
+                return Ty::from_hir_opt(db, module, None, impl_block.map(|i| i.target_type()));
            }
        }
@@ -308,18 +324,20 @@ impl Ty {
    pub(crate) fn from_ast_opt(
        db: &impl HirDatabase,
        module: &Module,
+        impl_block: Option<&ImplBlock>,
        node: Option<ast::TypeRef>,
    ) -> Cancelable<Self> {
-        node.map(|n| Ty::from_ast(db, module, n))
+        node.map(|n| Ty::from_ast(db, module, impl_block, n))
            .unwrap_or(Ok(Ty::Unknown))
    }
    pub(crate) fn from_ast(
        db: &impl HirDatabase,
        module: &Module,
+        impl_block: Option<&ImplBlock>,
        node: ast::TypeRef,
    ) -> Cancelable<Self> {
-        Ty::from_hir(db, module, &TypeRef::from_ast(node))
+        Ty::from_hir(db, module, impl_block, &TypeRef::from_ast(node))
    }
    pub fn unit() -> Self {
@@ -402,18 +420,19 @@ impl fmt::Display for Ty {
 fn type_for_fn(db: &impl HirDatabase, f: Function) -> Cancelable<Ty> {
    let syntax = f.syntax(db);
    let module = f.module(db)?;
+    let impl_block = f.impl_block(db)?;
    let node = syntax.borrowed();
    // TODO we ignore type parameters for now
    let input = node
        .param_list()
        .map(|pl| {
            pl.params()
-                .map(|p| Ty::from_ast_opt(db, &module, p.type_ref()))
+                .map(|p| Ty::from_ast_opt(db, &module, impl_block.as_ref(), p.type_ref()))
                .collect()
        })
        .unwrap_or_else(|| Ok(Vec::new()))?;
    let output = if let Some(type_ref) = node.ret_type().and_then(|rt| rt.type_ref()) {
-        Ty::from_ast(db, &module, type_ref)?
+        Ty::from_ast(db, &module, impl_block.as_ref(), type_ref)?
    } else {
        Ty::unit()
    };
@@ -467,12 +486,13 @@ pub(super) fn type_for_field(db: &impl HirDatabase, def_id: DefId, field: Name)
        ),
    };
    let module = def_id.module(db)?;
+    let impl_block = def_id.impl_block(db)?;
    let type_ref = if let Some(tr) = variant_data.get_field_type_ref(&field) {
        tr
    } else {
        return Ok(Ty::Unknown);
    };
-    Ty::from_hir(db, &module, &type_ref)
+    Ty::from_hir(db, &module, impl_block.as_ref(), &type_ref)
 }
 /// The result of type inference: A mapping from expressions and patterns to types.
@@ -496,19 +516,32 @@ impl InferenceResult {
 struct InferenceContext<'a, D: HirDatabase> {
    db: &'a D,
    scopes: Arc<FnScopes>,
+    /// The self param for the current method, if it exists.
+    self_param: Option<LocalSyntaxPtr>,
    module: Module,
+    impl_block: Option<ImplBlock>,
    var_unification_table: InPlaceUnificationTable<TypeVarId>,
    type_of: FxHashMap<LocalSyntaxPtr, Ty>,
+    /// The return type of the function being inferred.
+    return_ty: Ty,
 }
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
-    fn new(db: &'a D, scopes: Arc<FnScopes>, module: Module) -> Self {
+    fn new(
+        db: &'a D,
+        scopes: Arc<FnScopes>,
+        module: Module,
+        impl_block: Option<ImplBlock>,
+    ) -> Self {
        InferenceContext {
            type_of: FxHashMap::default(),
            var_unification_table: InPlaceUnificationTable::new(),
+            self_param: None,       // set during parameter typing
+            return_ty: Ty::Unknown, // set in collect_fn_signature
            db,
            scopes,
            module,
+            impl_block,
        }
    }
@@ -525,6 +558,14 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.type_of.insert(LocalSyntaxPtr::new(node), ty);
    }
+    fn make_ty(&self, type_ref: &TypeRef) -> Cancelable<Ty> {
+        Ty::from_hir(self.db, &self.module, self.impl_block.as_ref(), type_ref)
+    }
+    fn make_ty_opt(&self, type_ref: Option<&TypeRef>) -> Cancelable<Ty> {
+        Ty::from_hir_opt(self.db, &self.module, self.impl_block.as_ref(), type_ref)
+    }
    fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
        match (ty1, ty2) {
            (Ty::Unknown, ..) => true,
@@ -628,6 +669,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let ty = self.resolve_ty_as_possible(ty.clone());
                return Ok(Some(ty));
            };
+        } else if path.is_self() {
+            // resolve `self` param
+            let self_param = ctry!(self.self_param);
+            let ty = ctry!(self.type_of.get(&self_param));
+            let ty = self.resolve_ty_as_possible(ty.clone());
+            return Ok(Some(ty));
        };
        // resolve in module
@@ -826,7 +873,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            }
            ast::Expr::CastExpr(e) => {
                let _inner_ty = self.infer_expr_opt(e.expr(), &Expectation::none())?;
-                let cast_ty = Ty::from_ast_opt(self.db, &self.module, e.type_ref())?;
+                let cast_ty = Ty::from_ast_opt(
+                    self.db,
+                    &self.module,
+                    self.impl_block.as_ref(),
+                    e.type_ref(),
+                )?;
                let cast_ty = self.insert_type_vars(cast_ty);
                // TODO do the coercion...
                cast_ty
@@ -880,7 +932,12 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        for stmt in node.statements() {
            match stmt {
                ast::Stmt::LetStmt(stmt) => {
-                    let decl_ty = Ty::from_ast_opt(self.db, &self.module, stmt.type_ref())?;
+                    let decl_ty = Ty::from_ast_opt(
+                        self.db,
+                        &self.module,
+                        self.impl_block.as_ref(),
+                        stmt.type_ref(),
+                    )?;
                    let decl_ty = self.insert_type_vars(decl_ty);
                    let ty = if let Some(expr) = stmt.initializer() {
                        let expr_ty = self.infer_expr(expr, &Expectation::has_type(decl_ty))?;
@@ -906,46 +963,71 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.write_ty(node.syntax(), ty.clone());
        Ok(ty)
    }
+    fn collect_fn_signature(&mut self, node: ast::FnDef) -> Cancelable<()> {
+        if let Some(param_list) = node.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                let self_type = if let Some(type_ref) = self_param.type_ref() {
+                    let ty = self.make_ty(&TypeRef::from_ast(type_ref))?;
+                    self.insert_type_vars(ty)
+                } else {
+                    // TODO this should be handled by desugaring during HIR conversion
+                    let ty = self.make_ty_opt(self.impl_block.as_ref().map(|i| i.target_type()))?;
+                    let ty = match self_param.flavor() {
+                        ast::SelfParamFlavor::Owned => ty,
+                        ast::SelfParamFlavor::Ref => Ty::Ref(Arc::new(ty), Mutability::Shared),
+                        ast::SelfParamFlavor::MutRef => Ty::Ref(Arc::new(ty), Mutability::Mut),
+                    };
+                    self.insert_type_vars(ty)
+                };
+                if let Some(self_kw) = self_param.self_kw() {
+                    let self_param = LocalSyntaxPtr::new(self_kw.syntax());
+                    self.self_param = Some(self_param);
+                    self.type_of.insert(self_param, self_type);
+                }
+            }
+            for param in param_list.params() {
+                let pat = if let Some(pat) = param.pat() {
+                    pat
+                } else {
+                    continue;
+                };
+                let ty = if let Some(type_ref) = param.type_ref() {
+                    let ty = self.make_ty(&TypeRef::from_ast(type_ref))?;
+                    self.insert_type_vars(ty)
+                } else {
+                    // missing type annotation
+                    self.new_type_var()
+                };
+                self.type_of.insert(LocalSyntaxPtr::new(pat.syntax()), ty);
+            }
+        }
+        self.return_ty = if let Some(type_ref) = node.ret_type().and_then(|n| n.type_ref()) {
+            let ty = self.make_ty(&TypeRef::from_ast(type_ref))?;
+            self.insert_type_vars(ty)
+        } else {
+            Ty::unit()
+        };
+        Ok(())
+    }
 }
 pub fn infer(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<InferenceResult>> {
    let function = Function::new(def_id); // TODO: consts also need inference
    let scopes = function.scopes(db);
    let module = function.module(db)?;
-    let mut ctx = InferenceContext::new(db, scopes, module);
+    let impl_block = function.impl_block(db)?;
+    let mut ctx = InferenceContext::new(db, scopes, module, impl_block);
    let syntax = function.syntax(db);
    let node = syntax.borrowed();
-    if let Some(param_list) = node.param_list() {
+    ctx.collect_fn_signature(node)?;
-        for param in param_list.params() {
-            let pat = if let Some(pat) = param.pat() {
-                pat
-            } else {
-                continue;
-            };
-            if let Some(type_ref) = param.type_ref() {
-                let ty = Ty::from_ast(db, &ctx.module, type_ref)?;
-                let ty = ctx.insert_type_vars(ty);
-                ctx.type_of.insert(LocalSyntaxPtr::new(pat.syntax()), ty);
-            } else {
-                // TODO self param
-                let type_var = ctx.new_type_var();
-                ctx.type_of
-                    .insert(LocalSyntaxPtr::new(pat.syntax()), type_var);
-            };
-        }
-    }
-    let ret_ty = if let Some(type_ref) = node.ret_type().and_then(|n| n.type_ref()) {
-        let ty = Ty::from_ast(db, &ctx.module, type_ref)?;
-        ctx.insert_type_vars(ty)
-    } else {
-        Ty::unit()
-    };
    if let Some(block) = node.body() {
-        ctx.infer_block(block, &Expectation::has_type(ret_ty))?;
+        ctx.infer_block(block, &Expectation::has_type(ctx.return_ty.clone()))?;
    }
    Ok(Arc::new(ctx.resolve_all()))
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 93bf431c4..fb53fcf0b 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -134,6 +134,25 @@ fn test() -> &mut &f64 {
    );
 }
+#[test]
+fn infer_self() {
+    check_inference(
+        r#"
+struct S;
+impl S {
+    fn test(&self) {
+        self;
+    }
+    fn test2(self: &Self) {
+        self;
+    }
+}
+"#,
+        "0007_self.txt",
+    );
+}
 fn infer(content: &str) -> String {
    let (db, _, file_id) = MockDatabase::with_single_file(content);
    let source_file = db.source_file(file_id);
diff --git a/crates/ra_hir/src/ty/tests/data/0007_self.txt b/crates/ra_hir/src/ty/tests/data/0007_self.txt
new file mode 100644
index 000000000..db4ba17d0
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/0007_self.txt
@@ -0,0 +1,6 @@
+[50; 54) 'self': &S
+[34; 38) 'self': &S
+[40; 61) '{     ...     }': ()
+[88; 109) '{     ...     }': ()
+[98; 102) 'self': &S
+[75; 79) 'self': &S
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 1107ffc8b..e8eb3940f 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -1,11 +1,16 @@
 use languageserver_types::{
-    self, Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
+    self, CreateFile, DocumentChangeOperation, DocumentChanges, InsertTextFormat, Location,
-    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, InsertTextFormat,
+    Position, Range, RenameFile, ResourceOp, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
+    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    WorkspaceEdit,
 };
-use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition,FileRange,  CompletionItem, CompletionItemKind, InsertText, NavigationTarget};
+use ra_analysis::{
-use ra_editor::{LineCol, LineIndex, translate_offset_with_edit};
+    CompletionItem, CompletionItemKind, FileId, FilePosition, FileRange, FileSystemEdit,
-use ra_text_edit::{AtomTextEdit, TextEdit};
+    InsertText, NavigationTarget, SourceChange, SourceFileEdit,
+};
+use ra_editor::{translate_offset_with_edit, LineCol, LineIndex};
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
+use ra_text_edit::{AtomTextEdit, TextEdit};
 use crate::{req, server_world::ServerWorld, Result};
@@ -39,7 +44,7 @@ impl Conv for SyntaxKind {
            SyntaxKind::TYPE_DEF => SymbolKind::TypeParameter,
            SyntaxKind::STATIC_DEF => SymbolKind::Constant,
            SyntaxKind::CONST_DEF => SymbolKind::Constant,
-            SyntaxKind::IMPL_ITEM => SymbolKind::Object,
+            SyntaxKind::IMPL_BLOCK => SymbolKind::Object,
            _ => SymbolKind::Variable,
        }
    }
@@ -49,7 +54,7 @@ impl Conv for CompletionItemKind {
    type Output = ::languageserver_types::CompletionItemKind;
    fn conv(self) -> <Self as Conv>::Output {
-        use ::languageserver_types::CompletionItemKind::*;
+        use languageserver_types::CompletionItemKind::*;
        match self {
            CompletionItemKind::Keyword => Keyword,
            CompletionItemKind::Snippet => Snippet,
@@ -266,12 +271,20 @@ impl TryConvWith for SourceChange {
                })
            }
        };
-        let source_file_edits = self.source_file_edits.try_conv_with(world)?;
+        let mut document_changes: Vec<DocumentChangeOperation> = Vec::new();
-        let file_system_edits = self.file_system_edits.try_conv_with(world)?;
+        for resource_op in self.file_system_edits.try_conv_with(world)? {
+            document_changes.push(DocumentChangeOperation::Op(resource_op));
+        }
+        for text_document_edit in self.source_file_edits.try_conv_with(world)? {
+            document_changes.push(DocumentChangeOperation::Edit(text_document_edit));
+        }
+        let workspace_edit = WorkspaceEdit {
+            changes: None,
+            document_changes: Some(DocumentChanges::Operations(document_changes)),
+        };
        Ok(req::SourceChange {
            label: self.label,
-            source_file_edits,
+            workspace_edit,
-            file_system_edits,
            cursor_position,
        })
    }
@@ -301,21 +314,25 @@ impl TryConvWith for SourceFileEdit {
 impl TryConvWith for FileSystemEdit {
    type Ctx = ServerWorld;
-    type Output = req::FileSystemEdit;
+    type Output = ResourceOp;
-    fn try_conv_with(self, world: &ServerWorld) -> Result<req::FileSystemEdit> {
+    fn try_conv_with(self, world: &ServerWorld) -> Result<ResourceOp> {
        let res = match self {
            FileSystemEdit::CreateFile { source_root, path } => {
-                let uri = world.path_to_uri(source_root, &path)?;
+                let uri = world.path_to_uri(source_root, &path)?.to_string();
-                req::FileSystemEdit::CreateFile { uri }
+                ResourceOp::Create(CreateFile { uri, options: None })
            }
            FileSystemEdit::MoveFile {
                src,
                dst_source_root,
                dst_path,
            } => {
-                let src = world.file_id_to_uri(src)?;
+                let old_uri = world.file_id_to_uri(src)?.to_string();
-                let dst = world.path_to_uri(dst_source_root, &dst_path)?;
+                let new_uri = world.path_to_uri(dst_source_root, &dst_path)?.to_string();
-                req::FileSystemEdit::MoveFile { src, dst }
+                ResourceOp::Rename(RenameFile {
+                    old_uri,
+                    new_uri,
+                    options: None,
+                })
            }
        };
        Ok(res)
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 06dd373c0..60d9671de 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -350,7 +350,7 @@ fn on_notification(
                .write()
                .add_file_overlay(&path, params.text_document.text)
            {
-                subs.add_sub(FileId(file_id.0));
+                subs.add_sub(FileId(file_id.0.into()));
            }
            return Ok(());
        }
@@ -379,7 +379,7 @@ fn on_notification(
                .to_file_path()
                .map_err(|()| format_err!("invalid uri: {}", uri))?;
            if let Some(file_id) = state.vfs.write().remove_file_overlay(path.as_path()) {
-                subs.remove_sub(FileId(file_id.0));
+                subs.remove_sub(FileId(file_id.0.into()));
            }
            let params = req::PublishDiagnosticsParams {
                uri,
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 06ae9a64a..2fc4d3649 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -337,7 +337,10 @@ pub fn handle_runnables(
                None => return Ok(None),
            };
            let file_id = world.analysis().crate_root(crate_id)?;
-            let path = world.vfs.read().file2path(ra_vfs::VfsFile(file_id.0));
+            let path = world
+                .vfs
+                .read()
+                .file2path(ra_vfs::VfsFile(file_id.0.into()));
            let res = world.workspaces.iter().find_map(|ws| {
                let tgt = ws.target_by_root(&path)?;
                let res = CargoTargetSpec {
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 747ab8a8c..b41e90328 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -1,6 +1,6 @@
-use serde::{Serialize, Deserialize};
 use languageserver_types::{Location, Position, Range, TextDocumentIdentifier, Url};
 use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
 use url_serde;
 pub use languageserver_types::{
@@ -8,7 +8,7 @@ pub use languageserver_types::{
    CompletionResponse, DocumentOnTypeFormattingParams, DocumentSymbolParams,
    DocumentSymbolResponse, ExecuteCommandParams, Hover, InitializeResult,
    PublishDiagnosticsParams, ReferenceParams, SignatureHelp, TextDocumentEdit,
-    TextDocumentPositionParams, TextEdit, WorkspaceSymbolParams,
+    TextDocumentPositionParams, TextEdit, WorkspaceEdit, WorkspaceSymbolParams,
 };
 pub enum SyntaxTree {}
@@ -151,26 +151,10 @@ pub struct Runnable {
 #[serde(rename_all = "camelCase")]
 pub struct SourceChange {
    pub label: String,
-    pub source_file_edits: Vec<TextDocumentEdit>,
+    pub workspace_edit: WorkspaceEdit,
-    pub file_system_edits: Vec<FileSystemEdit>,
    pub cursor_position: Option<TextDocumentPositionParams>,
 }
-#[derive(Serialize, Debug)]
-#[serde(tag = "type", rename_all = "camelCase")]
-pub enum FileSystemEdit {
-    CreateFile {
-        #[serde(with = "url_serde")]
-        uri: Url,
-    },
-    MoveFile {
-        #[serde(with = "url_serde")]
-        src: Url,
-        #[serde(with = "url_serde")]
-        dst: Url,
-    },
-}
 pub enum InternalFeedback {}
 impl Notification for InternalFeedback {
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index c183c25af..ebf2b15cc 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -49,7 +49,7 @@ impl ServerWorldState {
        let (mut vfs, roots) = Vfs::new(roots);
        for r in roots {
            let is_local = vfs.root2path(r).starts_with(&root);
-            change.add_root(SourceRootId(r.0), is_local);
+            change.add_root(SourceRootId(r.0.into()), is_local);
        }
        let mut crate_graph = CrateGraph::default();
@@ -60,7 +60,7 @@ impl ServerWorldState {
                for tgt in pkg.targets(ws) {
                    let root = tgt.root(ws);
                    if let Some(file_id) = vfs.load(root) {
-                        let file_id = FileId(file_id.0);
+                        let file_id = FileId(file_id.0.into());
                        let crate_id = crate_graph.add_crate_root(file_id);
                        if tgt.kind(ws) == TargetKind::Lib {
                            pkg_to_lib_crate.insert(pkg, crate_id);
@@ -113,14 +113,19 @@ impl ServerWorldState {
                    if root_path.starts_with(&self.root) {
                        self.roots_to_scan -= 1;
                        for (file, path, text) in files {
-                            change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
+                            change.add_file(
+                                SourceRootId(root.0.into()),
+                                FileId(file.0.into()),
+                                path,
+                                text,
+                            );
                        }
                    } else {
                        let files = files
                            .into_iter()
-                            .map(|(vfsfile, path, text)| (FileId(vfsfile.0), path, text))
+                            .map(|(vfsfile, path, text)| (FileId(vfsfile.0.into()), path, text))
                            .collect();
-                        libs.push((SourceRootId(root.0), files));
+                        libs.push((SourceRootId(root.0.into()), files));
                    }
                }
                VfsChange::AddFile {
@@ -129,13 +134,18 @@ impl ServerWorldState {
                    path,
                    text,
                } => {
-                    change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
+                    change.add_file(
+                        SourceRootId(root.0.into()),
+                        FileId(file.0.into()),
+                        path,
+                        text,
+                    );
                }
                VfsChange::RemoveFile { root, file, path } => {
-                    change.remove_file(SourceRootId(root.0), FileId(file.0), path)
+                    change.remove_file(SourceRootId(root.0.into()), FileId(file.0.into()), path)
                }
                VfsChange::ChangeFile { file, text } => {
-                    change.change_file(FileId(file.0), text);
+                    change.change_file(FileId(file.0.into()), text);
                }
            }
        }
@@ -173,18 +183,18 @@ impl ServerWorld {
            .read()
            .path2file(&path)
            .ok_or_else(|| format_err!("unknown file: {}", path.display()))?;
-        Ok(FileId(file.0))
+        Ok(FileId(file.0.into()))
    }
    pub fn file_id_to_uri(&self, id: FileId) -> Result<Url> {
-        let path = self.vfs.read().file2path(VfsFile(id.0));
+        let path = self.vfs.read().file2path(VfsFile(id.0.into()));
        let url = Url::from_file_path(&path)
            .map_err(|_| format_err!("can't convert path to url: {}", path.display()))?;
        Ok(url)
    }
    pub fn path_to_uri(&self, root: SourceRootId, path: &RelativePathBuf) -> Result<Url> {
-        let base = self.vfs.read().root2path(VfsRoot(root.0));
+        let base = self.vfs.read().root2path(VfsRoot(root.0.into()));
        let path = path.to_path(base);
        let url = Url::from_file_path(&path)
            .map_err(|_| format_err!("can't convert path to url: {}", path.display()))?;
diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index b0e1e65b6..4cae44eab 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -1,8 +1,12 @@
 mod support;
+use languageserver_types::{
+    CodeActionContext, DocumentFormattingParams, FormattingOptions, Position, Range,
+};
+use ra_lsp_server::req::{
+    CodeActionParams, CodeActionRequest, Formatting, Runnables, RunnablesParams,
+};
 use serde_json::json;
-use ra_lsp_server::req::{Runnables, RunnablesParams, CodeActionRequest, CodeActionParams, Formatting};
-use languageserver_types::{Position, Range, CodeActionContext, DocumentFormattingParams, FormattingOptions};
 use crate::support::project;
@@ -203,14 +207,15 @@ fn main() {}
              "arguments": [
                {
                  "cursorPosition": null,
-                  "fileSystemEdits": [
+                  "workspaceEdit": {
-                    {
+                    "documentChanges": [
-                        "type": "createFile",
+                      {
+                        "kind": "create",
                        "uri": "file:///[..]/src/bar.rs"
-                    }
+                      }
-                  ],
+                    ]
-                  "label": "create module",
+                  },
-                  "sourceFileEdits": []
+                  "label": "create module"
                }
              ],
              "command": "ra-lsp.applySourceChange",
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 3e948800e..c10169d90 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -30,6 +30,12 @@ pub trait NameOwner<'a>: AstNode<'a> {
    }
 }
+pub trait VisibilityOwner<'a>: AstNode<'a> {
+    fn visibility(self) -> Option<Visibility<'a>> {
+        child_opt(self)
+    }
+}
 pub trait LoopBodyOwner<'a>: AstNode<'a> {
    fn loop_body(self) -> Option<Block<'a>> {
        child_opt(self)
@@ -109,6 +115,7 @@ pub trait DocCommentsOwner<'a>: AstNode<'a> {
    /// That is, strips leading `///` and joins lines
    fn doc_comment_text(self) -> RustString {
        self.doc_comments()
+            .filter(|comment| comment.is_doc_comment())
            .map(|comment| {
                let prefix = comment.prefix();
                let trimmed = comment
@@ -200,6 +207,10 @@ impl<'a> Comment<'a> {
        }
    }
+    pub fn is_doc_comment(&self) -> bool {
+        self.flavor().is_doc_comment()
+    }
    pub fn prefix(&self) -> &'static str {
        self.flavor().prefix()
    }
@@ -231,6 +242,13 @@ impl CommentFlavor {
            Multiline => "/*",
        }
    }
+    pub fn is_doc_comment(&self) -> bool {
+        match self {
+            CommentFlavor::Doc | CommentFlavor::ModuleDoc => true,
+            _ => false,
+        }
+    }
 }
 impl<'a> Whitespace<'a> {
@@ -261,7 +279,7 @@ impl<'a> NameRef<'a> {
    }
 }
-impl<'a> ImplItem<'a> {
+impl<'a> ImplBlock<'a> {
    pub fn target_type(self) -> Option<TypeRef<'a>> {
        match self.target() {
            (Some(t), None) | (_, Some(t)) => Some(t),
@@ -345,6 +363,12 @@ impl<'a> PathSegment<'a> {
    }
 }
+impl<'a> Path<'a> {
+    pub fn parent_path(self) -> Option<Path<'a>> {
+        self.syntax().parent().and_then(Path::cast)
+    }
+}
 impl<'a> UseTree<'a> {
    pub fn has_star(self) -> bool {
        self.syntax().children().any(|it| it.kind() == STAR)
@@ -463,3 +487,47 @@ impl<'a> PrefixExpr<'a> {
        }
    }
 }
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum SelfParamFlavor {
+    /// self
+    Owned,
+    /// &self
+    Ref,
+    /// &mut self
+    MutRef,
+}
+impl<'a> SelfParam<'a> {
+    pub fn flavor(&self) -> SelfParamFlavor {
+        let borrowed = self.syntax().children().any(|n| n.kind() == AMP);
+        if borrowed {
+            // check for a `mut` coming after the & -- `mut &self` != `&mut self`
+            if self
+                .syntax()
+                .children()
+                .skip_while(|n| n.kind() != AMP)
+                .any(|n| n.kind() == MUT_KW)
+            {
+                SelfParamFlavor::MutRef
+            } else {
+                SelfParamFlavor::Ref
+            }
+        } else {
+            SelfParamFlavor::Owned
+        }
+    }
+}
+#[test]
+fn test_doc_comment_of_items() {
+    let file = SourceFileNode::parse(
+        r#"
+        //! doc
+        // non-doc
+        mod foo {}
+        "#,
+    );
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("doc", module.doc_comment_text());
+}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index c5ac90a62..7df6a9c46 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -695,6 +695,7 @@ impl<R: TreeRoot<RaTypes>> ConstDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::NameOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {}
@@ -810,6 +811,7 @@ impl<R: TreeRoot<RaTypes>> EnumDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
@@ -1213,6 +1215,7 @@ impl<R: TreeRoot<RaTypes>> FnDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for FnDef<'a> {}
 impl<'a> ast::NameOwner<'a> for FnDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {}
@@ -1404,40 +1407,72 @@ impl<'a> IfExpr<'a> {
    }
 }
-// ImplItem
+// ImplBlock
 #[derive(Debug, Clone, Copy,)]
-pub struct ImplItemNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+pub struct ImplBlockNode<R: TreeRoot<RaTypes> = OwnedRoot> {
    pub(crate) syntax: SyntaxNode<R>,
 }
-pub type ImplItem<'a> = ImplItemNode<RefRoot<'a>>;
+pub type ImplBlock<'a> = ImplBlockNode<RefRoot<'a>>;
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplItemNode<R1>> for ImplItemNode<R2> {
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ImplBlockNode<R1>> for ImplBlockNode<R2> {
-    fn eq(&self, other: &ImplItemNode<R1>) -> bool { self.syntax == other.syntax }
+    fn eq(&self, other: &ImplBlockNode<R1>) -> bool { self.syntax == other.syntax }
 }
-impl<R: TreeRoot<RaTypes>> Eq for ImplItemNode<R> {}
+impl<R: TreeRoot<RaTypes>> Eq for ImplBlockNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ImplItemNode<R> {
+impl<R: TreeRoot<RaTypes>> Hash for ImplBlockNode<R> {
    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
 }
-impl<'a> AstNode<'a> for ImplItem<'a> {
+impl<'a> AstNode<'a> for ImplBlock<'a> {
    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
        match syntax.kind() {
-            IMPL_ITEM => Some(ImplItem { syntax }),
+            IMPL_BLOCK => Some(ImplBlock { syntax }),
            _ => None,
        }
    }
    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
 }
-impl<R: TreeRoot<RaTypes>> ImplItemNode<R> {
+impl<R: TreeRoot<RaTypes>> ImplBlockNode<R> {
-    pub fn borrowed(&self) -> ImplItem {
+    pub fn borrowed(&self) -> ImplBlock {
-        ImplItemNode { syntax: self.syntax.borrowed() }
+        ImplBlockNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> ImplBlockNode {
+        ImplBlockNode { syntax: self.syntax.owned() }
    }
-    pub fn owned(&self) -> ImplItemNode {
+}
-        ImplItemNode { syntax: self.syntax.owned() }
+impl<'a> ImplBlock<'a> {
+    pub fn item_list(self) -> Option<ItemList<'a>> {
+        super::child_opt(self)
    }
 }
+// ImplItem
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImplItem<'a> {
+    FnDef(FnDef<'a>),
+    TypeDef(TypeDef<'a>),
+    ConstDef(ConstDef<'a>),
+}
+impl<'a> AstNode<'a> for ImplItem<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            FN_DEF => Some(ImplItem::FnDef(FnDef { syntax })),
+            TYPE_DEF => Some(ImplItem::TypeDef(TypeDef { syntax })),
+            CONST_DEF => Some(ImplItem::ConstDef(ConstDef { syntax })),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> {
+        match self {
+            ImplItem::FnDef(inner) => inner.syntax(),
+            ImplItem::TypeDef(inner) => inner.syntax(),
+            ImplItem::ConstDef(inner) => inner.syntax(),
+        }
+    }
+}
 impl<'a> ImplItem<'a> {}
@@ -1552,7 +1587,11 @@ impl<R: TreeRoot<RaTypes>> ItemListNode<R> {
 impl<'a> ast::FnDefOwner<'a> for ItemList<'a> {}
 impl<'a> ast::ModuleItemOwner<'a> for ItemList<'a> {}
-impl<'a> ItemList<'a> {}
+impl<'a> ItemList<'a> {
+    pub fn impl_items(self) -> impl Iterator<Item = ImplItem<'a>> + 'a {
+        super::children(self)
+    }
+}
 // Label
 #[derive(Debug, Clone, Copy,)]
@@ -2136,6 +2175,7 @@ impl<R: TreeRoot<RaTypes>> ModuleNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for Module<'a> {}
 impl<'a> ast::NameOwner<'a> for Module<'a> {}
 impl<'a> ast::AttrsOwner<'a> for Module<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for Module<'a> {}
@@ -2153,7 +2193,7 @@ pub enum ModuleItem<'a> {
    FnDef(FnDef<'a>),
    TraitDef(TraitDef<'a>),
    TypeDef(TypeDef<'a>),
-    ImplItem(ImplItem<'a>),
+    ImplBlock(ImplBlock<'a>),
    UseItem(UseItem<'a>),
    ExternCrateItem(ExternCrateItem<'a>),
    ConstDef(ConstDef<'a>),
@@ -2169,7 +2209,7 @@ impl<'a> AstNode<'a> for ModuleItem<'a> {
            FN_DEF => Some(ModuleItem::FnDef(FnDef { syntax })),
            TRAIT_DEF => Some(ModuleItem::TraitDef(TraitDef { syntax })),
            TYPE_DEF => Some(ModuleItem::TypeDef(TypeDef { syntax })),
-            IMPL_ITEM => Some(ModuleItem::ImplItem(ImplItem { syntax })),
+            IMPL_BLOCK => Some(ModuleItem::ImplBlock(ImplBlock { syntax })),
            USE_ITEM => Some(ModuleItem::UseItem(UseItem { syntax })),
            EXTERN_CRATE_ITEM => Some(ModuleItem::ExternCrateItem(ExternCrateItem { syntax })),
            CONST_DEF => Some(ModuleItem::ConstDef(ConstDef { syntax })),
@@ -2185,7 +2225,7 @@ impl<'a> AstNode<'a> for ModuleItem<'a> {
            ModuleItem::FnDef(inner) => inner.syntax(),
            ModuleItem::TraitDef(inner) => inner.syntax(),
            ModuleItem::TypeDef(inner) => inner.syntax(),
-            ModuleItem::ImplItem(inner) => inner.syntax(),
+            ModuleItem::ImplBlock(inner) => inner.syntax(),
            ModuleItem::UseItem(inner) => inner.syntax(),
            ModuleItem::ExternCrateItem(inner) => inner.syntax(),
            ModuleItem::ConstDef(inner) => inner.syntax(),
@@ -2351,6 +2391,7 @@ impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> NamedFieldDef<'a> {
@@ -3082,6 +3123,7 @@ impl<R: TreeRoot<RaTypes>> PosFieldNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for PosField<'a> {}
 impl<'a> ast::AttrsOwner<'a> for PosField<'a> {}
 impl<'a> PosField<'a> {
    pub fn type_ref(self) -> Option<TypeRef<'a>> {
@@ -3446,6 +3488,43 @@ impl<'a> ReturnExpr<'a> {
    }
 }
+// SelfKw
+#[derive(Debug, Clone, Copy,)]
+pub struct SelfKwNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type SelfKw<'a> = SelfKwNode<RefRoot<'a>>;
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<SelfKwNode<R1>> for SelfKwNode<R2> {
+    fn eq(&self, other: &SelfKwNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for SelfKwNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for SelfKwNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+impl<'a> AstNode<'a> for SelfKw<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            SELF_KW => Some(SelfKw { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+impl<R: TreeRoot<RaTypes>> SelfKwNode<R> {
+    pub fn borrowed(&self) -> SelfKw {
+        SelfKwNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> SelfKwNode {
+        SelfKwNode { syntax: self.syntax.owned() }
+    }
+}
+impl<'a> SelfKw<'a> {}
 // SelfParam
 #[derive(Debug, Clone, Copy,)]
 pub struct SelfParamNode<R: TreeRoot<RaTypes> = OwnedRoot> {
@@ -3481,7 +3560,15 @@ impl<R: TreeRoot<RaTypes>> SelfParamNode<R> {
 }
-impl<'a> SelfParam<'a> {}
+impl<'a> SelfParam<'a> {
+    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+        super::child_opt(self)
+    }
+    pub fn self_kw(self) -> Option<SelfKw<'a>> {
+        super::child_opt(self)
+    }
+}
 // SlicePat
 #[derive(Debug, Clone, Copy,)]
@@ -3639,6 +3726,7 @@ impl<R: TreeRoot<RaTypes>> StaticDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::NameOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for StaticDef<'a> {}
@@ -3742,6 +3830,7 @@ impl<R: TreeRoot<RaTypes>> StructDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for StructDef<'a> {}
 impl<'a> ast::NameOwner<'a> for StructDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for StructDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for StructDef<'a> {}
@@ -3902,6 +3991,7 @@ impl<R: TreeRoot<RaTypes>> TraitDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::NameOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for TraitDef<'a> {}
@@ -4135,6 +4225,7 @@ impl<R: TreeRoot<RaTypes>> TypeDefNode<R> {
 }
+impl<'a> ast::VisibilityOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::NameOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for TypeDef<'a> {}
@@ -4409,6 +4500,43 @@ impl<'a> UseTreeList<'a> {
    }
 }
+// Visibility
+#[derive(Debug, Clone, Copy,)]
+pub struct VisibilityNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type Visibility<'a> = VisibilityNode<RefRoot<'a>>;
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<VisibilityNode<R1>> for VisibilityNode<R2> {
+    fn eq(&self, other: &VisibilityNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for VisibilityNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for VisibilityNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+impl<'a> AstNode<'a> for Visibility<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            VISIBILITY => Some(Visibility { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+impl<R: TreeRoot<RaTypes>> VisibilityNode<R> {
+    pub fn borrowed(&self) -> Visibility {
+        VisibilityNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> VisibilityNode {
+        VisibilityNode { syntax: self.syntax.owned() }
+    }
+}
+impl<'a> Visibility<'a> {}
 // WhereClause
 #[derive(Debug, Clone, Copy,)]
 pub struct WhereClauseNode<R: TreeRoot<RaTypes> = OwnedRoot> {
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index aab4839a9..c55e9e07a 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -128,7 +128,7 @@ Grammar(
        "STATIC_DEF",
        "CONST_DEF",
        "TRAIT_DEF",
-        "IMPL_ITEM",
+        "IMPL_BLOCK",
        "TYPE_DEF",
        "MACRO_CALL",
        "TOKEN_TREE",
@@ -247,6 +247,7 @@ Grammar(
        ),
        "FnDef": (
            traits: [
+                "VisibilityOwner",
                "NameOwner",
                "TypeParamsOwner",
                "AttrsOwner",
@@ -257,6 +258,7 @@ Grammar(
        "RetType": (options: ["TypeRef"]),
        "StructDef": (
            traits: [
+                "VisibilityOwner",
                "NameOwner",
                "TypeParamsOwner",
                "AttrsOwner",
@@ -264,10 +266,11 @@ Grammar(
            ]
        ),
        "NamedFieldDefList": (collections: [["fields", "NamedFieldDef"]]),
-        "NamedFieldDef": ( traits: ["NameOwner", "AttrsOwner"], options: ["TypeRef"] ),
+        "NamedFieldDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner"], options: ["TypeRef"] ),
        "PosFieldList": (collections: [["fields", "PosField"]]),
-        "PosField": ( traits: ["AttrsOwner"], options: ["TypeRef"]),
+        "PosField": ( traits: ["VisibilityOwner", "AttrsOwner"], options: ["TypeRef"]),
        "EnumDef": ( traits: [
+            "VisibilityOwner",
            "NameOwner",
            "TypeParamsOwner",
            "AttrsOwner",
@@ -275,33 +278,37 @@ Grammar(
        ], options: [["variant_list", "EnumVariantList"]] ),
        "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ),
        "EnumVariant": ( traits: ["NameOwner"], options: ["Expr"] ),
-        "TraitDef": ( traits: ["NameOwner", "AttrsOwner", "DocCommentsOwner"] ),
+        "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner"] ),
        "Module": (
-            traits: ["NameOwner", "AttrsOwner", "DocCommentsOwner" ],
+            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner" ],
            options: [ "ItemList" ]
        ),
        "ItemList": (
+            collections: [["impl_items", "ImplItem"]],
            traits: [ "FnDefOwner", "ModuleItemOwner" ],
        ),
        "ConstDef": ( traits: [
+            "VisibilityOwner",
            "NameOwner",
            "TypeParamsOwner",
            "AttrsOwner",
            "DocCommentsOwner"
        ] ),
        "StaticDef": ( traits: [
+            "VisibilityOwner",
            "NameOwner",
            "TypeParamsOwner",
            "AttrsOwner",
            "DocCommentsOwner"
        ] ),
        "TypeDef": ( traits: [
+            "VisibilityOwner",
            "NameOwner",
            "TypeParamsOwner",
            "AttrsOwner",
            "DocCommentsOwner"
        ] ),
-        "ImplItem": (),
+        "ImplBlock": (options: ["ItemList"]),
        "ParenType": (options: ["TypeRef"]),
        "TupleType": ( collections: [["fields", "TypeRef"]] ),
@@ -342,9 +349,12 @@ Grammar(
            ],
        ),
        "ModuleItem": (
-            enum: ["StructDef", "EnumDef", "FnDef", "TraitDef", "TypeDef", "ImplItem",
+            enum: ["StructDef", "EnumDef", "FnDef", "TraitDef", "TypeDef", "ImplBlock",
                   "UseItem", "ExternCrateItem", "ConstDef", "StaticDef", "Module" ]
        ),
+        "ImplItem": (
+            enum: ["FnDef", "TypeDef", "ConstDef"]
+        ),
        "TupleExpr": (),
        "ArrayExpr": (),
@@ -482,6 +492,7 @@ Grammar(
            ],
        ),
+        "Visibility": (),
        "Name": (),
        "NameRef": (),
        "MacroCall": ( options: [ "TokenTree", "Path" ] ),
@@ -523,7 +534,8 @@ Grammar(
                ["params", "Param"]
            ]
        ),
-        "SelfParam": (),
+        "SelfParam": (options: ["TypeRef", "SelfKw"]),
+        "SelfKw": (),
        "Param": (
            options: [ "Pat", "TypeRef" ],
        ),
diff --git a/crates/ra_syntax/src/grammar/items.rs b/crates/ra_syntax/src/grammar/items.rs
index aa5fe0777..265e84570 100644
--- a/crates/ra_syntax/src/grammar/items.rs
+++ b/crates/ra_syntax/src/grammar/items.rs
@@ -151,8 +151,8 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
        // test unsafe_default_impl
        // unsafe default impl Foo {}
        IMPL_KW => {
-            traits::impl_item(p);
+            traits::impl_block(p);
-            IMPL_ITEM
+            IMPL_BLOCK
        }
        _ => {
            return if has_mods {
diff --git a/crates/ra_syntax/src/grammar/items/traits.rs b/crates/ra_syntax/src/grammar/items/traits.rs
index d4da8b2f7..0a0621753 100644
--- a/crates/ra_syntax/src/grammar/items/traits.rs
+++ b/crates/ra_syntax/src/grammar/items/traits.rs
@@ -40,9 +40,9 @@ pub(crate) fn trait_item_list(p: &mut Parser) {
    m.complete(p, ITEM_LIST);
 }
-// test impl_item
+// test impl_block
 // impl Foo {}
-pub(super) fn impl_item(p: &mut Parser) {
+pub(super) fn impl_block(p: &mut Parser) {
    assert!(p.at(IMPL_KW));
    p.bump();
    if choose_type_params_over_qpath(p) {
@@ -52,7 +52,7 @@ pub(super) fn impl_item(p: &mut Parser) {
    // TODO: never type
    // impl ! {}
-    // test impl_item_neg
+    // test impl_block_neg
    // impl !Send for X {}
    p.eat(EXCL);
    impl_type(p);
diff --git a/crates/ra_syntax/src/parser_api.rs b/crates/ra_syntax/src/parser_api.rs
index 02421def1..3487aef85 100644
--- a/crates/ra_syntax/src/parser_api.rs
+++ b/crates/ra_syntax/src/parser_api.rs
@@ -61,7 +61,7 @@ impl<'t> Parser<'t> {
        Marker::new(self.0.start())
    }
-    /// Advances the parser by one token.
+    /// Advances the parser by one token unconditionally.
    pub(crate) fn bump(&mut self) {
        self.0.bump();
    }
@@ -91,7 +91,7 @@ impl<'t> Parser<'t> {
        self.0.error(message.into())
    }
-    /// Consume the next token if it is `kind`.
+    /// Consume the next token if `kind` matches.
    pub(crate) fn eat(&mut self, kind: SyntaxKind) -> bool {
        if !self.at(kind) {
            return false;
@@ -142,11 +142,13 @@ impl Marker {
        }
    }
-    /// Finishes the syntax tree node and assigns `kind` to it.
+    /// Finishes the syntax tree node and assigns `kind` to it,
+    /// and mark the create a `CompletedMarker` for possible future
+    /// operation like `.precede()` to deal with forward_parent.
    pub(crate) fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
        self.bomb.defuse();
        p.0.complete(self.pos, kind);
-        CompletedMarker(self.pos, kind)
+        CompletedMarker::new(self.pos, kind)
    }
    /// Abandons the syntax tree node. All its children
@@ -160,13 +162,22 @@ impl Marker {
 pub(crate) struct CompletedMarker(u32, SyntaxKind);
 impl CompletedMarker {
-    /// This one is tricky :-)
+    fn new(pos: u32, kind: SyntaxKind) -> Self {
+        CompletedMarker(pos, kind)
+    }
    /// This method allows to create a new node which starts
    /// *before* the current one. That is, parser could start
    /// node `A`, then complete it, and then after parsing the
    /// whole `A`, decide that it should have started some node
    /// `B` before starting `A`. `precede` allows to do exactly
    /// that. See also docs about `forward_parent` in `Event::Start`.
+    ///
+    /// Given completed events `[START, FINISH]` and its corresponding
+    /// `CompletedMarker(pos: 0, _)`.
+    /// Append a new `START` events as `[START, FINISH, NEWSTART]`,
+    /// then mark `NEWSTART` as `START`'s parent with saving its relative
+    /// distance to `NEWSTART` into forward_parent(=2 in this case);
    pub(crate) fn precede(self, p: &mut Parser) -> Marker {
        Marker::new(p.0.precede(self.0))
    }
diff --git a/crates/ra_syntax/src/parser_impl.rs b/crates/ra_syntax/src/parser_impl.rs
index cb6e370ac..01a51cd8d 100644
--- a/crates/ra_syntax/src/parser_impl.rs
+++ b/crates/ra_syntax/src/parser_impl.rs
@@ -22,10 +22,21 @@ use crate::SyntaxKind::{self, EOF, TOMBSTONE};
 pub(crate) trait Sink {
    type Tree;
+    /// Adds new leaf to the current branch.
    fn leaf(&mut self, kind: SyntaxKind, text: SmolStr);
-    fn start_internal(&mut self, kind: SyntaxKind);
-    fn finish_internal(&mut self);
+    /// Start new branch and make it current.
+    fn start_branch(&mut self, kind: SyntaxKind);
+    /// Finish current branch and restore previous
+    /// branch as current.
+    fn finish_branch(&mut self);
    fn error(&mut self, error: SyntaxError);
+    /// Complete tree building. Make sure that
+    /// `start_branch` and `finish_branch` calls
+    /// are paired!
    fn finish(self) -> Self::Tree;
 }
@@ -52,8 +63,7 @@ pub(crate) fn parse_with<S: Sink>(
 /// to a separate struct in order not to pollute
 /// the public API of the `Parser`.
 pub(crate) struct ParserImpl<'t> {
-    inp: &'t ParserInput<'t>,
+    parser_input: &'t ParserInput<'t>,
    pos: InputPosition,
    events: Vec<Event>,
    steps: Cell<u32>,
@@ -62,8 +72,7 @@ pub(crate) struct ParserImpl<'t> {
 impl<'t> ParserImpl<'t> {
    pub(crate) fn new(inp: &'t ParserInput<'t>) -> ParserImpl<'t> {
        ParserImpl {
-            inp,
+            parser_input: inp,
            pos: InputPosition::new(),
            events: Vec::new(),
            steps: Cell::new(0),
@@ -76,9 +85,11 @@ impl<'t> ParserImpl<'t> {
    }
    pub(super) fn next2(&self) -> Option<(SyntaxKind, SyntaxKind)> {
-        let c1 = self.inp.kind(self.pos);
+        let c1 = self.parser_input.kind(self.pos);
-        let c2 = self.inp.kind(self.pos + 1);
+        let c2 = self.parser_input.kind(self.pos + 1);
-        if self.inp.start(self.pos + 1) == self.inp.start(self.pos) + self.inp.len(self.pos) {
+        if self.parser_input.token_start_at(self.pos + 1)
+            == self.parser_input.token_start_at(self.pos) + self.parser_input.token_len(self.pos)
+        {
            Some((c1, c2))
        } else {
            None
@@ -86,12 +97,14 @@ impl<'t> ParserImpl<'t> {
    }
    pub(super) fn next3(&self) -> Option<(SyntaxKind, SyntaxKind, SyntaxKind)> {
-        let c1 = self.inp.kind(self.pos);
+        let c1 = self.parser_input.kind(self.pos);
-        let c2 = self.inp.kind(self.pos + 1);
+        let c2 = self.parser_input.kind(self.pos + 1);
-        let c3 = self.inp.kind(self.pos + 2);
+        let c3 = self.parser_input.kind(self.pos + 2);
-        if self.inp.start(self.pos + 1) == self.inp.start(self.pos) + self.inp.len(self.pos)
+        if self.parser_input.token_start_at(self.pos + 1)
-            && self.inp.start(self.pos + 2)
+            == self.parser_input.token_start_at(self.pos) + self.parser_input.token_len(self.pos)
-                == self.inp.start(self.pos + 1) + self.inp.len(self.pos + 1)
+            && self.parser_input.token_start_at(self.pos + 2)
+                == self.parser_input.token_start_at(self.pos + 1)
+                    + self.parser_input.token_len(self.pos + 1)
        {
            Some((c1, c2, c3))
        } else {
@@ -99,29 +112,27 @@ impl<'t> ParserImpl<'t> {
        }
    }
+    /// Get the syntax kind of the nth token.
    pub(super) fn nth(&self, n: u32) -> SyntaxKind {
        let steps = self.steps.get();
-        if steps > 10_000_000 {
+        assert!(steps <= 10_000_000, "the parser seems stuck");
-            panic!("the parser seems stuck");
-        }
        self.steps.set(steps + 1);
-        self.inp.kind(self.pos + n)
+        self.parser_input.kind(self.pos + n)
    }
    pub(super) fn at_kw(&self, t: &str) -> bool {
-        self.inp.text(self.pos) == t
+        self.parser_input.token_text(self.pos) == t
    }
+    /// Start parsing right behind the last event.
    pub(super) fn start(&mut self) -> u32 {
        let pos = self.events.len() as u32;
-        self.event(Event::Start {
+        self.push_event(Event::tombstone());
-            kind: TOMBSTONE,
-            forward_parent: None,
-        });
        pos
    }
+    /// Advances the parser by one token unconditionally.
    pub(super) fn bump(&mut self) {
        let kind = self.nth(0);
        if kind == EOF {
@@ -144,15 +155,17 @@ impl<'t> ParserImpl<'t> {
    fn do_bump(&mut self, kind: SyntaxKind, n_raw_tokens: u8) {
        self.pos += u32::from(n_raw_tokens);
-        self.event(Event::Token { kind, n_raw_tokens });
+        self.push_event(Event::Token { kind, n_raw_tokens });
    }
+    /// Append one Error event to the back of events.
    pub(super) fn error(&mut self, msg: String) {
-        self.event(Event::Error {
+        self.push_event(Event::Error {
            msg: ParseError(msg),
        })
    }
+    /// Complete an event with appending a `Finish` event.
    pub(super) fn complete(&mut self, pos: u32, kind: SyntaxKind) {
        match self.events[pos as usize] {
            Event::Start {
@@ -162,9 +175,10 @@ impl<'t> ParserImpl<'t> {
            }
            _ => unreachable!(),
        }
-        self.event(Event::Finish);
+        self.push_event(Event::Finish);
    }
+    /// Ignore the dummy `Start` event.
    pub(super) fn abandon(&mut self, pos: u32) {
        let idx = pos as usize;
        if idx == self.events.len() - 1 {
@@ -178,6 +192,7 @@ impl<'t> ParserImpl<'t> {
        }
    }
+    /// Save the relative distance of a completed event to its forward_parent.
    pub(super) fn precede(&mut self, pos: u32) -> u32 {
        let new_pos = self.start();
        match self.events[pos as usize] {
@@ -192,7 +207,7 @@ impl<'t> ParserImpl<'t> {
        new_pos
    }
-    fn event(&mut self, event: Event) {
+    fn push_event(&mut self, event: Event) {
        self.events.push(event)
    }
 }
diff --git a/crates/ra_syntax/src/parser_impl/event.rs b/crates/ra_syntax/src/parser_impl/event.rs
index 3d8b062d5..73dd6e02b 100644
--- a/crates/ra_syntax/src/parser_impl/event.rs
+++ b/crates/ra_syntax/src/parser_impl/event.rs
@@ -36,7 +36,7 @@ pub(crate) enum Event {
    ///
    /// For left-recursive syntactic constructs, the parser produces
    /// a child node before it sees a parent. `forward_parent`
-    /// exists to allow to tweak parent-child relationships.
+    /// saves the position of current event's parent.
    ///
    /// Consider this path
    ///
@@ -84,6 +84,15 @@ pub(crate) enum Event {
    },
 }
+impl Event {
+    pub(crate) fn tombstone() -> Self {
+        Event::Start {
+            kind: TOMBSTONE,
+            forward_parent: None,
+        }
+    }
+}
 pub(super) struct EventProcessor<'a, S: Sink> {
    sink: S,
    text_pos: TextUnit,
@@ -110,17 +119,12 @@ impl<'a, S: Sink> EventProcessor<'a, S> {
        }
    }
+    /// Generate the syntax tree with the control of events.
    pub(super) fn process(mut self) -> S {
-        fn tombstone() -> Event {
-            Event::Start {
-                kind: TOMBSTONE,
-                forward_parent: None,
-            }
-        }
        let mut forward_parents = Vec::new();
        for i in 0..self.events.len() {
-            match mem::replace(&mut self.events[i], tombstone()) {
+            match mem::replace(&mut self.events[i], Event::tombstone()) {
                Event::Start {
                    kind: TOMBSTONE, ..
                } => (),
@@ -129,12 +133,18 @@ impl<'a, S: Sink> EventProcessor<'a, S> {
                    kind,
                    forward_parent,
                } => {
+                    // For events[A, B, C], B is A's forward_parent, C is B's forward_parent,
+                    // in the normal control flow, the parent-child relation: `A -> B -> C`,
+                    // while with the magic forward_parent, it writes: `C <- B <- A`.
+                    // append `A` into parents.
                    forward_parents.push(kind);
                    let mut idx = i;
                    let mut fp = forward_parent;
                    while let Some(fwd) = fp {
                        idx += fwd as usize;
-                        fp = match mem::replace(&mut self.events[idx], tombstone()) {
+                        // append `A`'s forward_parent `B`
+                        fp = match mem::replace(&mut self.events[idx], Event::tombstone()) {
                            Event::Start {
                                kind,
                                forward_parent,
@@ -144,17 +154,19 @@ impl<'a, S: Sink> EventProcessor<'a, S> {
                            }
                            _ => unreachable!(),
                        };
+                        // append `B`'s forward_parent `C` in the next stage.
                    }
                    for kind in forward_parents.drain(..).rev() {
                        self.start(kind);
                    }
                }
                Event::Finish => {
-                    let last = i == self.events.len() - 1;
+                    let is_last = i == self.events.len() - 1;
-                    self.finish(last);
+                    self.finish(is_last);
                }
                Event::Token { kind, n_raw_tokens } => {
-                    self.eat_ws();
+                    self.eat_trivias();
                    let n_raw_tokens = n_raw_tokens as usize;
                    let len = self.tokens[self.token_pos..self.token_pos + n_raw_tokens]
                        .iter()
@@ -171,9 +183,10 @@ impl<'a, S: Sink> EventProcessor<'a, S> {
        self.sink
    }
+    /// Add the node into syntax tree but discard the comments/whitespaces.
    fn start(&mut self, kind: SyntaxKind) {
        if kind == SOURCE_FILE {
-            self.sink.start_internal(kind);
+            self.sink.start_branch(kind);
            return;
        }
        let n_trivias = self.tokens[self.token_pos..]
@@ -194,18 +207,18 @@ impl<'a, S: Sink> EventProcessor<'a, S> {
            n_attached_trivias(kind, leading_trivias)
        };
        self.eat_n_trivias(n_trivias - n_attached_trivias);
-        self.sink.start_internal(kind);
+        self.sink.start_branch(kind);
        self.eat_n_trivias(n_attached_trivias);
    }
-    fn finish(&mut self, last: bool) {
+    fn finish(&mut self, is_last: bool) {
-        if last {
+        if is_last {
-            self.eat_ws()
+            self.eat_trivias()
        }
-        self.sink.finish_internal();
+        self.sink.finish_branch();
    }
-    fn eat_ws(&mut self) {
+    fn eat_trivias(&mut self) {
        while let Some(&token) = self.tokens.get(self.token_pos) {
            if !token.kind.is_trivia() {
                break;
@@ -236,7 +249,7 @@ fn n_attached_trivias<'a>(
    trivias: impl Iterator<Item = (SyntaxKind, &'a str)>,
 ) -> usize {
    match kind {
-        STRUCT_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | MODULE => {
+        CONST_DEF | TYPE_DEF | STRUCT_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | MODULE => {
            let mut res = 0;
            for (i, (kind, text)) in trivias.enumerate() {
                match kind {
diff --git a/crates/ra_syntax/src/parser_impl/input.rs b/crates/ra_syntax/src/parser_impl/input.rs
index ac6d900d8..7fde5b3ab 100644
--- a/crates/ra_syntax/src/parser_impl/input.rs
+++ b/crates/ra_syntax/src/parser_impl/input.rs
@@ -4,11 +4,26 @@ use std::ops::{Add, AddAssign};
 pub(crate) struct ParserInput<'t> {
    text: &'t str,
+    /// start position of each token(expect whitespace and comment)
+    /// ```non-rust
+    ///  struct Foo;
+    /// ^------^---
+    /// |      |  ^-
+    /// 0      7  10
+    /// ```
+    /// (token, start_offset): `[(struct, 0), (Foo, 7), (;, 10)]`
    start_offsets: Vec<TextUnit>,
-    tokens: Vec<Token>, // non-whitespace tokens
+    /// non-whitespace/comment tokens
+    /// ```non-rust
+    /// struct Foo {}
+    /// ^^^^^^ ^^^ ^^
+    /// ```
+    /// tokens: `[struct, Foo, {, }]`
+    tokens: Vec<Token>,
 }
 impl<'t> ParserInput<'t> {
+    /// Generate input from tokens(expect comment and whitespace).
    pub fn new(text: &'t str, raw_tokens: &'t [Token]) -> ParserInput<'t> {
        let mut tokens = Vec::new();
        let mut start_offsets = Vec::new();
@@ -28,6 +43,7 @@ impl<'t> ParserInput<'t> {
        }
    }
+    /// Get the syntax kind of token at given input position.
    pub fn kind(&self, pos: InputPosition) -> SyntaxKind {
        let idx = pos.0 as usize;
        if !(idx < self.tokens.len()) {
@@ -36,7 +52,8 @@ impl<'t> ParserInput<'t> {
        self.tokens[idx].kind
    }
-    pub fn len(&self, pos: InputPosition) -> TextUnit {
+    /// Get the length of a token at given input position.
+    pub fn token_len(&self, pos: InputPosition) -> TextUnit {
        let idx = pos.0 as usize;
        if !(idx < self.tokens.len()) {
            return 0.into();
@@ -44,7 +61,8 @@ impl<'t> ParserInput<'t> {
        self.tokens[idx].len
    }
-    pub fn start(&self, pos: InputPosition) -> TextUnit {
+    /// Get the start position of a taken at given input position.
+    pub fn token_start_at(&self, pos: InputPosition) -> TextUnit {
        let idx = pos.0 as usize;
        if !(idx < self.tokens.len()) {
            return 0.into();
@@ -52,7 +70,8 @@ impl<'t> ParserInput<'t> {
        self.start_offsets[idx]
    }
-    pub fn text(&self, pos: InputPosition) -> &'t str {
+    /// Get the raw text of a token at given input position.
+    pub fn token_text(&self, pos: InputPosition) -> &'t str {
        let idx = pos.0 as usize;
        if !(idx < self.tokens.len()) {
            return "";
diff --git a/crates/ra_syntax/src/reparsing.rs b/crates/ra_syntax/src/reparsing.rs
index 208cae5c8..7ee71a1b6 100644
--- a/crates/ra_syntax/src/reparsing.rs
+++ b/crates/ra_syntax/src/reparsing.rs
@@ -100,7 +100,7 @@ fn find_reparsable_node(
            ITEM_LIST => {
                let parent = node.parent().unwrap();
                match parent.kind() {
-                    IMPL_ITEM => grammar::impl_item_list,
+                    IMPL_BLOCK => grammar::impl_item_list,
                    TRAIT_DEF => grammar::trait_item_list,
                    MODULE => grammar::mod_item_list,
                    _ => return None,
diff --git a/crates/ra_syntax/src/syntax_kinds/generated.rs b/crates/ra_syntax/src/syntax_kinds/generated.rs
index 3a869ad34..ef4588d93 100644
--- a/crates/ra_syntax/src/syntax_kinds/generated.rs
+++ b/crates/ra_syntax/src/syntax_kinds/generated.rs
@@ -128,7 +128,7 @@ pub enum SyntaxKind {
    STATIC_DEF,
    CONST_DEF,
    TRAIT_DEF,
-    IMPL_ITEM,
+    IMPL_BLOCK,
    TYPE_DEF,
    MACRO_CALL,
    TOKEN_TREE,
@@ -389,7 +389,7 @@ impl SyntaxKind {
            STATIC_DEF => &SyntaxInfo { name: "STATIC_DEF" },
            CONST_DEF => &SyntaxInfo { name: "CONST_DEF" },
            TRAIT_DEF => &SyntaxInfo { name: "TRAIT_DEF" },
-            IMPL_ITEM => &SyntaxInfo { name: "IMPL_ITEM" },
+            IMPL_BLOCK => &SyntaxInfo { name: "IMPL_BLOCK" },
            TYPE_DEF => &SyntaxInfo { name: "TYPE_DEF" },
            MACRO_CALL => &SyntaxInfo { name: "MACRO_CALL" },
            TOKEN_TREE => &SyntaxInfo { name: "TOKEN_TREE" },
diff --git a/crates/ra_syntax/src/yellow/builder.rs b/crates/ra_syntax/src/yellow/builder.rs
index 9fcebfb93..37ae6329b 100644
--- a/crates/ra_syntax/src/yellow/builder.rs
+++ b/crates/ra_syntax/src/yellow/builder.rs
@@ -26,11 +26,11 @@ impl Sink for GreenBuilder {
        self.inner.leaf(kind, text);
    }
-    fn start_internal(&mut self, kind: SyntaxKind) {
+    fn start_branch(&mut self, kind: SyntaxKind) {
        self.inner.start_internal(kind)
    }
-    fn finish_internal(&mut self) {
+    fn finish_branch(&mut self) {
        self.inner.finish_internal();
    }
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index 46bde9a08..279a83b61 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -119,3 +119,27 @@ impl SyntaxTextSlice for ops::Range<TextUnit> {
        TextRange::from_to(self.start, self.end).restrict(range)
    }
 }
+impl From<SyntaxText<'_>> for String {
+    fn from(text: SyntaxText) -> String {
+        text.to_string()
+    }
+}
+impl PartialEq<str> for SyntaxText<'_> {
+    fn eq(&self, mut rhs: &str) -> bool {
+        for chunk in self.chunks() {
+            if !rhs.starts_with(chunk) {
+                return false;
+            }
+            rhs = &rhs[chunk.len()..];
+        }
+        rhs.is_empty()
+    }
+}
+impl PartialEq<&'_ str> for SyntaxText<'_> {
+    fn eq(&self, rhs: &&str) -> bool {
+        self == *rhs
+    }
+}
diff --git a/crates/ra_syntax/tests/data/parser/err/0018_incomplete_fn.txt b/crates/ra_syntax/tests/data/parser/err/0018_incomplete_fn.txt
index 3937be255..262cbba1e 100644
--- a/crates/ra_syntax/tests/data/parser/err/0018_incomplete_fn.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0018_incomplete_fn.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 183)
-  IMPL_ITEM@[0; 182)
+  IMPL_BLOCK@[0; 182)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 13)
diff --git a/crates/ra_syntax/tests/data/parser/err/0022_bad_exprs.txt b/crates/ra_syntax/tests/data/parser/err/0022_bad_exprs.txt
index 55999c160..da3894133 100644
--- a/crates/ra_syntax/tests/data/parser/err/0022_bad_exprs.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0022_bad_exprs.txt
@@ -94,7 +94,7 @@ SOURCE_FILE@[0; 112)
          COMMA@[54; 55)
          err: `expected SEMI`
      WHITESPACE@[55; 56)
-      IMPL_ITEM@[56; 60)
+      IMPL_BLOCK@[56; 60)
        IMPL_KW@[56; 60)
        err: `expected type`
        err: `expected `{``
diff --git a/crates/ra_syntax/tests/data/parser/err/0026_imp_recovery.txt b/crates/ra_syntax/tests/data/parser/err/0026_imp_recovery.txt
index 82683f6ee..9b5fadcf7 100644
--- a/crates/ra_syntax/tests/data/parser/err/0026_imp_recovery.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0026_imp_recovery.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 38)
-  IMPL_ITEM@[0; 14)
+  IMPL_BLOCK@[0; 14)
    IMPL_KW@[0; 4)
    TYPE_PARAM_LIST@[4; 14)
      L_ANGLE@[4; 5)
@@ -17,7 +17,7 @@ SOURCE_FILE@[0; 38)
      err: `expected trait or type`
      err: `expected `{``
  WHITESPACE@[14; 15)
-  IMPL_ITEM@[15; 37)
+  IMPL_BLOCK@[15; 37)
    IMPL_KW@[15; 19)
    TYPE_PARAM_LIST@[19; 22)
      L_ANGLE@[19; 20)
diff --git a/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt
index 75533ecc1..8021aee00 100644
--- a/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt
@@ -19,7 +19,7 @@ SOURCE_FILE@[0; 30)
            err: `expected a loop`
            err: `expected SEMI`
      WHITESPACE@[22; 23)
-      IMPL_ITEM@[23; 27)
+      IMPL_BLOCK@[23; 27)
        IMPL_KW@[23; 27)
        err: `expected type`
        err: `expected `{``
diff --git a/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt
index 7279d5cae..6875ed016 100644
--- a/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 87)
-  IMPL_ITEM@[0; 12)
+  IMPL_BLOCK@[0; 12)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 9)
@@ -12,7 +12,7 @@ SOURCE_FILE@[0; 87)
      L_CURLY@[10; 11)
      R_CURLY@[11; 12)
  WHITESPACE@[12; 13)
-  IMPL_ITEM@[13; 33)
+  IMPL_BLOCK@[13; 33)
    IMPL_KW@[13; 17)
    WHITESPACE@[17; 18)
    PATH_TYPE@[18; 24)
@@ -33,12 +33,12 @@ SOURCE_FILE@[0; 87)
      L_CURLY@[31; 32)
      R_CURLY@[32; 33)
  WHITESPACE@[33; 34)
-  IMPL_ITEM@[34; 38)
+  IMPL_BLOCK@[34; 38)
    IMPL_KW@[34; 38)
    err: `expected trait or type`
    err: `expected `{``
  WHITESPACE@[38; 39)
-  IMPL_ITEM@[39; 54)
+  IMPL_BLOCK@[39; 54)
    IMPL_KW@[39; 43)
    WHITESPACE@[43; 44)
    PATH_TYPE@[44; 51)
@@ -51,7 +51,7 @@ SOURCE_FILE@[0; 87)
      L_CURLY@[52; 53)
      R_CURLY@[53; 54)
  WHITESPACE@[54; 55)
-  IMPL_ITEM@[55; 70)
+  IMPL_BLOCK@[55; 70)
    IMPL_KW@[55; 59)
    WHITESPACE@[59; 60)
    PATH_TYPE@[60; 66)
@@ -64,7 +64,7 @@ SOURCE_FILE@[0; 87)
    err: `expected trait or type`
    err: `expected `{``
  WHITESPACE@[70; 71)
-  IMPL_ITEM@[71; 86)
+  IMPL_BLOCK@[71; 86)
    IMPL_KW@[71; 75)
    WHITESPACE@[75; 76)
    PATH_TYPE@[76; 83)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt
index 998ac3da9..de7df7312 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 83)
-  IMPL_ITEM@[0; 82)
+  IMPL_BLOCK@[0; 82)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 6)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt
index 53027c852..4df01c6e5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 128)
-  IMPL_ITEM@[0; 127)
+  IMPL_BLOCK@[0; 127)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 6)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt
index b2f04ea7b..03139f7a4 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 69)
-  IMPL_ITEM@[0; 68)
+  IMPL_BLOCK@[0; 68)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 6)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt
index b15f93cd2..50426bdfe 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 89)
-  IMPL_ITEM@[0; 88)
+  IMPL_BLOCK@[0; 88)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 6)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt
index 6003ba645..5d68e88d6 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 27)
-  IMPL_ITEM@[0; 26)
+  IMPL_BLOCK@[0; 26)
    UNSAFE_KW@[0; 6)
    WHITESPACE@[6; 7)
    DEFAULT_KW@[7; 14)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_block_neg.rs
index b7527c870..b7527c870 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_block_neg.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_block_neg.txt
index b83db380e..563e43508 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_block_neg.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 20)
-  IMPL_ITEM@[0; 19)
+  IMPL_BLOCK@[0; 19)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    EXCL@[5; 6)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_item.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_block.rs
index d6337f6b3..d6337f6b3 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_item.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_block.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_item.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_block.txt
index 1b9a8aa0e..a2c218aa9 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_item.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0079_impl_block.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 12)
-  IMPL_ITEM@[0; 11)
+  IMPL_BLOCK@[0; 11)
    IMPL_KW@[0; 4)
    WHITESPACE@[4; 5)
    PATH_TYPE@[5; 8)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0087_unsafe_impl.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0087_unsafe_impl.txt
index f9c96c242..d93c0df4d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0087_unsafe_impl.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0087_unsafe_impl.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 19)
-  IMPL_ITEM@[0; 18)
+  IMPL_BLOCK@[0; 18)
    UNSAFE_KW@[0; 6)
    WHITESPACE@[6; 7)
    IMPL_KW@[7; 11)
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0097_default_impl.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0097_default_impl.txt
index f45b6251f..0b9af800b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0097_default_impl.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0097_default_impl.txt
@@ -1,5 +1,5 @@
 SOURCE_FILE@[0; 20)
-  IMPL_ITEM@[0; 19)
+  IMPL_BLOCK@[0; 19)
    DEFAULT_KW@[0; 7)
    WHITESPACE@[7; 8)
    IMPL_KW@[8; 12)
diff --git a/crates/ra_syntax/tests/data/parser/ok/0037_mod.rs b/crates/ra_syntax/tests/data/parser/ok/0037_mod.rs
new file mode 100644
index 000000000..7e5a1b835
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0037_mod.rs
@@ -0,0 +1,5 @@
+// https://github.com/rust-analyzer/rust-analyzer/issues/357
+//! docs
+// non-docs
+mod foo {}
+\ No newline at end of file
diff --git a/crates/ra_syntax/tests/data/parser/ok/0037_mod.txt b/crates/ra_syntax/tests/data/parser/ok/0037_mod.txt
new file mode 100644
index 000000000..f8a20ac53
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/ok/0037_mod.txt
@@ -0,0 +1,16 @@
+SOURCE_FILE@[0; 93)
+  COMMENT@[0; 60)
+  WHITESPACE@[60; 62)
+  MODULE@[62; 93)
+    COMMENT@[62; 70)
+    WHITESPACE@[70; 71)
+    COMMENT@[71; 82)
+    WHITESPACE@[82; 83)
+    MOD_KW@[83; 86)
+    WHITESPACE@[86; 87)
+    NAME@[87; 90)
+      IDENT@[87; 90) "foo"
+    WHITESPACE@[90; 91)
+    ITEM_LIST@[91; 93)
+      L_CURLY@[91; 92)
+      R_CURLY@[92; 93)
diff --git a/crates/ra_text_edit/src/text_edit.rs b/crates/ra_text_edit/src/text_edit.rs
index 0881f3e1c..a288a990d 100644
--- a/crates/ra_text_edit/src/text_edit.rs
+++ b/crates/ra_text_edit/src/text_edit.rs
@@ -7,15 +7,12 @@ pub struct TextEdit {
    atoms: Vec<AtomTextEdit>,
 }
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct TextEditBuilder {
    atoms: Vec<AtomTextEdit>,
 }
 impl TextEditBuilder {
-    pub fn new() -> TextEditBuilder {
-        TextEditBuilder { atoms: Vec::new() }
-    }
    pub fn replace(&mut self, range: TextRange, replace_with: String) {
        self.atoms.push(AtomTextEdit::replace(range, replace_with))
    }
diff --git a/crates/ra_vfs/Cargo.toml b/crates/ra_vfs/Cargo.toml
index 7c170cdfc..e637063c9 100644
--- a/crates/ra_vfs/Cargo.toml
+++ b/crates/ra_vfs/Cargo.toml
@@ -12,6 +12,7 @@ crossbeam-channel = "0.3.5"
 log = "0.4.6"
 thread_worker = { path = "../thread_worker" }
+ra_arena = { path = "../ra_arena" }
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_vfs/src/arena.rs b/crates/ra_vfs/src/arena.rs
deleted file mode 100644
index 6b42ae26d..000000000
--- a/crates/ra_vfs/src/arena.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::{
-    marker::PhantomData,
-    ops::{Index, IndexMut},
-};
-#[derive(Clone, Debug)]
-pub(crate) struct Arena<ID: ArenaId, T> {
-    data: Vec<T>,
-    _ty: PhantomData<ID>,
-}
-pub(crate) trait ArenaId {
-    fn from_u32(id: u32) -> Self;
-    fn to_u32(self) -> u32;
-}
-impl<ID: ArenaId, T> Arena<ID, T> {
-    pub fn alloc(&mut self, value: T) -> ID {
-        let id = self.data.len() as u32;
-        self.data.push(value);
-        ID::from_u32(id)
-    }
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = (ID, &'a T)> {
-        self.data
-            .iter()
-            .enumerate()
-            .map(|(idx, value)| (ID::from_u32(idx as u32), value))
-    }
-}
-impl<ID: ArenaId, T> Default for Arena<ID, T> {
-    fn default() -> Arena<ID, T> {
-        Arena {
-            data: Vec::new(),
-            _ty: PhantomData,
-        }
-    }
-}
-impl<ID: ArenaId, T> Index<ID> for Arena<ID, T> {
-    type Output = T;
-    fn index(&self, idx: ID) -> &T {
-        let idx = idx.to_u32() as usize;
-        &self.data[idx]
-    }
-}
-impl<ID: ArenaId, T> IndexMut<ID> for Arena<ID, T> {
-    fn index_mut(&mut self, idx: ID) -> &mut T {
-        let idx = idx.to_u32() as usize;
-        &mut self.data[idx]
-    }
-}
diff --git a/crates/ra_vfs/src/lib.rs b/crates/ra_vfs/src/lib.rs
index 5bbc3e993..cdea18d73 100644
--- a/crates/ra_vfs/src/lib.rs
+++ b/crates/ra_vfs/src/lib.rs
@@ -13,7 +13,6 @@
 //! VFS is based on a concept of roots: a set of directories on the file system
 //! which are watched for changes. Typically, there will be a root for each
 //! Cargo package.
-mod arena;
 mod io;
 use std::{
@@ -32,10 +31,7 @@ use relative_path::RelativePathBuf;
 use crossbeam_channel::Receiver;
 use walkdir::DirEntry;
 use thread_worker::WorkerHandle;
+use ra_arena::{Arena, RawId, impl_arena_id};
-use crate::{
-    arena::{ArenaId, Arena},
-};
 pub use crate::io::TaskResult as VfsTask;
@@ -68,29 +64,13 @@ fn has_rs_extension(p: &Path) -> bool {
    p.extension() == Some(OsStr::new("rs"))
 }
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct VfsRoot(pub u32);
+pub struct VfsRoot(pub RawId);
+impl_arena_id!(VfsRoot);
-impl ArenaId for VfsRoot {
-    fn from_u32(idx: u32) -> VfsRoot {
-        VfsRoot(idx)
-    }
-    fn to_u32(self) -> u32 {
-        self.0
-    }
-}
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-pub struct VfsFile(pub u32);
-impl ArenaId for VfsFile {
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    fn from_u32(idx: u32) -> VfsFile {
+pub struct VfsFile(pub RawId);
-        VfsFile(idx)
+impl_arena_id!(VfsFile);
-    }
-    fn to_u32(self) -> u32 {
-        self.0
-    }
-}
 struct VfsFileData {
    root: VfsRoot,