7 files changed, 232 insertions, 85 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 8efc6b368..6fccc2303 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -11,7 +11,7 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 doctest = false
 
 [dependencies]
-itertools = "0.8.2"
+itertools = "0.9.0"
 rowan = "0.9.1"
 rustc_lexer = "0.1.0"
 rustc-hash = "1.1.0"
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index ffdbdc767..191123c8e 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -1,6 +1,9 @@
 //! FIXME: write short doc here
 
-use std::ops::RangeInclusive;
+use std::{
+    fmt,
+    ops::{self, RangeInclusive},
+};
 
 use itertools::Itertools;
 use ra_text_edit::TextEditBuilder;
@@ -222,44 +225,110 @@ fn _replace_children(
     with_children(parent, new_children)
 }
 
-/// Replaces descendants in the node, according to the mapping.
-///
-/// 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_descendants(
-    parent: &SyntaxNode,
-    map: impl Fn(&SyntaxElement) -> Option<SyntaxElement>,
-) -> SyntaxNode {
-    _replace_descendants(parent, &map)
+#[derive(Default)]
+pub struct SyntaxRewriter<'a> {
+    f: Option<Box<dyn Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a>>,
+    //FIXME: add debug_assertions that all elements are in fact from the same file.
+    replacements: FxHashMap<SyntaxElement, Replacement>,
 }
 
-fn _replace_descendants(
-    parent: &SyntaxNode,
-    map: &dyn Fn(&SyntaxElement) -> Option<SyntaxElement>,
-) -> SyntaxNode {
-    //  FIXME: this could be made much faster.
-    let new_children = parent.children_with_tokens().map(|it| go(map, it)).collect::<Vec<_>>();
-    return with_children(parent, new_children);
+impl fmt::Debug for SyntaxRewriter<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SyntaxRewriter").field("replacements", &self.replacements).finish()
+    }
+}
 
-    fn go(
-        map: &dyn Fn(&SyntaxElement) -> Option<SyntaxElement>,
-        element: SyntaxElement,
-    ) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
-        if let Some(replacement) = map(&element) {
+impl<'a> SyntaxRewriter<'a> {
+    pub fn from_fn(f: impl Fn(&SyntaxElement) -> Option<SyntaxElement> + 'a) -> SyntaxRewriter<'a> {
+        SyntaxRewriter { f: Some(Box::new(f)), replacements: FxHashMap::default() }
+    }
+    pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
+        let what = what.clone().into();
+        let replacement = Replacement::Delete;
+        self.replacements.insert(what, replacement);
+    }
+    pub fn replace<T: Clone + Into<SyntaxElement>>(&mut self, what: &T, with: &T) {
+        let what = what.clone().into();
+        let replacement = Replacement::Single(with.clone().into());
+        self.replacements.insert(what, replacement);
+    }
+    pub fn replace_ast<T: AstNode>(&mut self, what: &T, with: &T) {
+        self.replace(what.syntax(), with.syntax())
+    }
+
+    pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
+        if self.f.is_none() && self.replacements.is_empty() {
+            return node.clone();
+        }
+        self.rewrite_children(node)
+    }
+
+    pub fn rewrite_ast<N: AstNode>(self, node: &N) -> N {
+        N::cast(self.rewrite(node.syntax())).unwrap()
+    }
+
+    pub fn rewrite_root(&self) -> Option<SyntaxNode> {
+        assert!(self.f.is_none());
+        self.replacements
+            .keys()
+            .map(|element| match element {
+                SyntaxElement::Node(it) => it.clone(),
+                SyntaxElement::Token(it) => it.parent(),
+            })
+            .fold1(|a, b| least_common_ancestor(&a, &b).unwrap())
+    }
+
+    fn replacement(&self, element: &SyntaxElement) -> Option<Replacement> {
+        if let Some(f) = &self.f {
+            assert!(self.replacements.is_empty());
+            return f(element).map(Replacement::Single);
+        }
+        self.replacements.get(element).cloned()
+    }
+
+    fn rewrite_children(&self, node: &SyntaxNode) -> SyntaxNode {
+        //  FIXME: this could be made much faster.
+        let new_children =
+            node.children_with_tokens().flat_map(|it| self.rewrite_self(&it)).collect::<Vec<_>>();
+        with_children(node, new_children)
+    }
+
+    fn rewrite_self(
+        &self,
+        element: &SyntaxElement,
+    ) -> Option<NodeOrToken<rowan::GreenNode, rowan::GreenToken>> {
+        if let Some(replacement) = self.replacement(&element) {
             return match replacement {
-                NodeOrToken::Node(it) => NodeOrToken::Node(it.green().clone()),
-                NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
+                Replacement::Single(NodeOrToken::Node(it)) => {
+                    Some(NodeOrToken::Node(it.green().clone()))
+                }
+                Replacement::Single(NodeOrToken::Token(it)) => {
+                    Some(NodeOrToken::Token(it.green().clone()))
+                }
+                Replacement::Delete => None,
             };
         }
-        match element {
+        let res = match element {
             NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
-            NodeOrToken::Node(it) => {
-                NodeOrToken::Node(_replace_descendants(&it, map).green().clone())
-            }
-        }
+            NodeOrToken::Node(it) => NodeOrToken::Node(self.rewrite_children(it).green().clone()),
+        };
+        Some(res)
     }
 }
 
