6 files changed, 93 insertions, 89 deletions

diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 64fac13a7..18820786a 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -9,7 +9,7 @@ use std::{
 use arrayvec::ArrayVec;
 
 use crate::{
-    algo::{self, neighbor, SyntaxRewriter},
+    algo::{self, SyntaxRewriter},
     ast::{
         self,
         make::{self, tokens},
@@ -322,28 +322,6 @@ impl ast::Use {
         }
         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 {
@@ -397,22 +375,6 @@ 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
-    }
 }
 
 impl ast::MatchArmList {
@@ -462,8 +424,7 @@ impl ast::MatchArmList {
         let end = if let Some(comma) = start
             .siblings_with_tokens(Direction::Next)
             .skip(1)
-            .skip_while(|it| it.kind().is_trivia())
-            .next()
+            .find(|it| !it.kind().is_trivia())
             .filter(|it| it.kind() == T![,])
         {
             comma
@@ -594,10 +555,17 @@ impl ops::Add<u8> for IndentLevel {
 }
 
 impl IndentLevel {
+    pub fn from_element(element: &SyntaxElement) -> IndentLevel {
+        match element {
+            rowan::NodeOrToken::Node(it) => IndentLevel::from_node(it),
+            rowan::NodeOrToken::Token(it) => IndentLevel::from_token(it),
+        }
+    }
+
     pub fn from_node(node: &SyntaxNode) -> IndentLevel {
         match node.first_token() {
             Some(it) => Self::from_token(&it),
-            None => return IndentLevel(0),
+            None => IndentLevel(0),
         }
     }
 
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index b1eed0a2c..529bd0eb1 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -2,13 +2,13 @@
 
 use std::iter::empty;
 
-use ast::{edit::AstNodeEdit, make, GenericParamsOwner, WhereClause};
 use parser::T;
 
 use crate::{
-    ast,
+    algo::neighbor,
+    ast::{self, edit::AstNodeEdit, make, GenericParamsOwner, WhereClause},
     ted::{self, Position},
-    AstNode, Direction,
+    AstNode, AstToken, Direction,
 };
 
 use super::NameOwner;
@@ -126,3 +126,41 @@ impl ast::TypeBoundList {
         }
     }
 }
+
+impl ast::UseTree {
+    pub fn remove(&self) {
+        for &dir in [Direction::Next, Direction::Prev].iter() {
+            if let Some(next_use_tree) = neighbor(self, dir) {
+                let separators = self
+                    .syntax()
+                    .siblings_with_tokens(dir)
+                    .skip(1)
+                    .take_while(|it| it.as_node() != Some(next_use_tree.syntax()));
+                ted::remove_all_iter(separators);
+                break;
+            }
+        }
+        ted::remove(self.syntax())
+    }
+}
+
+impl ast::Use {
+    pub fn remove(&self) {
+        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 let Some(rest) = ws_text.strip_prefix('\n') {
+                if rest.is_empty() {
+                    ted::remove(next_ws.syntax())
+                } else {
+                    ted::replace(next_ws.syntax(), make::tokens::whitespace(rest))
+                }
+            }
+        }
+        ted::remove(self.syntax())
+    }
+}
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
index 636ce166d..6317d84ba 100644
--- a/crates/syntax/src/ast/expr_ext.rs
+++ b/crates/syntax/src/ast/expr_ext.rs
@@ -11,16 +11,16 @@ impl ast::AttrsOwner for ast::Expr {}
 
 impl ast::Expr {
     pub fn is_block_like(&self) -> bool {
-        match self {
+        matches!(
+            self,
             ast::Expr::IfExpr(_)
-            | ast::Expr::LoopExpr(_)
-            | ast::Expr::ForExpr(_)
-            | ast::Expr::WhileExpr(_)
-            | ast::Expr::BlockExpr(_)
-            | ast::Expr::MatchExpr(_)
-            | ast::Expr::EffectExpr(_) => true,
-            _ => false,
-        }
+                | ast::Expr::LoopExpr(_)
+                | ast::Expr::ForExpr(_)
+                | ast::Expr::WhileExpr(_)
+                | ast::Expr::BlockExpr(_)
+                | ast::Expr::MatchExpr(_)
+                | ast::Expr::EffectExpr(_)
+        )
     }
 
     pub fn name_ref(&self) -> Option<ast::NameRef> {
@@ -151,20 +151,20 @@ pub enum BinOp {
 
 impl BinOp {
     pub fn is_assignment(self) -> bool {
-        match self {
+        matches!(
+            self,
             BinOp::Assignment
-            | BinOp::AddAssign
-            | BinOp::DivAssign
-            | BinOp::MulAssign
-            | BinOp::RemAssign
-            | BinOp::ShrAssign
-            | BinOp::ShlAssign
-            | BinOp::SubAssign
-            | BinOp::BitOrAssign
-            | BinOp::BitAndAssign
-            | BinOp::BitXorAssign => true,
-            _ => false,
-        }
+                | BinOp::AddAssign
+                | BinOp::DivAssign
+                | BinOp::MulAssign
+                | BinOp::RemAssign
+                | BinOp::ShrAssign
+                | BinOp::ShlAssign
+                | BinOp::SubAssign
+                | BinOp::BitOrAssign
+                | BinOp::BitAndAssign
+                | BinOp::BitXorAssign
+        )
     }
 }
 
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 810c8d4c8..c08f2c14f 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -532,7 +532,7 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green().to_owned())
+    SyntaxNode::new_root(n.green())
 }
 
 pub mod tokens {
@@ -560,7 +560,7 @@ pub mod tokens {
     pub fn whitespace(text: &str) -> SyntaxToken {
         assert!(text.trim().is_empty());
         let sf = SourceFile::parse(text).ok().unwrap();
-        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
+        sf.syntax().clone_for_update().first_child_or_token().unwrap().into_token().unwrap()
     }
 
     pub fn doc_comment(text: &str) -> SyntaxToken {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 01f580a40..bdf907a21 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -58,10 +58,7 @@ impl From<ast::MacroDef> for Macro {
 
 impl AstNode for Macro {
     fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF => true,
-            _ => false,
-        }
+        matches!(kind, SyntaxKind::MACRO_RULES | SyntaxKind::MACRO_DEF)
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
         let res = match syntax.kind() {
@@ -380,6 +377,15 @@ impl fmt::Display for NameOrNameRef {
     }
 }
 
+impl NameOrNameRef {
+    pub fn text(&self) -> &str {
+        match self {
+            NameOrNameRef::Name(name) => name.text(),
+            NameOrNameRef::NameRef(name_ref) => name_ref.text(),
+        }
+    }
+}
+
 impl ast::RecordPatField {
     pub fn for_field_name_ref(field_name: &ast::NameRef) -> Option<ast::RecordPatField> {
         let candidate = field_name.syntax().parent().and_then(ast::RecordPatField::cast)?;
@@ -453,10 +459,8 @@ impl ast::FieldExpr {
     pub fn field_access(&self) -> Option<FieldKind> {
         if let Some(nr) = self.name_ref() {
             Some(FieldKind::Name(nr))
-        } else if let Some(tok) = self.index_token() {
-            Some(FieldKind::Index(tok))
         } else {
-            None
+            self.index_token().map(FieldKind::Index)
         }
     }
 }
@@ -473,16 +477,10 @@ impl ast::SlicePat {
         let prefix = args
             .peeking_take_while(|p| match p {
                 ast::Pat::RestPat(_) => false,
-                ast::Pat::IdentPat(bp) => match bp.pat() {
-                    Some(ast::Pat::RestPat(_)) => false,
-                    _ => true,
-                },
+                ast::Pat::IdentPat(bp) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
                 ast::Pat::RefPat(rp) => match rp.pat() {
                     Some(ast::Pat::RestPat(_)) => false,
-                    Some(ast::Pat::IdentPat(bp)) => match bp.pat() {
-                        Some(ast::Pat::RestPat(_)) => false,
-                        _ => true,
-                    },
+                    Some(ast::Pat::IdentPat(bp)) => !matches!(bp.pat(), Some(ast::Pat::RestPat(_))),
                     _ => true,
                 },
                 _ => true,
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 6c242d126..29d25a58a 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -102,8 +102,9 @@ impl CommentKind {
         kind
     }
 
-    fn prefix(&self) -> &'static str {
-        let &(prefix, _) = CommentKind::BY_PREFIX.iter().find(|(_, kind)| kind == self).unwrap();
+    pub fn prefix(&self) -> &'static str {
+        let &(prefix, _) =
+            CommentKind::BY_PREFIX.iter().rev().find(|(_, kind)| kind == self).unwrap();
         prefix
     }
 }
@@ -494,9 +495,8 @@ pub trait HasFormatSpecifier: AstToken {
                 }
                 _ => {
                     while let Some((_, Ok(next_char))) = chars.peek() {
-                        match next_char {
-                            '{' => break,
-                            _ => {}
+                        if next_char == &'{' {
+                            break;
                         }
                         chars.next();
                     }