8 files changed, 39 insertions, 15 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 7846e9798..a74ac42d5 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -157,7 +157,7 @@ impl<'a> QualifyPaths<'a> {
 
 pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
     let syntax = node.syntax();
-    let result = ra_syntax::algo::replace_descendants(syntax, &|element| match element {
+    let result = ra_syntax::algo::replace_descendants(syntax, |element| match element {
         ra_syntax::SyntaxElement::Node(n) => {
             let replacement = transformer.get_substitution(&n)?;
             Some(replacement.into())
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index f57ecd07a..f3167b4e5 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -120,7 +120,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
                         let expr = {
                             let name_ref = make::name_ref("it");
                             let segment = make::path_segment(name_ref);
-                            let path = make::path_unqalified(segment);
+                            let path = make::path_unqualified(segment);
                             make::expr_path(path)
                         };
                         make::match_arm(once(pat.into()), expr)
diff --git a/crates/ra_assists/src/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs
index 616b95770..86b235366 100644
--- a/crates/ra_assists/src/handlers/move_bounds.rs
+++ b/crates/ra_assists/src/handlers/move_bounds.rs
@@ -75,7 +75,7 @@ fn build_predicate(param: ast::TypeParam) -> Option<ast::WherePred> {
     let path = {
         let name_ref = make::name_ref(&param.name()?.syntax().to_string());
         let segment = make::path_segment(name_ref);
-        make::path_unqalified(segment)
+        make::path_unqualified(segment)
     };
     let predicate = make::where_pred(path, param.type_bound_list()?.bounds());
     Some(predicate)
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index f2814e684..5a079de27 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -52,7 +52,7 @@ fn expand_macro_recur(
         }
     }
 
-    Some(replace_descendants(&expanded, &|n| replaces.get(n).cloned()))
+    Some(replace_descendants(&expanded, |n| replaces.get(n).cloned()))
 }
 
 // FIXME: It would also be cool to share logic here and in the mbe tests,
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index ea2cac069..2aaf0215f 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -570,7 +570,7 @@ mod tests {
         let token_tree = insert_children(
             &rbrace.parent().unwrap(),
             InsertPosition::Last,
-            &mut std::iter::once(space),
+            std::iter::once(space),
         );
 
         // Token Tree now is :
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index ebf59288a..b87c7084e 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -144,6 +144,15 @@ pub fn diff(from: &SyntaxNode, to: &SyntaxNode) -> TreeDiff {
 pub fn insert_children(
     parent: &SyntaxNode,
     position: InsertPosition<SyntaxElement>,
+    to_insert: impl IntoIterator<Item = SyntaxElement>,
+) -> SyntaxNode {
+    let mut to_insert = to_insert.into_iter();
+    _insert_children(parent, position, &mut to_insert)
+}
+
+fn _insert_children(
+    parent: &SyntaxNode,
+    position: InsertPosition<SyntaxElement>,
     to_insert: &mut dyn Iterator<Item = SyntaxElement>,
 ) -> SyntaxNode {
     let mut delta = TextUnit::default();
@@ -178,6 +187,15 @@ pub fn insert_children(
 pub fn replace_children(
     parent: &SyntaxNode,
     to_delete: RangeInclusive<SyntaxElement>,
+    to_insert: impl IntoIterator<Item = SyntaxElement>,
+) -> SyntaxNode {
+    let mut to_insert = to_insert.into_iter();
+    _replace_children(parent, to_delete, &mut to_insert)
+}
+
+fn _replace_children(
+    parent: &SyntaxNode,
+    to_delete: RangeInclusive<SyntaxElement>,
     to_insert: &mut dyn Iterator<Item = SyntaxElement>,
 ) -> SyntaxNode {
     let start = position_of_child(parent, to_delete.start().clone());
@@ -202,14 +220,21 @@ pub fn replace_children(
 /// to create a type-safe abstraction on top of it instead.
 pub fn replace_descendants(
     parent: &SyntaxNode,
-    map: &impl Fn(&SyntaxElement) -> Option<SyntaxElement>,
+    map: impl Fn(&SyntaxElement) -> Option<SyntaxElement>,
+) -> SyntaxNode {
+    _replace_descendants(parent, &map)
+}
+
+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);
 
     fn go(
-        map: &impl Fn(&SyntaxElement) -> Option<SyntaxElement>,
+        map: &dyn Fn(&SyntaxElement) -> Option<SyntaxElement>,
         element: SyntaxElement,
     ) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
         if let Some(replacement) = map(&element) {
@@ -221,7 +246,7 @@ pub fn replace_descendants(
         match element {
             NodeOrToken::Token(it) => NodeOrToken::Token(it.green().clone()),
             NodeOrToken::Node(it) => {
-                NodeOrToken::Node(replace_descendants(&it, map).green().clone())
+                NodeOrToken::Node(_replace_descendants(&it, map).green().clone())
             }
         }
     }
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 0e78d8b63..d2630e9e9 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -276,7 +276,7 @@ pub fn replace_descendants<N: AstNode, D: AstNode>(
         .into_iter()
         .map(|(from, to)| (from.syntax().clone().into(), to.syntax().clone().into()))
         .collect::<FxHashMap<SyntaxElement, _>>();
-    let new_syntax = algo::replace_descendants(parent.syntax(), &|n| map.get(n).cloned());
+    let new_syntax = algo::replace_descendants(parent.syntax(), |n| map.get(n).cloned());
     N::cast(new_syntax).unwrap()
 }
 
@@ -331,7 +331,7 @@ impl IndentLevel {
                 )
             })
             .collect();
-        algo::replace_descendants(&node, &|n| replacements.get(n).cloned())
+        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
     }
 
     pub fn decrease_indent<N: AstNode>(self, node: N) -> N {
@@ -359,7 +359,7 @@ impl IndentLevel {
                 )
             })
             .collect();
-        algo::replace_descendants(&node, &|n| replacements.get(n).cloned())
+        algo::replace_descendants(&node, |n| replacements.get(n).cloned())
     }
 }
 
@@ -389,7 +389,7 @@ fn insert_children<N: AstNode>(
     position: InsertPosition<SyntaxElement>,
     to_insert: impl IntoIterator<Item = SyntaxElement>,
 ) -> N {
-    let new_syntax = algo::insert_children(parent.syntax(), position, &mut to_insert.into_iter());
+    let new_syntax = algo::insert_children(parent.syntax(), position, to_insert);
     N::cast(new_syntax).unwrap()
 }
 
@@ -404,8 +404,7 @@ fn replace_children<N: AstNode>(
     to_replace: RangeInclusive<SyntaxElement>,
     to_insert: impl IntoIterator<Item = SyntaxElement>,
 ) -> N {
-    let new_syntax =
-        algo::replace_children(parent.syntax(), to_replace, &mut to_insert.into_iter());
+    let new_syntax = algo::replace_children(parent.syntax(), to_replace, to_insert);
     N::cast(new_syntax).unwrap()
 }
 
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 60cd9d260..3f11b747f 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -15,7 +15,7 @@ pub fn name_ref(text: &str) -> ast::NameRef {
 pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment {
     ast_from_text(&format!("use {};", name_ref.syntax()))
 }
-pub fn path_unqalified(segment: ast::PathSegment) -> ast::Path {
+pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path {
     path_from_text(&format!("use {}", segment.syntax()))
 }
 pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path {