+impl<'a> ops::AddAssign for SyntaxRewriter<'_> {
+    fn add_assign(&mut self, rhs: SyntaxRewriter) {
+        assert!(rhs.f.is_none());
+        self.replacements.extend(rhs.replacements)
+    }
+}
+
+#[derive(Clone, Debug)]
+enum Replacement {
+    Delete,
+    Single(SyntaxElement),
+}
+
 fn with_children(
     parent: &SyntaxNode,
     new_children: Vec<NodeOrToken<rowan::GreenNode, rowan::GreenToken>>,
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 68dae008f..f74c9f9c6 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -4,7 +4,6 @@
 use std::{iter, ops::RangeInclusive};
 
 use arrayvec::ArrayVec;
-use rustc_hash::FxHashMap;
 
 use crate::{
     algo,
@@ -17,6 +16,7 @@ use crate::{
     SyntaxKind::{ATTR, COMMENT, WHITESPACE},
     SyntaxNode, SyntaxToken, T,
 };
+use algo::{neighbor, SyntaxRewriter};
 
 impl ast::BinExpr {
     #[must_use]
@@ -255,6 +255,28 @@ impl ast::UseItem {
         }
         self.clone()
     }
+
+    pub fn remove(&self) -> SyntaxRewriter<'static> {
+        let mut res = SyntaxRewriter::default();
+        res.delete(self.syntax());
+        let next_ws = self
+            .syntax()
+            .next_sibling_or_token()
+            .and_then(|it| it.into_token())
+            .and_then(ast::Whitespace::cast);
+        if let Some(next_ws) = next_ws {
+            let ws_text = next_ws.syntax().text();
+            if ws_text.starts_with('\n') {
+                let rest = &ws_text[1..];
+                if rest.is_empty() {
+                    res.delete(next_ws.syntax())
+                } else {
+                    res.replace(next_ws.syntax(), &make::tokens::whitespace(rest));
+                }
+            }
+        }
+        res
+    }
 }
 
 impl ast::UseTree {
@@ -293,14 +315,30 @@ impl ast::UseTree {
             Some(res)
         }
     }
+
+    pub fn remove(&self) -> SyntaxRewriter<'static> {
+        let mut res = SyntaxRewriter::default();
+        res.delete(self.syntax());
+        for &dir in [Direction::Next, Direction::Prev].iter() {
+            if let Some(nb) = neighbor(self, dir) {
+                self.syntax()
+                    .siblings_with_tokens(dir)
+                    .skip(1)
+                    .take_while(|it| it.as_node() != Some(nb.syntax()))
+                    .for_each(|el| res.delete(&el));
+                return res;
+            }
+        }
+        res
+    }
 }
 
 #[must_use]
-pub fn strip_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
-    N::cast(strip_attrs_and_docs_inner(node.syntax().clone())).unwrap()
+pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
+    N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
 }
 
