15 files changed, 379 insertions, 339 deletions

diff --git a/crates/ide_assists/src/handlers/add_explicit_type.rs b/crates/ide_assists/src/handlers/add_explicit_type.rs
index 62db31952..36589203d 100644
--- a/crates/ide_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ide_assists/src/handlers/add_explicit_type.rs
@@ -198,6 +198,34 @@ fn main() {
         )
     }
 
+    /// https://github.com/rust-analyzer/rust-analyzer/issues/2922
+    #[test]
+    fn regression_issue_2922() {
+        check_assist(
+            add_explicit_type,
+            r#"
+fn main() {
+    let $0v = [0.0; 2];
+}
+"#,
+            r#"
+fn main() {
+    let v: [f64; 2] = [0.0; 2];
+}
+"#,
+        );
+        // note: this may break later if we add more consteval. it just needs to be something that our
+        // consteval engine doesn't understand
+        check_assist_not_applicable(
+            add_explicit_type,
+            r#"
+fn main() {
+    let $0l = [0.0; 2+2];
+}
+"#,
+        );
+    }
+
     #[test]
     fn default_generics_should_not_be_added() {
         check_assist(
diff --git a/crates/ide_assists/src/handlers/auto_import.rs b/crates/ide_assists/src/handlers/auto_import.rs
index 506cc292c..dda5a6631 100644
--- a/crates/ide_assists/src/handlers/auto_import.rs
+++ b/crates/ide_assists/src/handlers/auto_import.rs
@@ -102,8 +102,8 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
             range,
             |builder| {
                 let scope = match scope.clone() {
-                    ImportScope::File(it) => ImportScope::File(builder.make_ast_mut(it)),
-                    ImportScope::Module(it) => ImportScope::Module(builder.make_ast_mut(it)),
+                    ImportScope::File(it) => ImportScope::File(builder.make_mut(it)),
+                    ImportScope::Module(it) => ImportScope::Module(builder.make_mut(it)),
                 };
                 insert_use(&scope, mod_path_to_ast(&import.import_path), ctx.config.insert_use);
             },
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index da8d245e5..79cb08d69 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -61,7 +61,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
         "Expand glob import",
         target.text_range(),
         |builder| {
-            let use_tree = builder.make_ast_mut(use_tree);
+            let use_tree = builder.make_mut(use_tree);
 
             let names_to_import = find_names_to_import(ctx, refs_in_target, imported_defs);
             let expanded = make::use_tree_list(names_to_import.iter().map(|n| {
diff --git a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
index 8e2178391..007aba23d 100644
--- a/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -70,7 +70,7 @@ pub(crate) fn extract_struct_from_enum_variant(
                     continue;
                 }
                 builder.edit_file(file_id);
-                let source_file = builder.make_ast_mut(ctx.sema.parse(file_id));
+                let source_file = builder.make_mut(ctx.sema.parse(file_id));
                 let processed = process_references(
                     ctx,
                     &mut visited_modules_set,
@@ -84,8 +84,8 @@ pub(crate) fn extract_struct_from_enum_variant(
                 });
             }
             builder.edit_file(ctx.frange.file_id);
-            let source_file = builder.make_ast_mut(ctx.sema.parse(ctx.frange.file_id));
-            let variant = builder.make_ast_mut(variant.clone());
+            let source_file = builder.make_mut(ctx.sema.parse(ctx.frange.file_id));
+            let variant = builder.make_mut(variant.clone());
             if let Some(references) = def_file_references {
                 let processed = process_references(
                     ctx,
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index be927cc1c..58b001050 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -71,6 +71,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
             .filter_map(|variant| build_pat(ctx.db(), module, variant))
             .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
+            .map(|it| it.clone_for_update())
             .collect::<Vec<_>>();
         if Some(enum_def)
             == FamousDefs(&ctx.sema, Some(module.krate()))
@@ -99,6 +100,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
             })
             .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
+            .map(|it| it.clone_for_update())
             .collect()
     } else {
         return None;
@@ -114,10 +116,20 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
         "Fill match arms",
         target,
         |builder| {
-            let new_arm_list = match_arm_list.remove_placeholder();
-            let n_old_arms = new_arm_list.arms().count();
-            let new_arm_list = new_arm_list.append_arms(missing_arms);
-            let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+            let new_match_arm_list = match_arm_list.clone_for_update();
+
+            let catch_all_arm = new_match_arm_list
+                .arms()
+                .find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))));
+            if let Some(arm) = catch_all_arm {
+                arm.remove()
+            }
+            let mut first_new_arm = None;
+            for arm in missing_arms {
+                first_new_arm.get_or_insert_with(|| arm.clone());
+                new_match_arm_list.add_arm(arm);
+            }
+
             let old_range = ctx.sema.original_range(match_arm_list.syntax()).range;
             match (first_new_arm, ctx.config.snippet_cap) {
                 (Some(first_new_arm), Some(cap)) => {
@@ -131,10 +143,10 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
                             }
                             None => Cursor::Before(first_new_arm.syntax()),
                         };
-                    let snippet = render_snippet(cap, new_arm_list.syntax(), cursor);
+                    let snippet = render_snippet(cap, new_match_arm_list.syntax(), cursor);
                     builder.replace_snippet(cap, old_range, snippet);
                 }
-                _ => builder.replace(old_range, new_arm_list.to_string()),
+                _ => builder.replace(old_range, new_match_arm_list.to_string()),
             }
         },
     )
