19 files changed, 869 insertions, 214 deletions

diff --git a/Cargo.lock b/Cargo.lock
index e5729f968..3be73d66d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -903,8 +903,10 @@ version = "0.1.0"
 name = "ra_assists"
 version = "0.1.0"
 dependencies = [
+ "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "join_to_string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_db 0.1.0",
  "ra_fmt 0.1.0",
  "ra_hir 0.1.0",
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index d4056a349..29d9ceb59 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -5,8 +5,10 @@ version = "0.1.0"
 authors = ["rust-analyzer developers"]
 
 [dependencies]
+lazy_static = "1.3.0"
 join_to_string = "0.1.3"
 itertools = "0.8.0"
+arrayvec = "0.4.10"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_text_edit = { path = "../ra_text_edit" }
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index c82447b84..17c2af899 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -1,14 +1,9 @@
-use std::fmt::Write;
-
-use crate::{Assist, AssistId, AssistCtx};
+use crate::{Assist, AssistId, AssistCtx, ast_editor::{AstEditor, AstBuilder}};
 
 use hir::db::HirDatabase;
-use ra_syntax::{SmolStr, SyntaxKind, TextRange, TextUnit, TreeArc};
-use ra_syntax::ast::{self, AstNode, AstToken, FnDef, ImplItem, ImplItemKind, NameOwner};
+use ra_syntax::{SmolStr, TreeArc};
+use ra_syntax::ast::{self, AstNode, FnDef, ImplItem, ImplItemKind, NameOwner};
 use ra_db::FilePosition;
-use ra_fmt::{leading_indent, reindent};
-
-use itertools::Itertools;
 
 enum AddMissingImplMembersMode {
     DefaultMethodsOnly,
@@ -76,48 +71,35 @@ fn add_missing_impl_members_inner(
     }
 
     ctx.add_action(AssistId(assist_id), label, |edit| {
-        let (parent_indent, indent) = {
-            // FIXME: Find a way to get the indent already used in the file.
-            // Now, we copy the indent of first item or indent with 4 spaces relative to impl block
-            const DEFAULT_INDENT: &str = "    ";
-            let first_item = impl_item_list.impl_items().next();
-            let first_item_indent =
-                first_item.and_then(|i| leading_indent(i.syntax())).map(ToOwned::to_owned);
-            let impl_block_indent = leading_indent(impl_node.syntax()).unwrap_or_default();
-
-            (
-                impl_block_indent.to_owned(),
-                first_item_indent.unwrap_or_else(|| impl_block_indent.to_owned() + DEFAULT_INDENT),
-            )
-        };
-
-        let changed_range = {
-            let children = impl_item_list.syntax().children_with_tokens();
-            let last_whitespace =
-                children.filter_map(|it| ast::Whitespace::cast(it.as_token()?)).last();
-
-            last_whitespace.map(|w| w.syntax().range()).unwrap_or_else(|| {
-                let in_brackets = impl_item_list.syntax().range().end() - TextUnit::of_str("}");
-                TextRange::from_to(in_brackets, in_brackets)
-            })
-        };
-
-        let func_bodies = format!("\n{}", missing_fns.into_iter().map(build_func_body).join("\n"));
-        let trailing_whitespace = format!("\n{}", parent_indent);
-        let func_bodies = reindent(&func_bodies, &indent) + &trailing_whitespace;
-
-        let replaced_text_range = TextUnit::of_str(&func_bodies);
-
-        edit.replace(changed_range, func_bodies);
-        // FIXME: place the cursor on the first unimplemented?
-        edit.set_cursor(
-            changed_range.start() + replaced_text_range - TextUnit::of_str(&trailing_whitespace),
-        );
+        let n_existing_items = impl_item_list.impl_items().count();
+        let fns = missing_fns.into_iter().map(add_body_and_strip_docstring).collect::<Vec<_>>();
+
+        let mut ast_editor = AstEditor::new(impl_item_list);
+        if n_existing_items == 0 {
+            ast_editor.make_multiline();
+        }
+        ast_editor.append_functions(fns.iter().map(|it| &**it));
+        let first_new_item = ast_editor.ast().impl_items().nth(n_existing_items).unwrap();
+        let cursor_poisition = first_new_item.syntax().range().start();
+        ast_editor.into_text_edit(edit.text_edit_builder());
+
+        edit.set_cursor(cursor_poisition);
     });
 
     ctx.build()
 }
 
+fn add_body_and_strip_docstring(fn_def: &ast::FnDef) -> TreeArc<ast::FnDef> {
+    let mut ast_editor = AstEditor::new(fn_def);
+    if fn_def.body().is_none() {
+        ast_editor.set_body(&AstBuilder::<ast::Block>::single_expr(
+            &AstBuilder::<ast::Expr>::unimplemented(),
+        ));
+    }
+    ast_editor.strip_attrs_and_docs();
+    ast_editor.ast().to_owned()
+}
+
 /// Given an `ast::ImplBlock`, resolves the target trait (the one being
 /// implemented) to a `ast::TraitDef`.
 fn resolve_target_trait_def(
@@ -134,22 +116,6 @@ fn resolve_target_trait_def(
     }
 }
 
-fn build_func_body(def: &ast::FnDef) -> String {
-    let mut buf = String::new();
-
-    for child in def.syntax().children_with_tokens() {
-        match (child.prev_sibling_or_token().map(|c| c.kind()), child.kind()) {
-            (_, SyntaxKind::SEMI) => buf.push_str(" {\n    unimplemented!()\n}"),
-            (_, SyntaxKind::ATTR) | (_, SyntaxKind::COMMENT) => {}
-            (Some(SyntaxKind::ATTR), SyntaxKind::WHITESPACE)
-            | (Some(SyntaxKind::COMMENT), SyntaxKind::WHITESPACE) => {}
-            _ => write!(buf, "{}", child).unwrap(),
-        };
-    }
-
-    buf.trim_end().to_string()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -170,7 +136,7 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    <|>
+<|>
 }",
             "
 trait Foo {
@@ -183,12 +149,9 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    fn foo(&self) {
-        unimplemented!()
-    }
-    fn baz(&self) {
-        unimplemented!()
-    }<|>
+    <|>fn foo(&self) { unimplemented!() }
+    fn baz(&self) { unimplemented!() }
+
 }",
         );
     }