-fn strip_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
+fn remove_attrs_and_docs_inner(mut node: SyntaxNode) -> SyntaxNode {
     while let Some(start) =
         node.children_with_tokens().find(|it| it.kind() == ATTR || it.kind() == COMMENT)
     {
@@ -343,28 +381,24 @@ impl IndentLevel {
     }
 
     fn _increase_indent(self, node: SyntaxNode) -> SyntaxNode {
-        let replacements: FxHashMap<SyntaxElement, SyntaxElement> = node
-            .descendants_with_tokens()
+        let mut rewriter = SyntaxRewriter::default();
+        node.descendants_with_tokens()
             .filter_map(|el| el.into_token())
             .filter_map(ast::Whitespace::cast)
             .filter(|ws| {
                 let text = ws.syntax().text();
                 text.contains('\n')
             })
-            .map(|ws| {
-                (
-                    ws.syntax().clone().into(),
-                    make::tokens::whitespace(&format!(
-                        "{}{:width$}",
-                        ws.syntax().text(),
-                        "",
-                        width = self.0 as usize * 4
-                    ))
-                    .into(),
-                )
-            })
-            .collect();
-        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
+            .for_each(|ws| {
+                let new_ws = make::tokens::whitespace(&format!(
+                    "{}{:width$}",
+                    ws.syntax().text(),
+                    "",
+                    width = self.0 as usize * 4
+                ));
+                rewriter.replace(ws.syntax(), &new_ws)
+            });
+        rewriter.rewrite(&node)
     }
 
     pub fn decrease_indent<N: AstNode>(self, node: N) -> N {
@@ -372,27 +406,21 @@ impl IndentLevel {
     }
 
     fn _decrease_indent(self, node: SyntaxNode) -> SyntaxNode {
-        let replacements: FxHashMap<SyntaxElement, SyntaxElement> = node
-            .descendants_with_tokens()
+        let mut rewriter = SyntaxRewriter::default();
+        node.descendants_with_tokens()
             .filter_map(|el| el.into_token())
             .filter_map(ast::Whitespace::cast)
             .filter(|ws| {
                 let text = ws.syntax().text();
                 text.contains('\n')
             })
-            .map(|ws| {
-                (
-                    ws.syntax().clone().into(),
-                    make::tokens::whitespace(
-                        &ws.syntax()
-                            .text()
-                            .replace(&format!("\n{:1$}", "", self.0 as usize * 4), "\n"),
-                    )
-                    .into(),
-                )
-            })
-            .collect();
-        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
+            .for_each(|ws| {
+                let new_ws = make::tokens::whitespace(
+                    &ws.syntax().text().replace(&format!("\n{:1$}", "", self.0 as usize * 4), "\n"),
+                );
+                rewriter.replace(ws.syntax(), &new_ws)
+            });
+        rewriter.rewrite(&node)
     }
 }
 
@@ -442,12 +470,11 @@ pub trait AstNodeEdit: AstNode + Sized {
         &self,
         replacement_map: impl IntoIterator<Item = (D, D)>,
     ) -> Self {
-        let map = replacement_map
-            .into_iter()
-            .map(|(from, to)| (from.syntax().clone().into(), to.syntax().clone().into()))
-            .collect::<FxHashMap<SyntaxElement, _>>();
-        let new_syntax = algo::replace_descendants(self.syntax(), |n| map.get(n).cloned());
-        Self::cast(new_syntax).unwrap()
+        let mut rewriter = SyntaxRewriter::default();
+        for (from, to) in replacement_map {
+            rewriter.replace(from.syntax(), to.syntax())
+        }
+        rewriter.rewrite_ast(self)
     }
 }
 
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 9257ccd1a..1145b69e8 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -87,6 +87,9 @@ pub fn block_from_expr(e: ast::Expr) -> ast::Block {
 pub fn expr_unit() -> ast::Expr {
     expr_from_text("()")
 }
+pub fn expr_empty_block() -> ast::Expr {
+    expr_from_text("{}")
+}
 pub fn expr_unimplemented() -> ast::Expr {
     expr_from_text("unimplemented!()")
 }
diff --git a/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt b/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
index e0edf6a2d..0ffbd25aa 100644
--- a/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
+++ b/crates/ra_syntax/test_data/parser/err/0010_unsafe_lambda_block.txt
@@ -12,8 +12,8 @@ SOURCE_FILE@[0; 42)
       BLOCK@[10; 41)
         L_CURLY@[10; 11) "{"
         WHITESPACE@[11; 16) "\n    "
-        EXPR_STMT@[16; 39)
-          LAMBDA_EXPR@[16; 38)
+        EXPR_STMT@[16; 24)
+          LAMBDA_EXPR@[16; 24)
             PARAM_LIST@[16; 18)
               PIPE@[16; 17) "|"
               PIPE@[17; 18) "|"
@@ -24,20 +24,22 @@ SOURCE_FILE@[0; 42)
               TUPLE_TYPE@[22; 24)
                 L_PAREN@[22; 23) "("
                 R_PAREN@[23; 24) ")"
-            WHITESPACE@[24; 25) " "
-            BLOCK_EXPR@[25; 38)
-              UNSAFE_KW@[25; 31) "unsafe"
-              WHITESPACE@[31; 32) " "
-              BLOCK@[32; 38)
-                L_CURLY@[32; 33) "{"
-                WHITESPACE@[33; 34) " "
-                TUPLE_EXPR@[34; 36)
-                  L_PAREN@[34; 35) "("
-                  R_PAREN@[35; 36) ")"
-                WHITESPACE@[36; 37) " "
-                R_CURLY@[37; 38) "}"
+        WHITESPACE@[24; 25) " "
+        EXPR_STMT@[25; 39)
+          BLOCK_EXPR@[25; 38)
+            UNSAFE_KW@[25; 31) "unsafe"
+            WHITESPACE@[31; 32) " "
+            BLOCK@[32; 38)
+              L_CURLY@[32; 33) "{"
+              WHITESPACE@[33; 34) " "
+              TUPLE_EXPR@[34; 36)
+                L_PAREN@[34; 35) "("
+                R_PAREN@[35; 36) ")"
+              WHITESPACE@[36; 37) " "
+              R_CURLY@[37; 38) "}"
           SEMI@[38; 39) ";"
         WHITESPACE@[39; 40) "\n"
         R_CURLY@[40; 41) "}"
   WHITESPACE@[41; 42) "\n"
 error [24; 24): expected `{`
+error [24; 24): expected SEMI
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs
new file mode 100644
index 000000000..061118d3a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.rs
@@ -0,0 +1 @@
+fn main() { || -> i32 { 92 }(); }
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt
new file mode 100644
index 000000000..ba8779094
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_lambda_ret_block.txt
@@ -0,0 +1,45 @@
+SOURCE_FILE@[0; 34)
+  FN_DEF@[0; 33)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "main"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 33)
+      BLOCK@[10; 33)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 12) " "
+        EXPR_STMT@[12; 31)
+          CALL_EXPR@[12; 30)
+            LAMBDA_EXPR@[12; 28)
+              PARAM_LIST@[12; 14)
+                PIPE@[12; 13) "|"
+                PIPE@[13; 14) "|"
+              WHITESPACE@[14; 15) " "
+              RET_TYPE@[15; 21)
+                THIN_ARROW@[15; 17) "->"
+                WHITESPACE@[17; 18) " "
+                PATH_TYPE@[18; 21)
+                  PATH@[18; 21)
+                    PATH_SEGMENT@[18; 21)
+                      NAME_REF@[18; 21)
+                        IDENT@[18; 21) "i32"
+              WHITESPACE@[21; 22) " "
+              BLOCK_EXPR@[22; 28)
+                BLOCK@[22; 28)
+                  L_CURLY@[22; 23) "{"
+                  WHITESPACE@[23; 24) " "
+                  LITERAL@[24; 26)
+                    INT_NUMBER@[24; 26) "92"
+                  WHITESPACE@[26; 27) " "
+                  R_CURLY@[27; 28) "}"
+            ARG_LIST@[28; 30)
+              L_PAREN@[28; 29) "("
+              R_PAREN@[29; 30) ")"
+          SEMI@[30; 31) ";"
+        WHITESPACE@[31; 32) " "
+        R_CURLY@[32; 33) "}"
+  WHITESPACE@[33; 34) "\n"