@@ -263,18 +275,18 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs{x:i32, y:Option<i32>},
-                Cs(i32, Option<i32>),
-            }
-            fn main() {
-                match A::As$0 {
-                    A::As,
-                    A::Bs{x,y:Some(_)} => {}
-                    A::Cs(_, Some(_)) => {}
-                }
-            }
+enum A {
+    As,
+    Bs{x:i32, y:Option<i32>},
+    Cs(i32, Option<i32>),
+}
+fn main() {
+    match A::As$0 {
+        A::As,
+        A::Bs{x,y:Some(_)} => {}
+        A::Cs(_, Some(_)) => {}
+    }
+}
             "#,
         );
     }
@@ -284,13 +296,13 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match a$0 {
-                    true => {}
-                    false => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match a$0 {
+        true => {}
+        false => {}
+    }
+}
+"#,
         )
     }
 
@@ -301,11 +313,11 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            fn main() {
-                match (0, false)$0 {
-                }
-            }
-            "#,
+fn main() {
+    match (0, false)$0 {
+    }
+}
+"#,
         );
     }
 
@@ -314,19 +326,19 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match a$0 {
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match a$0 {
+    }
+}
+"#,
             r#"
-            fn foo(a: bool) {
-                match a {
-                    $0true => {}
-                    false => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match a {
+        $0true => {}
+        false => {}
+    }
+}
+"#,
         )
     }
 
@@ -335,20 +347,20 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match a$0 {
-                    true => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match a$0 {
+        true => {}
+    }
+}
+"#,
             r#"
-            fn foo(a: bool) {
-                match a {
-                    true => {}
-                    $0false => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match a {
+        true => {}
+        $0false => {}
+    }
+}
+"#,
         )
     }
 
@@ -357,15 +369,15 @@ mod tests {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match (a, a)$0 {
-                    (true, true) => {}
-                    (true, false) => {}
-                    (false, true) => {}
-                    (false, false) => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match (a, a)$0 {
+        (true, true) => {}
+        (true, false) => {}
+        (false, true) => {}
+        (false, false) => {}
+    }
+}
+"#,
         )
     }
 
@@ -374,21 +386,21 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match (a, a)$0 {
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match (a, a)$0 {
+    }
+}
+"#,
             r#"
-            fn foo(a: bool) {
-                match (a, a) {
-                    $0(true, true) => {}
-                    (true, false) => {}
-                    (false, true) => {}
-                    (false, false) => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match (a, a) {
+        $0(true, true) => {}
+        (true, false) => {}
+        (false, true) => {}
+        (false, false) => {}
+    }
+}
+"#,
         )
     }
 
@@ -397,22 +409,22 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            fn foo(a: bool) {
-                match (a, a)$0 {
-                    (false, true) => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match (a, a)$0 {
+        (false, true) => {}
+    }
+}
+"#,
             r#"
-            fn foo(a: bool) {
-                match (a, a) {
-                    (false, true) => {}
-                    $0(true, true) => {}
-                    (true, false) => {}
-                    (false, false) => {}
-                }
-            }
-            "#,
+fn foo(a: bool) {
+    match (a, a) {
+        (false, true) => {}
+        $0(true, true) => {}
+        (true, false) => {}
+        (false, false) => {}
+    }
+}
+"#,
         )
     }
 