@@ -208,7 +171,7 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    <|>
+<|>
 }",
             "
 trait Foo {
@@ -221,9 +184,8 @@ struct S;
 
 impl Foo for S {
     fn bar(&self) {}
-    fn foo(&self) {
-        unimplemented!()
-    }<|>
+    <|>fn foo(&self) { unimplemented!() }
+
 }",
         );
     }
@@ -240,9 +202,7 @@ impl Foo for S { <|> }",
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    fn foo(&self) {
-        unimplemented!()
-    }<|>
+    <|>fn foo(&self) { unimplemented!() }
 }",
         );
     }
@@ -259,9 +219,7 @@ impl Foo for S {}<|>",
 trait Foo { fn foo(&self); }
 struct S;
 impl Foo for S {
-    fn foo(&self) {
-        unimplemented!()
-    }<|>
+    <|>fn foo(&self) { unimplemented!() }
 }",
         )
     }
@@ -292,35 +250,6 @@ impl Foo for S { <|> }",
     }
 
     #[test]
-    fn test_indented_impl_block() {
-        check_assist(
-            add_missing_impl_members,
-            "
-trait Foo {
-    fn valid(some: u32) -> bool;
-}
-struct S;
-
-mod my_mod {
-    impl crate::Foo for S { <|> }
-}",
-            "
-trait Foo {
-    fn valid(some: u32) -> bool;
-}
-struct S;
-
-mod my_mod {
-    impl crate::Foo for S {
-        fn valid(some: u32) -> bool {
-            unimplemented!()
-        }<|>
-    }
-}",
-        )
-    }
-
-    #[test]
     fn test_with_docstring_and_attrs() {
         check_assist(
             add_missing_impl_members,
@@ -342,9 +271,7 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    fn foo(&self) {
-        unimplemented!()
-    }<|>
+    <|>fn foo(&self) { unimplemented!() }
 }"#,
         )
     }
@@ -367,7 +294,7 @@ trait Foo {
 }
 struct S;
 impl Foo for S {
-    fn valid(some: u32) -> bool { false }<|>
+    <|>fn valid(some: u32) -> bool { false }
 }",
         )
     }
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 17a9041c5..e744e82d0 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -165,6 +165,10 @@ impl AssistBuilder {
         self.target = Some(target)
     }
 