@@ -421,32 +433,32 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs { x: i32, y: Option<i32> },
-                Cs(i32, Option<i32>),
-            }
-            fn main() {
-                match A::As$0 {
-                    A::Bs { x, y: Some(_) } => {}
-                    A::Cs(_, Some(_)) => {}
-                }
-            }
-            "#,
+enum A {
+    As,
+    Bs { x: i32, y: Option<i32> },
+    Cs(i32, Option<i32>),
+}
+fn main() {
+    match A::As$0 {
+        A::Bs { x, y: Some(_) } => {}
+        A::Cs(_, Some(_)) => {}
+    }
+}
+"#,
             r#"
-            enum A {
-                As,
-                Bs { x: i32, y: Option<i32> },
-                Cs(i32, Option<i32>),
-            }
-            fn main() {
-                match A::As {
-                    A::Bs { x, y: Some(_) } => {}
-                    A::Cs(_, Some(_)) => {}
-                    $0A::As => {}
-                }
-            }
-            "#,
+enum A {
+    As,
+    Bs { x: i32, y: Option<i32> },
+    Cs(i32, Option<i32>),
+}
+fn main() {
+    match A::As {
+        A::Bs { x, y: Some(_) } => {}
+        A::Cs(_, Some(_)) => {}
+        $0A::As => {}
+    }
+}
+"#,
         );
     }
 
@@ -593,30 +605,30 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
+enum A { One, Two }
+enum B { One, Two }
 
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (a$0, b) {}
-            }
-            "#,
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a$0, b) {}
+}
+"#,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
-
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (a, b) {
-                    $0(A::One, B::One) => {}
-                    (A::One, B::Two) => {}
-                    (A::Two, B::One) => {}
-                    (A::Two, B::Two) => {}
-                }
-            }
-            "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        $0(A::One, B::One) => {}
+        (A::One, B::Two) => {}
+        (A::Two, B::One) => {}
+        (A::Two, B::Two) => {}
+    }
+}
+"#,
         );
     }
 
@@ -625,30 +637,30 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
+enum A { One, Two }
+enum B { One, Two }
 
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (&a$0, &b) {}
-            }
-            "#,
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (&a$0, &b) {}
+}
+"#,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
-
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (&a, &b) {
-                    $0(A::One, B::One) => {}
-                    (A::One, B::Two) => {}
-                    (A::Two, B::One) => {}
-                    (A::Two, B::Two) => {}
-                }
-            }
-            "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (&a, &b) {
+        $0(A::One, B::One) => {}
+        (A::One, B::Two) => {}
+        (A::Two, B::One) => {}
+        (A::Two, B::Two) => {}
+    }
+}
+"#,
         );
     }
 
@@ -737,20 +749,20 @@ fn main() {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
-
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (a$0, b) {
-                    (A::Two, B::One) => {}
-                    (A::One, B::One) => {}
-                    (A::One, B::Two) => {}
-                    (A::Two, B::Two) => {}
-                }
-            }
-            "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a$0, b) {
+        (A::Two, B::One) => {}
+        (A::One, B::One) => {}
+        (A::One, B::Two) => {}
+        (A::Two, B::Two) => {}
+    }
+}
+"#,
         );
     }
 
@@ -759,25 +771,25 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
+enum A { One, Two }
 
-            fn main() {
-                let a = A::One;
-                match (a$0, ) {
-                }
-            }
-            "#,
+fn main() {
+    let a = A::One;
+    match (a$0, ) {
+    }
+}
+"#,
             r#"
-            enum A { One, Two }
+enum A { One, Two }
 
-            fn main() {
-                let a = A::One;
-                match (a, ) {
-                    $0(A::One,) => {}
-                    (A::Two,) => {}
-                }
-            }
-            "#,
+fn main() {
+    let a = A::One;
+    match (a, ) {
+        $0(A::One,) => {}
+        (A::Two,) => {}
+    }
+}
+"#,
         );
     }
 
@@ -786,47 +798,47 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { As }
+enum A { As }
 
-            fn foo(a: &A) {
-                match a$0 {
-                }
-            }
-            "#,
+fn foo(a: &A) {
+    match a$0 {
+    }
+}
+"#,
             r#"
-            enum A { As }
+enum A { As }
 
-            fn foo(a: &A) {
-                match a {
-                    $0A::As => {}
-                }
-            }
-            "#,
+fn foo(a: &A) {
+    match a {
+        $0A::As => {}
+    }
+}
+"#,
         );
 
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                Es { x: usize, y: usize }
-            }
+enum A {
+    Es { x: usize, y: usize }
+}
 
-            fn foo(a: &mut A) {
-                match a$0 {
-                }
-            }
-            "#,
+fn foo(a: &mut A) {
+    match a$0 {
+    }
+}
+"#,
             r#"