+    pub(crate) fn text_edit_builder(&mut self) -> &mut TextEditBuilder {
+        &mut self.edit
+    }
+
     fn build(self) -> AssistAction {
         AssistAction {
             edit: self.edit.finish(),
diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
new file mode 100644
index 000000000..6854294ae
--- /dev/null
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -0,0 +1,333 @@
+use std::{iter, ops::RangeInclusive};
+
+use arrayvec::ArrayVec;
+use ra_text_edit::TextEditBuilder;
+use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction};
+use ra_fmt::leading_indent;
+
+pub struct AstEditor<N: AstNode> {
+    original_ast: TreeArc<N>,
+    ast: TreeArc<N>,
+}
+
+impl<N: AstNode> AstEditor<N> {
+    pub fn new(node: &N) -> AstEditor<N> {
+        AstEditor { original_ast: node.to_owned(), ast: node.to_owned() }
+    }
+
+    pub fn into_text_edit(self, builder: &mut TextEditBuilder) {
+        // FIXME: compute a more fine-grained diff here.
+        // If *you* know a nice algorithm to compute diff between two syntax
+        // tree, tell me about it!
+        builder.replace(self.original_ast.syntax().range(), self.ast().syntax().text().to_string());
+    }
+
+    pub fn ast(&self) -> &N {
+        &*self.ast
+    }
+
+    #[must_use]
+    fn insert_children<'a>(
+        &self,
+        position: InsertPosition<SyntaxElement<'_>>,
+        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+    ) -> TreeArc<N> {
+        let new_syntax = self.ast().syntax().insert_children(position, to_insert);
+        N::cast(&new_syntax).unwrap().to_owned()
+    }
+
+    #[must_use]
+    fn replace_children<'a>(
+        &self,
+        to_delete: RangeInclusive<SyntaxElement<'_>>,
+        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+    ) -> TreeArc<N> {
+        let new_syntax = self.ast().syntax().replace_children(to_delete, to_insert);
+        N::cast(&new_syntax).unwrap().to_owned()
+    }
+
+    fn do_make_multiline(&mut self) {
+        let l_curly =
+            match self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY) {
+                Some(it) => it,
+                None => return,
+            };
+        let sibling = match l_curly.next_sibling_or_token() {
+            Some(it) => it,
+            None => return,
+        };
+        let existing_ws = match sibling.as_token() {
+            None => None,
+            Some(tok) if tok.kind() != WHITESPACE => None,
+            Some(ws) => {
+                if ws.text().contains('\n') {
+                    return;
+                }
+                Some(ws)
+            }
+        };
+
+        let indent = leading_indent(self.ast().syntax()).unwrap_or("");
+        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
+        let to_insert = iter::once(ws.ws().into());
+        self.ast = match existing_ws {
+            None => self.insert_children(InsertPosition::After(l_curly), to_insert),
+            Some(ws) => self.replace_children(RangeInclusive::new(ws.into(), ws.into()), to_insert),
+        };
+    }
+}
+
+impl AstEditor<ast::NamedFieldList> {
+    pub fn append_field(&mut self, field: &ast::NamedField) {
+        self.insert_field(InsertPosition::Last, field)
+    }
+
+    pub fn make_multiline(&mut self) {
+        self.do_make_multiline()
+    }
+
+    pub fn insert_field(
+        &mut self,
+        position: InsertPosition<&'_ ast::NamedField>,
+        field: &ast::NamedField,
+    ) {
+        let is_multiline = self.ast().syntax().text().contains('\n');
+        let ws;
+        let space = if is_multiline {
+            ws = tokens::WsBuilder::new(&format!(
+                "\n{}    ",
+                leading_indent(self.ast().syntax()).unwrap_or("")
+            ));
+            ws.ws()
+        } else {
+            tokens::single_space()
+        };
+
+        let mut to_insert: ArrayVec<[SyntaxElement; 4]> = ArrayVec::new();
+        to_insert.push(space.into());
+        to_insert.push(field.syntax().into());
+        to_insert.push(tokens::comma().into());
+
+        macro_rules! after_l_curly {
+            () => {{
+                let anchor = match self.l_curly() {
+                    Some(it) => it,
+                    None => return,
+                };
+                InsertPosition::After(anchor)
+            }};
+        }
+
+        macro_rules! after_field {
+            ($anchor:expr) => {
+                if let Some(comma) = $anchor
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .find(|it| it.kind() == COMMA)
+                {
+                    InsertPosition::After(comma)
+                } else {
+                    to_insert.insert(0, tokens::comma().into());
+                    InsertPosition::After($anchor.syntax().into())
+                }
+            };
+        };
+
+        let position = match position {
+            InsertPosition::First => after_l_curly!(),
+            InsertPosition::Last => {
+                if !is_multiline {
+                    // don't insert comma before curly
+                    to_insert.pop();
+                }
+                match self.ast().fields().last() {
+                    Some(it) => after_field!(it),
+                    None => after_l_curly!(),
+                }
+            }
+            InsertPosition::Before(anchor) => InsertPosition::Before(anchor.syntax().into()),
+            InsertPosition::After(anchor) => after_field!(anchor),
+        };
+
+        self.ast = self.insert_children(position, to_insert.iter().cloned());
+    }
+
+    fn l_curly(&self) -> Option<SyntaxElement> {
+        self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+    }
+}
+
+impl AstEditor<ast::ItemList> {
+    pub fn make_multiline(&mut self) {
+        self.do_make_multiline()
+    }
+
+    pub fn append_functions<'a>(&mut self, fns: impl Iterator<Item = &'a ast::FnDef>) {
+        fns.for_each(|it| self.append_function(it))
+    }
+
+    pub fn append_function(&mut self, fn_def: &ast::FnDef) {
+        let (indent, position) = match self.ast().impl_items().last() {
+            Some(it) => (
+                leading_indent(it.syntax()).unwrap_or("").to_string(),
+                InsertPosition::After(it.syntax().into()),
+            ),
+            None => match self.l_curly() {
+                Some(it) => (
+                    "    ".to_string() + leading_indent(self.ast().syntax()).unwrap_or(""),
+                    InsertPosition::After(it),
+                ),
+                None => return,
+            },
+        };
+        let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
+        let to_insert: ArrayVec<[SyntaxElement; 2]> =
+            [ws.ws().into(), fn_def.syntax().into()].into();
+        self.ast = self.insert_children(position, to_insert.into_iter());
+    }
+
+    fn l_curly(&self) -> Option<SyntaxElement> {
+        self.ast().syntax().children_with_tokens().find(|it| it.kind() == L_CURLY)
+    }
+}
+
+impl AstEditor<ast::FnDef> {
+    pub fn set_body(&mut self, body: &ast::Block) {
+        let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
+        let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.ast().body() {
+            old_body.syntax().into()
+        } else if let Some(semi) = self.ast().semicolon_token() {
+            to_insert.push(tokens::single_space().into());
+            semi.into()
+        } else {
+            to_insert.push(tokens::single_space().into());
+            to_insert.push(body.syntax().into());
+            self.ast = self.insert_children(InsertPosition::Last, to_insert.into_iter());
+            return;
+        };
+        to_insert.push(body.syntax().into());
+        let replace_range = RangeInclusive::new(old_body_or_semi, old_body_or_semi);
+        self.ast = self.replace_children(replace_range, to_insert.into_iter())
+    }
+
+    pub fn strip_attrs_and_docs(&mut self) {
+        loop {
+            if let Some(start) = self
+                .ast()
+                .syntax()
+                .children_with_tokens()
+                .find(|it| it.kind() == ATTR || it.kind() == COMMENT)
+            {
+                let end = match start.next_sibling_or_token() {
+                    Some(el) if el.kind() == WHITESPACE => el,
+                    Some(_) | None => start,
+                };
+                self.ast = self.replace_children(RangeInclusive::new(start, end), iter::empty());
+            } else {
+                break;
+            }
+        }
+    }
+}
+
+pub struct AstBuilder<N: AstNode> {
+    _phantom: std::marker::PhantomData<N>,
+}
+
+impl AstBuilder<ast::NamedField> {
+    fn from_text(text: &str) -> TreeArc<ast::NamedField> {
+        ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
+    }
+
+    pub fn from_pieces(name: &ast::NameRef, expr: Option<&ast::Expr>) -> TreeArc<ast::NamedField> {
+        match expr {
+            Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())),
+            None => Self::from_text(&name.syntax().to_string()),
+        }
+    }
+}
+
+impl AstBuilder<ast::Block> {
+    fn from_text(text: &str) -> TreeArc<ast::Block> {
+        ast_node_from_file_text(&format!("fn f() {}", text))
+    }
+
+    pub fn single_expr(e: &ast::Expr) -> TreeArc<ast::Block> {
+        Self::from_text(&format!("{{ {} }}", e.syntax()))
+    }
+}
+
+impl AstBuilder<ast::Expr> {
+    fn from_text(text: &str) -> TreeArc<ast::Expr> {
+        ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
+    }
+
+    pub fn unit() -> TreeArc<ast::Expr> {
+        Self::from_text("()")
+    }
+
+    pub fn unimplemented() -> TreeArc<ast::Expr> {
+        Self::from_text("unimplemented!()")
+    }
+}
+
+impl AstBuilder<ast::NameRef> {
+    pub fn new(text: &str) -> TreeArc<ast::NameRef> {
+        ast_node_from_file_text(&format!("fn f() {{ {}; }}", text))
+    }
+}
+
+fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
+    let file = SourceFile::parse(text);
+    let res = file.syntax().descendants().find_map(N::cast).unwrap().to_owned();
+    res
+}
+
+mod tokens {
+    use lazy_static::lazy_static;
+    use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*};
+
+    lazy_static! {
+        static ref SOURCE_FILE: TreeArc<SourceFile> = SourceFile::parse(",\n; ;");
+    }
+
+    pub(crate) fn comma() -> SyntaxToken<'static> {
+        SOURCE_FILE
+            .syntax()
+            .descendants_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == COMMA)
+            .unwrap()
+    }
+
+    pub(crate) fn single_space() -> SyntaxToken<'static> {
+        SOURCE_FILE
+            .syntax()
+            .descendants_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == " ")
+            .unwrap()
+    }
+
+    #[allow(unused)]
+    pub(crate) fn single_newline() -> SyntaxToken<'static> {
+        SOURCE_FILE
+            .syntax()
+            .descendants_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n")
+            .unwrap()
+    }
+
+    pub(crate) struct WsBuilder(TreeArc<SourceFile>);
+
+    impl WsBuilder {
+        pub(crate) fn new(text: &str) -> WsBuilder {
+            WsBuilder(SourceFile::parse(text))
+        }
+        pub(crate) fn ws(&self) -> SyntaxToken<'_> {
+            self.0.syntax().first_child_or_token().unwrap().as_token().unwrap()
+        }
+    }
+
+}
diff --git a/crates/ra_assists/src/fill_struct_fields.rs b/crates/ra_assists/src/fill_struct_fields.rs
index 663b4f669..54b70e17d 100644
--- a/crates/ra_assists/src/fill_struct_fields.rs
+++ b/crates/ra_assists/src/fill_struct_fields.rs
@@ -1,94 +1,55 @@
-use std::fmt::Write;
-
 use hir::{AdtDef, db::HirDatabase};
 
 use ra_syntax::ast::{self, AstNode};
 
-use crate::{AssistCtx, Assist, AssistId};
+use crate::{AssistCtx, Assist, AssistId, ast_editor::{AstEditor, AstBuilder}};
 
 pub(crate) fn fill_struct_fields(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let struct_lit = ctx.node_at_offset::<ast::StructLit>()?;
-    let mut fsf = FillStructFields {
-        ctx: &mut ctx,
-        named_field_list: struct_lit.named_field_list()?,
-        struct_fields: vec![],
-        struct_lit,
-    };
-    fsf.evaluate_struct_def_fields()?;
-    if fsf.struct_lit_and_def_have_the_same_number_of_fields() {
-        return None;
-    }
-    fsf.remove_already_included_fields()?;
-    fsf.add_action()?;
-    ctx.build()
-}
+    let named_field_list = struct_lit.named_field_list()?;
 
-struct FillStructFields<'a, 'b: 'a, DB> {
-    ctx: &'a mut AssistCtx<'b, DB>,
-    named_field_list: &'a ast::NamedFieldList,
-    struct_fields: Vec<(String, String)>,
-    struct_lit: &'a ast::StructLit,
-}
-
-impl<DB> FillStructFields<'_, '_, DB>
-where
-    DB: HirDatabase,
-{
-    fn add_action(&mut self) -> Option<()> {
-        let named_field_list = self.named_field_list;
-        let struct_fields_string = self.struct_fields_string()?;
-        let struct_lit = self.struct_lit;
-        self.ctx.add_action(AssistId("fill_struct_fields"), "fill struct fields", |edit| {
-            edit.target(struct_lit.syntax().range());
-            edit.set_cursor(struct_lit.syntax().range().start());
-            edit.replace_node_and_indent(named_field_list.syntax(), struct_fields_string);
-        });
-        Some(())
-    }
-
-    fn struct_lit_and_def_have_the_same_number_of_fields(&self) -> bool {
-        self.named_field_list.fields().count() == self.struct_fields.len()
-    }
-
-    fn evaluate_struct_def_fields(&mut self) -> Option<()> {
-        let analyzer = hir::SourceAnalyzer::new(
-            self.ctx.db,
-            self.ctx.frange.file_id,
-            self.struct_lit.syntax(),
-            None,
-        );
-        let struct_lit_ty = analyzer.type_of(self.ctx.db, self.struct_lit.into())?;
+    // Collect all fields from struct definition
+    let mut fields = {
+        let analyzer =
+            hir::SourceAnalyzer::new(ctx.db, ctx.frange.file_id, struct_lit.syntax(), None);
+        let struct_lit_ty = analyzer.type_of(ctx.db, struct_lit.into())?;
         let struct_def = match struct_lit_ty.as_adt() {
             Some((AdtDef::Struct(s), _)) => s,
             _ => return None,
         };
-        self.struct_fields = struct_def
-            .fields(self.ctx.db)
-            .into_iter()
-            .map(|f| (f.name(self.ctx.db).to_string(), "()".into()))
-            .collect();
-        Some(())
-    }
+        struct_def.fields(ctx.db)
+    };
 
-    fn remove_already_included_fields(&mut self) -> Option<()> {
-        for ast_field in self.named_field_list.fields() {
-            let expr = ast_field.expr()?.syntax().text().to_string();
-            let name_from_ast = ast_field.name_ref()?.text().to_string();
-            if let Some(idx) = self.struct_fields.iter().position(|(n, _)| n == &name_from_ast) {
-                self.struct_fields[idx] = (name_from_ast, expr);
-            }
-        }
-        Some(())
+    // Filter out existing fields
+    for ast_field in named_field_list.fields() {
+        let name_from_ast = ast_field.name_ref()?.text().to_string();
+        fields.retain(|field| field.name(ctx.db).to_string() != name_from_ast);
+    }
+    if fields.is_empty() {
+        return None;
     }
 
-    fn struct_fields_string(&mut self) -> Option<String> {
-        let mut buf = String::from("{\n");
-        for (name, expr) in &self.struct_fields {
-            write!(&mut buf, "    {}: {},\n", name, expr).unwrap();
+    let db = ctx.db;
+    ctx.add_action(AssistId("fill_struct_fields"), "fill struct fields", |edit| {
+        let mut ast_editor = AstEditor::new(named_field_list);
+        if named_field_list.fields().count() == 0 && fields.len() > 2 {
+            ast_editor.make_multiline();
+        };
+
+        for field in fields {
+            let field = AstBuilder::<ast::NamedField>::from_pieces(
+                &AstBuilder::<ast::NameRef>::new(&field.name(db).to_string()),
+                Some(&AstBuilder::<ast::Expr>::unit()),
+            );
+            ast_editor.append_field(&field);
         }
-        buf.push_str("}");
-        Some(buf)
-    }
+
+        edit.target(struct_lit.syntax().range());
+        edit.set_cursor(struct_lit.syntax().range().start());
+
+        ast_editor.into_text_edit(edit.text_edit_builder());
+    });
+    ctx.build()
 }
 
 #[cfg(test)]
@@ -225,14 +186,41 @@ mod tests {
 
             fn main() {
                 let s = <|>S {
+                    c: (1, 2),
+                    e: "foo",
                     a: (),
                     b: (),
-                    c: (1, 2),
                     d: (),
-                    e: "foo",
                 }
             }
             "#,
         );
     }
+
+    #[test]
+    fn fill_struct_short() {
+        check_assist(
+            fill_struct_fields,
+            r#"
+            struct S {
+                foo: u32,
+                bar: String,
+            }
+
+            fn main() {
+                let s = S {<|> };
+            }
+            "#,
+            r#"
+            struct S {
+                foo: u32,
+                bar: String,
+            }
+
+            fn main() {
+                let s = <|>S { foo: (), bar: () };
+            }
+            "#,
+        );
+    }
 }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 173c004cd..4c330c907 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -7,6 +7,7 @@
 
 mod assist_ctx;
 mod marks;