-            enum A {
-                Es { x: usize, y: usize }
-            }
+enum A {
+    Es { x: usize, y: usize }
+}
 
-            fn foo(a: &mut A) {
-                match a {
-                    $0A::Es { x, y } => {}
-                }
-            }
-            "#,
+fn foo(a: &mut A) {
+    match a {
+        $0A::Es { x, y } => {}
+    }
+}
+"#,
         );
     }
 
@@ -835,12 +847,12 @@ fn main() {
         check_assist_target(
             fill_match_arms,
             r#"
-            enum E { X, Y }
+enum E { X, Y }
 
-            fn main() {
-                match E::X$0 {}
-            }
-            "#,
+fn main() {
+    match E::X$0 {}
+}
+"#,
             "match E::X {}",
         );
     }
@@ -850,24 +862,24 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum E { X, Y }
+enum E { X, Y }
 
-            fn main() {
-                match E::X {
-                    $0_ => {}
-                }
-            }
-            "#,
+fn main() {
+    match E::X {
+        $0_ => {}
+    }
+}
+"#,
             r#"
-            enum E { X, Y }
+enum E { X, Y }
 
-            fn main() {
-                match E::X {
-                    $0E::X => {}
-                    E::Y => {}
-                }
-            }
-            "#,
+fn main() {
+    match E::X {
+        $0E::X => {}
+        E::Y => {}
+    }
+}
+"#,
         );
     }
 
@@ -876,26 +888,26 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            mod foo { pub enum E { X, Y } }
-            use foo::E::X;
+mod foo { pub enum E { X, Y } }
+use foo::E::X;
 
-            fn main() {
-                match X {
-                    $0
-                }
-            }
-            "#,
+fn main() {
+    match X {
+        $0
+    }
+}
+"#,
             r#"
-            mod foo { pub enum E { X, Y } }
-            use foo::E::X;
+mod foo { pub enum E { X, Y } }
+use foo::E::X;
 
-            fn main() {
-                match X {
-                    $0X => {}
-                    foo::E::Y => {}
-                }
-            }
-            "#,
+fn main() {
+    match X {
+        $0X => {}
+        foo::E::Y => {}
+    }
+}
+"#,
         );
     }
 
@@ -904,26 +916,26 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            fn foo(a: A) {
-                match a {
-                    // foo bar baz$0
-                    A::One => {}
-                    // This is where the rest should be
-                }
-            }
-            "#,
+enum A { One, Two }
+fn foo(a: A) {
+    match a {
+        // foo bar baz$0
+        A::One => {}
+        // This is where the rest should be
+    }
+}
+"#,
             r#"
-            enum A { One, Two }
-            fn foo(a: A) {
-                match a {
-                    // foo bar baz
-                    A::One => {}
-                    // This is where the rest should be
-                    $0A::Two => {}
-                }
-            }
-            "#,
+enum A { One, Two }
+fn foo(a: A) {
+    match a {
+        // foo bar baz
+        A::One => {}
+        $0A::Two => {}
+        // This is where the rest should be
+    }
+}
+"#,
         );
     }
 
@@ -932,23 +944,23 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            fn foo(a: A) {
-                match a {
-                    // foo bar baz$0
-                }
-            }
-            "#,
+enum A { One, Two }
+fn foo(a: A) {
+    match a {
+        // foo bar baz$0
+    }
+}
+"#,
             r#"
-            enum A { One, Two }
-            fn foo(a: A) {
-                match a {
-                    // foo bar baz
-                    $0A::One => {}
-                    A::Two => {}
-                }
-            }
-            "#,
+enum A { One, Two }
+fn foo(a: A) {
+    match a {
+        $0A::One => {}
+        A::Two => {}
+        // foo bar baz
+    }
+}
+"#,
         );
     }
 
@@ -957,22 +969,22 @@ fn main() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two, }
-            fn foo(a: A) {
-                match a$0 {
-                    _ => (),
-                }
-            }
-            "#,
+enum A { One, Two, }
+fn foo(a: A) {
+    match a$0 {
+        _ => (),
+    }
+}
+"#,
             r#"
-            enum A { One, Two, }
-            fn foo(a: A) {
-                match a {
-                    $0A::One => {}
-                    A::Two => {}
-                }
-            }
-            "#,
+enum A { One, Two, }
+fn foo(a: A) {
+    match a {
+        $0A::One => {}
+        A::Two => {}
+    }
+}
+"#,
         );
     }
 