+pub mod ast_editor;
 
 use itertools::Itertools;
 
@@ -36,7 +37,7 @@ pub struct AssistAction {
     pub target: Option<TextRange>,
 }
 
-/// Return all the assists applicable at the given position.
+/// Return all the assists eapplicable at the given position.
 ///
 /// Assists are returned in the "unresolved" state, that is only labels are
 /// returned, without actual edits.
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index e771a311c..c7849c995 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -94,6 +94,13 @@ fn parse_macro(
 
     let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?;
     let tt = macro_rules.expand(&macro_arg).map_err(|err| format!("{:?}", err))?;
+
+    // Set a hard limit for the expanded tt
+    let count = tt.count();
+    if count > 65536 {
+        return Err(format!("Total tokens count exceed limit : count = {}", count));
+    }
+
     Ok(mbe::token_tree_to_ast_item_list(&tt))
 }
 
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 39152360c..fbfff4fd7 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -55,7 +55,7 @@ mod tests;
 
 use std::sync::Arc;
 
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use ra_arena::{Arena, RawId, impl_arena_id};
 use ra_db::{FileId, Edition};
 use test_utils::tested_by;
@@ -91,6 +91,19 @@ pub struct CrateDefMap {
     root: CrateModuleId,
     modules: Arena<CrateModuleId, ModuleData>,
     public_macros: FxHashMap<Name, MacroDefId>,
+
+    /// Some macros are not well-behavior, which leads to infinite loop
+    /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
+    /// We mark it down and skip it in collector
+    ///
+    /// FIXME:
+    /// Right now it only handle a poison macro in a single crate,
+    /// such that if other crate try to call that macro,
+    /// the whole process will do again until it became poisoned in that crate.
+    /// We should handle this macro set globally
+    /// However, do we want to put it as a global variable?
+    poison_macros: FxHashSet<MacroDefId>,
+
     diagnostics: Vec<DefDiagnostic>,
 }
 
@@ -195,6 +208,7 @@ impl CrateDefMap {
                 root,
                 modules,
                 public_macros: FxHashMap::default(),
+                poison_macros: FxHashSet::default(),
                 diagnostics: Vec::new(),
             }
         };
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 6147b3219..4590a5184 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -42,12 +42,40 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
         unresolved_imports: Vec::new(),
         unexpanded_macros: Vec::new(),
         global_macro_scope: FxHashMap::default(),
-        marco_stack_count: 0,
+        macro_stack_monitor: MacroStackMonitor::default(),
     };
     collector.collect();
     collector.finish()
 }
 
+#[derive(Default)]
+struct MacroStackMonitor {
+    counts: FxHashMap<MacroDefId, u32>,
+
+    /// Mainly use for test
+    validator: Option<Box<dyn Fn(u32) -> bool>>,
+}
+
+impl MacroStackMonitor {
+    fn increase(&mut self, macro_def_id: MacroDefId) {
+        *self.counts.entry(macro_def_id).or_default() += 1;
+    }
+
+    fn decrease(&mut self, macro_def_id: MacroDefId) {
+        *self.counts.entry(macro_def_id).or_default() -= 1;
+    }
+
+    fn is_poison(&self, macro_def_id: MacroDefId) -> bool {
+        let cur = *self.counts.get(&macro_def_id).unwrap_or(&0);
+
+        if let Some(validator) = &self.validator {
+            validator(cur)
+        } else {
+            cur > 100
+        }
+    }
+}
+
 /// Walks the tree of module recursively
 struct DefCollector<DB> {
     db: DB,
@@ -59,7 +87,7 @@ struct DefCollector<DB> {
 
     /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
     /// To prevent stackoverflow, we add a deep counter here for prevent that.
-    marco_stack_count: u32,
+    macro_stack_monitor: MacroStackMonitor,
 }
 
 impl<'a, DB> DefCollector<&'a DB>
@@ -317,30 +345,40 @@ where
             let def_map = self.db.crate_def_map(krate);
             if let Some(macro_id) = def_map.public_macros.get(&path.segments[1].name).cloned() {
                 let call_id = MacroCallLoc { def: macro_id, ast_id: *ast_id }.id(self.db);
-                resolved.push((*module_id, call_id));
+                resolved.push((*module_id, call_id, macro_id));
             }
             false
         });
 
-        for (module_id, macro_call_id) in resolved {
-            self.collect_macro_expansion(module_id, macro_call_id);
+        for (module_id, macro_call_id, macro_def_id) in resolved {
+            self.collect_macro_expansion(module_id, macro_call_id, macro_def_id);
         }
         res
     }
 
-    fn collect_macro_expansion(&mut self, module_id: CrateModuleId, macro_call_id: MacroCallId) {
-        self.marco_stack_count += 1;
+    fn collect_macro_expansion(
+        &mut self,
+        module_id: CrateModuleId,
+        macro_call_id: MacroCallId,
+        macro_def_id: MacroDefId,
+    ) {
+        if self.def_map.poison_macros.contains(&macro_def_id) {
+            return;
+        }
+
+        self.macro_stack_monitor.increase(macro_def_id);
 
-        if self.marco_stack_count < 300 {
+        if !self.macro_stack_monitor.is_poison(macro_def_id) {
             let file_id: HirFileId = macro_call_id.into();
             let raw_items = self.db.raw_items(file_id);
             ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items }
-                .collect(raw_items.items())
+                .collect(raw_items.items());
         } else {
             log::error!("Too deep macro expansion: {}", macro_call_id.debug_dump(self.db));
+            self.def_map.poison_macros.insert(macro_def_id);
         }
 
-        self.marco_stack_count -= 1;
+        self.macro_stack_monitor.decrease(macro_def_id);
     }
 
     fn finish(self) -> CrateDefMap {
@@ -484,7 +522,7 @@ where
         {
             let macro_call_id = MacroCallLoc { def: macro_id, ast_id }.id(self.def_collector.db);
 
-            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id);
+            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_id);
             return;
         }
 
@@ -530,3 +568,108 @@ fn resolve_submodule(
         None => Err(if is_dir_owner { file_mod } else { file_dir_mod }),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use ra_db::SourceDatabase;
+
+    use crate::{Crate, mock::MockDatabase, DefDatabase};
+    use ra_arena::{Arena};
+    use super::*;
+    use rustc_hash::FxHashSet;
+
+    fn do_collect_defs(
+        db: &impl DefDatabase,
+        def_map: CrateDefMap,
+        monitor: MacroStackMonitor,
+    ) -> CrateDefMap {
+        let mut collector = DefCollector {
+            db,
+            def_map,
+            glob_imports: FxHashMap::default(),
+            unresolved_imports: Vec::new(),
+            unexpanded_macros: Vec::new(),
+            global_macro_scope: FxHashMap::default(),
+            macro_stack_monitor: monitor,
+        };
+        collector.collect();
+        collector.finish()
+    }
+
+    fn do_limited_resolve(code: &str, limit: u32, poison_limit: u32) -> CrateDefMap {
+        let (db, _source_root, _) = MockDatabase::with_single_file(&code);
+        let crate_id = db.crate_graph().iter().next().unwrap();
+        let krate = Crate { crate_id };
+
+        let def_map = {
+            let edition = krate.edition(&db);
+            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+            let root = modules.alloc(ModuleData::default());
+            CrateDefMap {
+                krate,
+                edition,
+                extern_prelude: FxHashMap::default(),
+                prelude: None,
+                root,
+                modules,
+                public_macros: FxHashMap::default(),
+                poison_macros: FxHashSet::default(),
+                diagnostics: Vec::new(),
+            }
+        };
+
+        let mut monitor = MacroStackMonitor::default();
+        monitor.validator = Some(Box::new(move |count| {
+            assert!(count < limit);
+            count >= poison_limit
+        }));
+
+        do_collect_defs(&db, def_map, monitor)
+    }
+
+    #[test]
+    fn test_macro_expand_limit_width() {
+        do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); }
+        }
+foo!(KABOOM);
+        "#,
+            16,
+            1000,
+        );
+    }
+
+    #[test]
+    fn test_macro_expand_poisoned() {
+        let def = do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($ty:ty) => { foo!($ty); }
+        }
+foo!(KABOOM);
+        "#,
+            100,
+            16,
+        );
+
+        assert_eq!(def.poison_macros.len(), 1);
+    }
+
+    #[test]
+    fn test_macro_expand_normal() {
+        let def = do_limited_resolve(
+            r#"
+        macro_rules! foo {
+            ($ident:ident) => { struct $ident {} }
+        }
+foo!(Bar);
+        "#,
+            16,
+            16,
+        );
+
+        assert_eq!(def.poison_macros.len(), 0);
+    }
+}
diff --git a/crates/ra_ide_api/src/completion/complete_postfix.rs b/crates/ra_ide_api/src/completion/complete_postfix.rs
index 4dfa5f176..278b1b797 100644
--- a/crates/ra_ide_api/src/completion/complete_postfix.rs
+++ b/crates/ra_ide_api/src/completion/complete_postfix.rs
@@ -40,7 +40,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
             ctx,
             "match",
             "match expr {}",
-            &format!("match {} {{\n${{1:_}} => {{$0\\}},\n}}", receiver_text),
+            &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
         )
         .add_to(acc);
         postfix_snippet(
diff --git a/crates/ra_ide_api/src/completion/snapshots/completion_item__postfix_completion_works_for_trivial_path_expression.snap b/crates/ra_ide_api/src/completion/snapshots/completion_item__postfix_completion_works_for_trivial_path_expression.snap
index 2b5435f0c..3bbc9e3c4 100644
--- a/crates/ra_ide_api/src/completion/snapshots/completion_item__postfix_completion_works_for_trivial_path_expression.snap
+++ b/crates/ra_ide_api/src/completion/snapshots/completion_item__postfix_completion_works_for_trivial_path_expression.snap
@@ -1,6 +1,6 @@
 ---
-created: "2019-02-18T09:22:24.127119709Z"
-creator: insta@0.6.2
+created: "2019-04-22T07:37:13.981826301Z"
+creator: insta@0.7.4
 source: crates/ra_ide_api/src/completion/completion_item.rs
 expression: kind_completions
 ---
@@ -23,7 +23,7 @@ expression: kind_completions
         label: "match",
         source_range: [76; 76),
         delete: [72; 76),
-        insert: "match bar {\n${1:_} => {$0\\},\n}",
+        insert: "match bar {\n    ${1:_} => {$0\\},\n}",
         detail: "match expr {}"
     },
     CompletionItem {
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index e78bc734b..eedc0c5dd 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -199,7 +199,7 @@ impl_froms!(TokenTree: Leaf, Subtree);
         rules.expand(&invocation_tt).unwrap()
     }
 