@@ -1016,7 +1028,8 @@ enum Test {
 fn foo(t: Test) {
     m!(match t$0 {});
 }"#,
-            r#"macro_rules! m { ($expr:expr) => {$expr}}
+            r#"
+macro_rules! m { ($expr:expr) => {$expr}}
 enum Test {
     A,
     B,
diff --git a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
index 68bc15120..16f8f9d70 100644
--- a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
@@ -84,8 +84,8 @@ fn generate_fn_def_assist(
         }
     };
     acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        let fn_def = builder.make_ast_mut(fn_def);
-        let lifetime = builder.make_ast_mut(lifetime);
+        let fn_def = builder.make_mut(fn_def);
+        let lifetime = builder.make_mut(lifetime);
         let loc_needing_lifetime =
             loc_needing_lifetime.and_then(|it| it.make_mut(builder).to_position());
 
@@ -107,8 +107,8 @@ fn generate_impl_def_assist(
 ) -> Option<()> {
     let new_lifetime_param = generate_unique_lifetime_param_name(impl_def.generic_param_list())?;
     acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        let impl_def = builder.make_ast_mut(impl_def);
-        let lifetime = builder.make_ast_mut(lifetime);
+        let impl_def = builder.make_mut(impl_def);
+        let lifetime = builder.make_mut(lifetime);
 
         impl_def.get_or_create_generic_param_list().add_generic_param(
             make::lifetime_param(new_lifetime_param.clone()).clone_for_update().into(),
@@ -141,8 +141,8 @@ enum NeedsLifetime {
 impl NeedsLifetime {
     fn make_mut(self, builder: &mut AssistBuilder) -> Self {
         match self {
-            Self::SelfParam(it) => Self::SelfParam(builder.make_ast_mut(it)),
-            Self::RefType(it) => Self::RefType(builder.make_ast_mut(it)),
+            Self::SelfParam(it) => Self::SelfParam(builder.make_mut(it)),
+            Self::RefType(it) => Self::RefType(builder.make_mut(it)),
         }
     }
 
diff --git a/crates/ide_assists/src/handlers/merge_imports.rs b/crates/ide_assists/src/handlers/merge_imports.rs
index 3cd090737..31854840c 100644
--- a/crates/ide_assists/src/handlers/merge_imports.rs
+++ b/crates/ide_assists/src/handlers/merge_imports.rs
@@ -47,16 +47,16 @@ pub(crate) fn merge_imports(acc: &mut Assists, ctx: &AssistContext) -> Option<()
         target,
         |builder| {
             if let Some((to_replace, replacement, to_remove)) = imports {
-                let to_replace = builder.make_ast_mut(to_replace);
-                let to_remove = builder.make_ast_mut(to_remove);
+                let to_replace = builder.make_mut(to_replace);
+                let to_remove = builder.make_mut(to_remove);
 
                 ted::replace(to_replace.syntax(), replacement.syntax());
                 to_remove.remove();
             }
 
             if let Some((to_replace, replacement, to_remove)) = uses {
-                let to_replace = builder.make_ast_mut(to_replace);
-                let to_remove = builder.make_ast_mut(to_remove);
+                let to_replace = builder.make_mut(to_replace);
+                let to_remove = builder.make_mut(to_remove);
 
                 ted::replace(to_replace.syntax(), replacement.syntax());
                 to_remove.remove()
diff --git a/crates/ide_assists/src/handlers/move_bounds.rs b/crates/ide_assists/src/handlers/move_bounds.rs
index fa3f76609..d89d11bdf 100644
--- a/crates/ide_assists/src/handlers/move_bounds.rs
+++ b/crates/ide_assists/src/handlers/move_bounds.rs
@@ -36,8 +36,8 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
         "Move to where clause",
         target,
         |edit| {
-            let type_param_list = edit.make_ast_mut(type_param_list);
-            let parent = edit.make_mut(parent);
+            let type_param_list = edit.make_mut(type_param_list);
+            let parent = edit.make_syntax_mut(parent);
 
             let where_clause: ast::WhereClause = match_ast! {
                 match parent {
diff --git a/crates/ide_assists/src/handlers/pull_assignment_up.rs b/crates/ide_assists/src/handlers/pull_assignment_up.rs
index 3128faa68..f07b8a6c0 100644
--- a/crates/ide_assists/src/handlers/pull_assignment_up.rs
+++ b/crates/ide_assists/src/handlers/pull_assignment_up.rs
@@ -74,10 +74,10 @@ pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext) -> Opti
             let assignments: Vec<_> = collector
                 .assignments
                 .into_iter()
-                .map(|(stmt, rhs)| (edit.make_ast_mut(stmt), rhs.clone_for_update()))
+                .map(|(stmt, rhs)| (edit.make_mut(stmt), rhs.clone_for_update()))
                 .collect();
 
-            let tgt = edit.make_ast_mut(tgt);
+            let tgt = edit.make_mut(tgt);
 
             for (stmt, rhs) in assignments {
                 let mut stmt = stmt.syntax().clone();
diff --git a/crates/ide_assists/src/handlers/raw_string.rs b/crates/ide_assists/src/handlers/raw_string.rs
index d0f1613f3..d98a55ae4 100644
--- a/crates/ide_assists/src/handlers/raw_string.rs
+++ b/crates/ide_assists/src/handlers/raw_string.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use syntax::{ast, AstToken, TextRange, TextSize};
+use syntax::{ast, ast::IsString, AstToken, TextRange, TextSize};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
diff --git a/crates/ide_assists/src/handlers/reorder_fields.rs b/crates/ide_assists/src/handlers/reorder_fields.rs
index e90bbdbcf..933acead1 100644
--- a/crates/ide_assists/src/handlers/reorder_fields.rs
+++ b/crates/ide_assists/src/handlers/reorder_fields.rs
@@ -70,10 +70,10 @@ pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext) -> Option<(
         target,
         |builder| match fields {
             Either::Left((sorted, field_list)) => {
-                replace(builder.make_ast_mut(field_list).fields(), sorted)
+                replace(builder.make_mut(field_list).fields(), sorted)
             }
             Either::Right((sorted, field_list)) => {
-                replace(builder.make_ast_mut(field_list).fields(), sorted)
+                replace(builder.make_mut(field_list).fields(), sorted)
             }
         },
     )
diff --git a/crates/ide_assists/src/handlers/reorder_impl.rs b/crates/ide_assists/src/handlers/reorder_impl.rs
index 54a9a468e..5a6a9f158 100644
--- a/crates/ide_assists/src/handlers/reorder_impl.rs
+++ b/crates/ide_assists/src/handlers/reorder_impl.rs
@@ -79,8 +79,7 @@ pub(crate) fn reorder_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
         "Sort methods",
         target,
         |builder| {
-            let methods =
-                methods.into_iter().map(|fn_| builder.make_ast_mut(fn_)).collect::<Vec<_>>();
+            let methods = methods.into_iter().map(|fn_| builder.make_mut(fn_)).collect::<Vec<_>>();
             methods
                 .into_iter()
                 .zip(sorted)
diff --git a/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs b/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
index 15420aedf..540a905cc 100644
--- a/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
+++ b/crates/ide_assists/src/handlers/replace_impl_trait_with_generic.rs
@@ -32,8 +32,8 @@ pub(crate) fn replace_impl_trait_with_generic(
         "Replace impl trait with generic",
         target,
         |edit| {
-            let impl_trait_type = edit.make_ast_mut(impl_trait_type);
-            let fn_ = edit.make_ast_mut(fn_);
+            let impl_trait_type = edit.make_mut(impl_trait_type);
+            let fn_ = edit.make_mut(fn_);
 
             let type_param_name = suggest_name::for_generic_parameter(&impl_trait_type);
 
diff --git a/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
index 99ba79860..39f5eb4ff 100644
--- a/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ide_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -40,7 +40,7 @@ pub(crate) fn replace_qualified_name_with_use(
         |builder| {
             // Now that we've brought the name into scope, re-qualify all paths that could be
             // affected (that is, all paths inside the node we added the `use` to).
-            let syntax = builder.make_mut(syntax.clone());
+            let syntax = builder.make_syntax_mut(syntax.clone());
             if let Some(ref import_scope) = ImportScope::from(syntax.clone()) {
                 shorten_paths(&syntax, &path.clone_for_update());
                 insert_use(import_scope, path, ctx.config.insert_use);
diff --git a/crates/ide_assists/src/handlers/replace_string_with_char.rs b/crates/ide_assists/src/handlers/replace_string_with_char.rs
index 634b9c0b7..0800d291e 100644
--- a/crates/ide_assists/src/handlers/replace_string_with_char.rs
+++ b/crates/ide_assists/src/handlers/replace_string_with_char.rs
@@ -1,4 +1,4 @@
-use syntax::{ast, AstToken, SyntaxKind::STRING};
+use syntax::{ast, ast::IsString, AstToken, SyntaxKind::STRING};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};