-    pub(crate) fn expand_to_syntax(
+    pub(crate) fn expand_to_items(
         rules: &MacroRules,
         invocation: &str,
     ) -> ra_syntax::TreeArc<ast::MacroItems> {
@@ -207,7 +207,28 @@ impl_froms!(TokenTree: Leaf, Subtree);
         token_tree_to_macro_items(&expanded).unwrap()
     }
 
-    pub(crate) fn assert_expansion(rules: &MacroRules, invocation: &str, expansion: &str) {
+    #[allow(unused)]
+    pub(crate) fn expand_to_stmts(
+        rules: &MacroRules,
+        invocation: &str,
+    ) -> ra_syntax::TreeArc<ast::MacroStmts> {
+        let expanded = expand(rules, invocation);
+        token_tree_to_macro_stmts(&expanded).unwrap()
+    }
+
+    pub(crate) fn expand_to_expr(
+        rules: &MacroRules,
+        invocation: &str,
+    ) -> ra_syntax::TreeArc<ast::Expr> {
+        let expanded = expand(rules, invocation);
+        token_tree_to_expr(&expanded).unwrap()
+    }
+
+    pub(crate) fn assert_expansion(
+        rules: &MacroRules,
+        invocation: &str,
+        expansion: &str,
+    ) -> tt::Subtree {
         let expanded = expand(rules, invocation);
         assert_eq!(expanded.to_string(), expansion);
 
@@ -224,6 +245,8 @@ impl_froms!(TokenTree: Leaf, Subtree);
 
         let file = file.replace("C_C__C", "$crate");
         assert_eq!(tree, file,);
+
+        expanded
     }
 
     #[test]
@@ -638,7 +661,7 @@ MACRO_ITEMS@[0; 40)
         );
 
         assert_eq!(
-            expand_to_syntax(&rules, "foo! { 1 + 1  }").syntax().debug_dump().trim(),
+            expand_to_items(&rules, "foo! { 1 + 1  }").syntax().debug_dump().trim(),
             r#"MACRO_ITEMS@[0; 15)
   FN_DEF@[0; 15)
     FN_KW@[0; 2) "fn"
@@ -914,6 +937,78 @@ MACRO_ITEMS@[0; 40)
 "#,
         );
         assert_expansion(&rules, r#"vec!();"#, r#"{let mut v = Vec :: new () ;  v}"#);
+        assert_expansion(
+            &rules,
+            r#"vec![1u32,2]"#,
+            r#"{let mut v = Vec :: new () ; v . push (1u32) ; v . push (2) ; v}"#,
+        );
+
+        assert_eq!(
+            expand_to_expr(&rules, r#"vec![1u32,2]"#).syntax().debug_dump().trim(),
+            r#"BLOCK_EXPR@[0; 45)
+  BLOCK@[0; 45)
+    L_CURLY@[0; 1) "{"
+    LET_STMT@[1; 20)
+      LET_KW@[1; 4) "let"
+      BIND_PAT@[4; 8)
+        MUT_KW@[4; 7) "mut"
+        NAME@[7; 8)
+          IDENT@[7; 8) "v"
+      EQ@[8; 9) "="
+      CALL_EXPR@[9; 19)
+        PATH_EXPR@[9; 17)
+          PATH@[9; 17)
+            PATH@[9; 12)
+              PATH_SEGMENT@[9; 12)
+                NAME_REF@[9; 12)
+                  IDENT@[9; 12) "Vec"
+            COLONCOLON@[12; 14) "::"
+            PATH_SEGMENT@[14; 17)
+              NAME_REF@[14; 17)
+                IDENT@[14; 17) "new"
+        ARG_LIST@[17; 19)
+          L_PAREN@[17; 18) "("
+          R_PAREN@[18; 19) ")"
+      SEMI@[19; 20) ";"
+    EXPR_STMT@[20; 33)
+      METHOD_CALL_EXPR@[20; 32)
+        PATH_EXPR@[20; 21)
+          PATH@[20; 21)
+            PATH_SEGMENT@[20; 21)
+              NAME_REF@[20; 21)
+                IDENT@[20; 21) "v"
+        DOT@[21; 22) "."
+        NAME_REF@[22; 26)
+          IDENT@[22; 26) "push"
+        ARG_LIST@[26; 32)
+          L_PAREN@[26; 27) "("
+          LITERAL@[27; 31)
+            INT_NUMBER@[27; 31) "1u32"
+          R_PAREN@[31; 32) ")"
+      SEMI@[32; 33) ";"
+    EXPR_STMT@[33; 43)
+      METHOD_CALL_EXPR@[33; 42)
+        PATH_EXPR@[33; 34)
+          PATH@[33; 34)
+            PATH_SEGMENT@[33; 34)
+              NAME_REF@[33; 34)
+                IDENT@[33; 34) "v"
+        DOT@[34; 35) "."
+        NAME_REF@[35; 39)
+          IDENT@[35; 39) "push"
+        ARG_LIST@[39; 42)
+          L_PAREN@[39; 40) "("
+          LITERAL@[40; 41)
+            INT_NUMBER@[40; 41) "2"
+          R_PAREN@[41; 42) ")"
+      SEMI@[42; 43) ";"
+    PATH_EXPR@[43; 44)
+      PATH@[43; 44)
+        PATH_SEGMENT@[43; 44)
+          NAME_REF@[43; 44)
+            IDENT@[43; 44) "v"
+    R_CURLY@[44; 45) "}""#
+        );
     }
 
     #[test]
diff --git a/crates/ra_mbe/src/subtree_parser.rs b/crates/ra_mbe/src/subtree_parser.rs
index 528aa0f8a..f07107414 100644
--- a/crates/ra_mbe/src/subtree_parser.rs
+++ b/crates/ra_mbe/src/subtree_parser.rs
@@ -5,6 +5,7 @@ use ra_syntax::{SyntaxKind};
 
 struct OffsetTokenSink {
     token_pos: usize,
+    error: bool,
 }
 
 impl TreeSink for OffsetTokenSink {
@@ -13,7 +14,9 @@ impl TreeSink for OffsetTokenSink {
     }
     fn start_node(&mut self, _kind: SyntaxKind) {}
     fn finish_node(&mut self) {}
-    fn error(&mut self, _error: ra_parser::ParseError) {}
+    fn error(&mut self, _error: ra_parser::ParseError) {
+        self.error = true;
+    }
 }
 
 pub(crate) struct Parser<'a> {
@@ -67,11 +70,15 @@ impl<'a> Parser<'a> {
         F: FnOnce(&dyn TokenSource, &mut dyn TreeSink),
     {
         let mut src = SubtreeTokenSource::new(&self.subtree.token_trees[*self.cur_pos..]);
-        let mut sink = OffsetTokenSink { token_pos: 0 };
+        let mut sink = OffsetTokenSink { token_pos: 0, error: false };
 
         f(&src, &mut sink);
 
-        self.finish(sink.token_pos, &mut src)
+        let r = self.finish(sink.token_pos, &mut src);
+        if sink.error {
+            return None;
+        }
+        r
     }
 
     fn finish(self, parsed_token: usize, src: &mut SubtreeTokenSource) -> Option<tt::TokenTree> {
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 5c4c0ffc1..9cbd2c6b8 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -210,6 +210,15 @@ impl ast::EnumVariant {
     }
 }
 
+impl ast::FnDef {
+    pub fn semicolon_token(&self) -> Option<SyntaxToken<'_>> {
+        self.syntax()
+            .last_child_or_token()
+            .and_then(|it| it.as_token())
+            .filter(|it| it.kind() == SEMI)
+    }
+}
+
 impl ast::LetStmt {
     pub fn has_semi(&self) -> bool {
         match self.syntax().last_child_or_token() {
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index a6ce14f06..9cb66b76b 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -38,7 +38,7 @@ pub use crate::{
     ast::AstNode,
     syntax_error::{SyntaxError, SyntaxErrorKind, Location},
     syntax_text::SyntaxText,
-    syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc, SyntaxTreeBuilder, SyntaxElement, SyntaxToken},
+    syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc, SyntaxTreeBuilder, SyntaxElement, SyntaxToken, InsertPosition},
     ptr::{SyntaxNodePtr, AstPtr},
     parsing::{tokenize, classify_literal, Token},
 };
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index 15a8b94cd..b0816b135 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -10,7 +10,7 @@ use crate::{
 /// specific node across reparses of the same file.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct SyntaxNodePtr {
-    range: TextRange,
+    pub(crate) range: TextRange,
     kind: SyntaxKind,
 }
 
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index dc2352c76..92c15234e 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -7,6 +7,7 @@
 //! modules just wraps its API.
 
 use std::{
+    ops::RangeInclusive,
     fmt::{self, Write},
     any::Any,
     borrow::Borrow,
@@ -17,13 +18,21 @@ use ra_parser::ParseError;
 use rowan::{TransparentNewType, GreenNodeBuilder};
 
 use crate::{
-    SmolStr, SyntaxKind, TextUnit, TextRange, SyntaxText, SourceFile, AstNode,
+    SmolStr, SyntaxKind, TextUnit, TextRange, SyntaxText, SourceFile, AstNode, SyntaxNodePtr,
     syntax_error::{SyntaxError, SyntaxErrorKind},
 };
 
 pub use rowan::WalkEvent;
 pub(crate) use rowan::{GreenNode, GreenToken};
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum InsertPosition<T> {
+    First,
+    Last,
+    Before(T),
+    After(T),
+}
+
 /// Marker trait for CST and AST nodes
 pub trait SyntaxNodeWrapper: TransparentNewType<Repr = rowan::SyntaxNode> {}
 impl<T: TransparentNewType<Repr = rowan::SyntaxNode>> SyntaxNodeWrapper for T {}
@@ -309,6 +318,97 @@ impl SyntaxNode {
     pub(crate) fn replace_with(&self, replacement: GreenNode) -> GreenNode {
         self.0.replace_with(replacement)
     }
+
+    /// Adds specified children (tokens or nodes) to the current node at the
+    /// specific position.
+    ///
+    /// This is a type-unsafe low-level editing API, if you need to use it,
+    /// prefer to create a type-safe abstraction on top of it instead.
+    pub fn insert_children<'a>(
+        &self,
+        position: InsertPosition<SyntaxElement<'_>>,
+        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+    ) -> TreeArc<SyntaxNode> {
+        let mut delta = TextUnit::default();
+        let to_insert = to_insert.map(|element| {
+            delta += element.text_len();
+            to_green_element(element)
+        });
+
+        let old_children = self.0.green().children();
+
+        let new_children = match position {
+            InsertPosition::First => {
+                to_insert.chain(old_children.iter().cloned()).collect::<Box<[_]>>()
+            }
+            InsertPosition::Last => {
+                old_children.iter().cloned().chain(to_insert).collect::<Box<[_]>>()
+            }
+            InsertPosition::Before(anchor) | InsertPosition::After(anchor) => {
+                let take_anchor = if let InsertPosition::After(_) = position { 1 } else { 0 };
+                let split_at = self.position_of_child(anchor) + take_anchor;
+                let (before, after) = old_children.split_at(split_at);
+                before
+                    .iter()
+                    .cloned()
+                    .chain(to_insert)
+                    .chain(after.iter().cloned())
+                    .collect::<Box<[_]>>()
+            }
+        };
+
+        self.with_children(new_children)
+    }
+
+    /// Replaces all nodes in `to_delete` with nodes from `to_insert`
+    ///
+    /// This is a type-unsafe low-level editing API, if you need to use it,
+    /// prefer to create a type-safe abstraction on top of it instead.
+    pub fn replace_children<'a>(
+        &self,
+        to_delete: RangeInclusive<SyntaxElement<'_>>,
+        to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+    ) -> TreeArc<SyntaxNode> {
+        let start = self.position_of_child(*to_delete.start());
+        let end = self.position_of_child(*to_delete.end());
+        let old_children = self.0.green().children();
+
+        let new_children = old_children[..start]
+            .iter()
+            .cloned()
+            .chain(to_insert.map(to_green_element))
+            .chain(old_children[end + 1..].iter().cloned())
+            .collect::<Box<[_]>>();
+        self.with_children(new_children)
+    }
+
+    fn with_children(&self, new_children: Box<[rowan::GreenElement]>) -> TreeArc<SyntaxNode> {
+        let len = new_children.iter().map(|it| it.text_len()).sum::<TextUnit>();
+        let new_node = GreenNode::new(rowan::SyntaxKind(self.kind() as u16), new_children);
+        let new_file_node = self.replace_with(new_node);
+        let file = SourceFile::new(new_file_node, Vec::new());
+
+        // FIXME: use a more elegant way to re-fetch the node (#1185), make
+        // `range` private afterwards
+        let mut ptr = SyntaxNodePtr::new(self);
+        ptr.range = TextRange::offset_len(ptr.range().start(), len);
+        return ptr.to_node(&file).to_owned();
+    }
+
+    fn position_of_child(&self, child: SyntaxElement) -> usize {
+        self.children_with_tokens()
+            .position(|it| it == child)
+            .expect("elemetn is not a child of current element")
+    }
+}
+
+fn to_green_element(element: SyntaxElement) -> rowan::GreenElement {
+    match element {
+        SyntaxElement::Node(node) => node.0.green().clone().into(),
+        SyntaxElement::Token(tok) => {
+            GreenToken::new(rowan::SyntaxKind(tok.kind() as u16), tok.text().clone()).into()
+        }
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
@@ -451,6 +551,13 @@ impl<'a> SyntaxElement<'a> {
         }
         .ancestors()
     }
+
+    fn text_len(&self) -> TextUnit {
+        match self {
+            SyntaxElement::Node(node) => node.0.green().text_len(),
+            SyntaxElement::Token(token) => TextUnit::of_str(token.0.text()),
+        }
+    }
 }
 
 impl<'a> From<rowan::SyntaxElement<'a>> for SyntaxElement<'a> {
diff --git a/crates/ra_tt/src/lib.rs b/crates/ra_tt/src/lib.rs
index 0b0b9b4d2..62c5ac52a 100644
--- a/crates/ra_tt/src/lib.rs
+++ b/crates/ra_tt/src/lib.rs
@@ -149,3 +149,19 @@ impl fmt::Display for Punct {
         fmt::Display::fmt(&self.char, f)
     }
 }
+
+impl Subtree {
+    /// Count the number of tokens recursively
+    pub fn count(&self) -> usize {
+        let children_count = self
+            .token_trees
+            .iter()
+            .map(|c| match c {
+                TokenTree::Subtree(c) => c.count(),
+                _ => 0,
+            })
+            .sum::<usize>();
+
+        self.token_trees.len() + children_count
+    }
+}