45 files changed, 945 insertions, 734 deletions
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 6233bca83..d443b124c 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -52,7 +52,9 @@ use hir_def::{
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind};
 use hir_ty::{
-    autoderef, could_unify,
+    autoderef,
+    consteval::ConstExt,
+    could_unify,
    method_resolution::{self, def_crates, TyFingerprint},
    primitive::UintTy,
    subst_prefix,
@@ -1914,6 +1916,7 @@ impl Type {
                    substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
                }
+                TyKind::Array(_ty, len) if len.is_unknown() => true,
                TyKind::Array(ty, _)
                | TyKind::Slice(ty)
                | TyKind::Raw(_, ty)
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 9f278d35b..2a7e0205f 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1006,23 +1006,27 @@ impl From<ast::BinOp> for BinaryOp {
 impl From<ast::LiteralKind> for Literal {
    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
        match ast_lit_kind {
+            // FIXME: these should have actual values filled in, but unsure on perf impact
            LiteralKind::IntNumber(lit) => {
                if let builtin @ Some(_) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
                    return Literal::Float(Default::default(), builtin);
                } else if let builtin @ Some(_) =
                    lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it))
                {
-                    Literal::Int(Default::default(), builtin)
+                    Literal::Int(lit.value().unwrap_or(0) as i128, builtin)
                } else {
                    let builtin = lit.suffix().and_then(|it| BuiltinUint::from_suffix(&it));
-                    Literal::Uint(Default::default(), builtin)
+                    Literal::Uint(lit.value().unwrap_or(0), builtin)
                }
            }
            LiteralKind::FloatNumber(lit) => {
                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it));
                Literal::Float(Default::default(), ty)
            }
-            LiteralKind::ByteString(_) => Literal::ByteString(Default::default()),
+            LiteralKind::ByteString(bs) => {
+                let text = bs.value().map(Vec::from).unwrap_or_else(Default::default);
+                Literal::ByteString(text)
+            }
            LiteralKind::String(_) => Literal::String(Default::default()),
            LiteralKind::Byte => Literal::Uint(Default::default(), Some(BuiltinUint::U8)),
            LiteralKind::Bool(val) => Literal::Bool(val),
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 0c3b41080..2ba619d23 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -43,8 +43,8 @@ pub enum Literal {
    ByteString(Vec<u8>),
    Char(char),
    Bool(bool),
-    Int(u64, Option<BuiltinInt>),
+    Int(i128, Option<BuiltinInt>),
-    Uint(u64, Option<BuiltinUint>),
+    Uint(u128, Option<BuiltinUint>),
    Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq
 }
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index ea29da5da..9e44547cb 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -2,6 +2,7 @@
 //! be directly created from an ast::TypeRef, without further queries.
 use hir_expand::{name::Name, AstId, InFile};
+use std::convert::TryInto;
 use syntax::ast;
 use crate::{body::LowerCtx, path::Path};
@@ -79,7 +80,9 @@ pub enum TypeRef {
    Path(Path),
    RawPtr(Box<TypeRef>, Mutability),
    Reference(Box<TypeRef>, Option<LifetimeRef>, Mutability),
-    Array(Box<TypeRef> /*, Expr*/),
+    // FIXME: for full const generics, the latter element (length) here is going to have to be an
+    // expression that is further lowered later in hir_ty.
+    Array(Box<TypeRef>, ConstScalar),
    Slice(Box<TypeRef>),
    /// A fn pointer. Last element of the vector is the return type.
    Fn(Vec<TypeRef>, bool /*varargs*/),
@@ -140,7 +143,16 @@ impl TypeRef {
                TypeRef::RawPtr(Box::new(inner_ty), mutability)
            }
            ast::Type::ArrayType(inner) => {
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
+                // FIXME: This is a hack. We should probably reuse the machinery of
+                // `hir_def::body::lower` to lower this into an `Expr` and then evaluate it at the
+                // `hir_ty` level, which would allow knowing the type of:
+                // let v: [u8; 2 + 2] = [0u8; 4];
+                let len = inner
+                    .expr()
+                    .map(ConstScalar::usize_from_literal_expr)
+                    .unwrap_or(ConstScalar::Unknown);
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())), len)
            }
            ast::Type::SliceType(inner) => {
                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
@@ -212,7 +224,7 @@ impl TypeRef {
                }
                TypeRef::RawPtr(type_ref, _)
                | TypeRef::Reference(type_ref, ..)
-                | TypeRef::Array(type_ref)
+                | TypeRef::Array(type_ref, _)
                | TypeRef::Slice(type_ref) => go(&type_ref, f),
                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
                    for bound in bounds {
@@ -298,3 +310,58 @@ impl TypeBound {
        }
    }
 }
+/// A concrete constant value
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ConstScalar {
+    // for now, we only support the trivial case of constant evaluating the length of an array
+    // Note that this is u64 because the target usize may be bigger than our usize
+    Usize(u64),
+    /// Case of an unknown value that rustc might know but we don't
+    // FIXME: this is a hack to get around chalk not being able to represent unevaluatable
+    // constants
+    // https://github.com/rust-analyzer/rust-analyzer/pull/8813#issuecomment-840679177
+    // https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/Handling.20non.20evaluatable.20constants'.20equality/near/238386348
+    Unknown,
+}
+impl std::fmt::Display for ConstScalar {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        match self {
+            ConstScalar::Usize(us) => write!(fmt, "{}", us),
+            ConstScalar::Unknown => write!(fmt, "_"),
+        }
+    }
+}
+impl ConstScalar {
+    /// Gets a target usize out of the ConstScalar
+    pub fn as_usize(&self) -> Option<u64> {
+        match self {
+            &ConstScalar::Usize(us) => Some(us),
+            _ => None,
+        }
+    }
+    // FIXME: as per the comments on `TypeRef::Array`, this evaluation should not happen at this
+    // parse stage.
+    fn usize_from_literal_expr(expr: ast::Expr) -> ConstScalar {
+        match expr {
+            ast::Expr::Literal(lit) => {
+                let lkind = lit.kind();
+                match lkind {
+                    ast::LiteralKind::IntNumber(num)
+                        if num.suffix() == None || num.suffix() == Some("usize") =>
+                    {
+                        num.value().and_then(|v| v.try_into().ok())
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+        .map(ConstScalar::Usize)
+        .unwrap_or(ConstScalar::Unknown)
+    }
+}
diff --git a/crates/hir_ty/src/consteval.rs b/crates/hir_ty/src/consteval.rs
new file mode 100644
index 000000000..e3ceb3d62
--- /dev/null
+++ b/crates/hir_ty/src/consteval.rs
@@ -0,0 +1,56 @@
+//! Constant evaluation details
+use std::convert::TryInto;
+use hir_def::{
+    builtin_type::BuiltinUint,
+    expr::{Expr, Literal},
+    type_ref::ConstScalar,
+};
+use crate::{Const, ConstData, ConstValue, Interner, TyKind};
+/// Extension trait for [`Const`]
+pub trait ConstExt {
+    /// Is a [`Const`] unknown?
+    fn is_unknown(&self) -> bool;
+}
+impl ConstExt for Const {
+    fn is_unknown(&self) -> bool {
+        match self.data(&Interner).value {
+            // interned Unknown
+            chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
+                interned: ConstScalar::Unknown,
+            }) => true,
+            // interned concrete anything else
+            chalk_ir::ConstValue::Concrete(..) => false,
+            _ => {
+                log::error!("is_unknown was called on a non-concrete constant value! {:?}", self);
+                true
+            }
+        }
+    }
+}
+// FIXME: support more than just evaluating literals
+pub fn eval_usize(expr: &Expr) -> Option<u64> {
+    match expr {
+        Expr::Literal(Literal::Uint(v, None))
+        | Expr::Literal(Literal::Uint(v, Some(BuiltinUint::Usize))) => (*v).try_into().ok(),
+        _ => None,
+    }
+}
+/// Interns a possibly-unknown target usize
+pub fn usize_const(value: Option<u64>) -> Const {
+    ConstData {
+        ty: TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(&Interner),
+        value: ConstValue::Concrete(chalk_ir::ConcreteConst {
+            interned: value.map(|value| ConstScalar::Usize(value)).unwrap_or(ConstScalar::Unknown),
+        }),
+    }
+    .intern(&Interner)
+}
diff --git a/crates/hir_ty/src/consts.rs b/crates/hir_ty/src/consts.rs
deleted file mode 100644
index 0044b1cff..000000000
--- a/crates/hir_ty/src/consts.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! Handling of concrete const values
-/// A concrete constant value
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ConstScalar {
-    // for now, we only support the trivial case of constant evaluating the length of an array
-    // Note that this is u64 because the target usize may be bigger than our usize
-    Usize(u64),
-    /// Case of an unknown value that rustc might know but we don't
-    Unknown,
-}
-impl std::fmt::Display for ConstScalar {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            ConstScalar::Usize(us) => write!(fmt, "{}", us),
-            ConstScalar::Unknown => write!(fmt, "_"),
-        }
-    }
-}
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 8a4296697..7bbd1a1f7 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -962,11 +962,10 @@ impl HirDisplay for TypeRef {
                write!(f, "{}", mutability)?;
                inner.hir_fmt(f)?;
            }
-            TypeRef::Array(inner) => {
+            TypeRef::Array(inner, len) => {
                write!(f, "[")?;
                inner.hir_fmt(f)?;
-                // FIXME: Array length?
+                write!(f, "; {}]", len)?;
-                write!(f, "; _]")?;
            }
            TypeRef::Slice(inner) => {
                write!(f, "[")?;
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 2178ffd07..b6b5a1b75 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -3,7 +3,7 @@
 use std::iter::{repeat, repeat_with};
 use std::{mem, sync::Arc};
-use chalk_ir::{cast::Cast, fold::Shift, ConstData, Mutability, TyVariableKind};
+use chalk_ir::{cast::Cast, fold::Shift, Mutability, TyVariableKind};
 use hir_def::{
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
@@ -15,9 +15,7 @@ use stdx::always;
 use syntax::ast::RangeOp;
 use crate::{
-    autoderef,
+    autoderef, consteval,
-    consts::ConstScalar,
-    dummy_usize_const,
    lower::lower_to_chalk_mutability,
    mapping::from_chalk,
    method_resolution, op,
@@ -25,7 +23,7 @@ use crate::{
    static_lifetime, to_chalk_trait_id,
    traits::FnTrait,
    utils::{generics, Generics},
-    AdtId, Binders, CallableDefId, ConstValue, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
+    AdtId, Binders, CallableDefId, FnPointer, FnSig, FnSubst, InEnvironment, Interner,
    ProjectionTyExt, Rawness, Scalar, Substitution, TraitRef, Ty, TyBuilder, TyExt, TyKind,
 };
@@ -724,7 +722,7 @@ impl<'a> InferenceContext<'a> {
                        for expr in items.iter() {
                            self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
                        }
-                        Some(items.len())
+                        Some(items.len() as u64)
                    }
                    Array::Repeat { initializer, repeat } => {
                        self.infer_expr_coerce(
@@ -737,20 +735,13 @@ impl<'a> InferenceContext<'a> {
                                TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner),
                            ),
                        );
-                        // FIXME: support length for Repeat array expressions
-                        None
+                        let repeat_expr = &self.body.exprs[*repeat];
+                        consteval::eval_usize(repeat_expr)
                    }
                };
-                let cd = ConstData {
+                TyKind::Array(elem_ty, consteval::usize_const(len)).intern(&Interner)
-                    ty: TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner),
-                    value: ConstValue::Concrete(chalk_ir::ConcreteConst {
-                        interned: len
-                            .map(|len| ConstScalar::Usize(len as u64))
-                            .unwrap_or(ConstScalar::Unknown),
-                    }),
-                };
-                TyKind::Array(elem_ty, cd.intern(&Interner)).intern(&Interner)
            }
            Expr::Literal(lit) => match lit {
                Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
@@ -758,11 +749,12 @@ impl<'a> InferenceContext<'a> {
                    TyKind::Ref(Mutability::Not, static_lifetime(), TyKind::Str.intern(&Interner))
                        .intern(&Interner)
                }
-                Literal::ByteString(..) => {
+                Literal::ByteString(bs) => {
                    let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
-                    let array_type =
+                    let len = consteval::usize_const(Some(bs.len() as u64));
-                        TyKind::Array(byte_type, dummy_usize_const()).intern(&Interner);
+                    let array_type = TyKind::Array(byte_type, len).intern(&Interner);
                    TyKind::Ref(Mutability::Not, static_lifetime(), array_type).intern(&Interner)
                }
                Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
diff --git a/crates/hir_ty/src/interner.rs b/crates/hir_ty/src/interner.rs
index 4cbc9cd4f..7b4119747 100644
--- a/crates/hir_ty/src/interner.rs
+++ b/crates/hir_ty/src/interner.rs
@@ -1,11 +1,12 @@
 //! Implementation of the Chalk `Interner` trait, which allows customizing the
 //! representation of the various objects Chalk deals with (types, goals etc.).
-use crate::{chalk_db, consts::ConstScalar, tls, GenericArg};
+use crate::{chalk_db, tls, GenericArg};
 use base_db::salsa::InternId;
 use chalk_ir::{Goal, GoalData};
 use hir_def::{
    intern::{impl_internable, InternStorage, Internable, Interned},
+    type_ref::ConstScalar,
    TypeAliasId,
 };
 use smallvec::SmallVec;
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index d23eff513..15b61bedc 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -10,9 +10,9 @@ mod autoderef;
 mod builder;
 mod chalk_db;
 mod chalk_ext;
+pub mod consteval;
 mod infer;
 mod interner;
-mod consts;
 mod lower;
 mod mapping;
 mod op;
@@ -38,9 +38,13 @@ use chalk_ir::{
    interner::HasInterner,
    UintTy,
 };
-use hir_def::{expr::ExprId, type_ref::Rawness, TypeParamId};
+use hir_def::{
+    expr::ExprId,
+    type_ref::{ConstScalar, Rawness},
+    TypeParamId,
+};
-use crate::{consts::ConstScalar, db::HirDatabase, display::HirDisplay, utils::generics};
+use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
 pub use autoderef::autoderef;
 pub use builder::TyBuilder;
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 9751b45e4..bd8bb6028 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -29,8 +29,8 @@ use stdx::impl_from;
 use syntax::ast;
 use crate::{
+    consteval,
    db::HirDatabase,
-    dummy_usize_const,
    mapping::ToChalk,
    static_lifetime, to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
    utils::{
@@ -172,11 +172,12 @@ impl<'a> TyLoweringContext<'a> {
                let inner_ty = self.lower_ty(inner);
                TyKind::Raw(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
            }
-            TypeRef::Array(inner) => {
+            TypeRef::Array(inner, len) => {
                let inner_ty = self.lower_ty(inner);
-                // FIXME: we don't have length info here because we don't store an expression for
-                // the length
+                let const_len = consteval::usize_const(len.as_usize());
-                TyKind::Array(inner_ty, dummy_usize_const()).intern(&Interner)
+                TyKind::Array(inner_ty, const_len).intern(&Interner)
            }
            TypeRef::Slice(inner) => {
                let inner_ty = self.lower_ty(inner);
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index aad3d610e..190471069 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -64,42 +64,42 @@ fn coerce_places() {
            81..92 '{ loop {} }': T
            83..90 'loop {}': !
            88..90 '{}': ()
-            121..132 '{ loop {} }': *mut [T; _]
+            121..132 '{ loop {} }': *mut [T; 2]
            123..130 'loop {}': !
            128..130 '{}': ()
            159..172 '{     gen() }': *mut [U]
-            165..168 'gen': fn gen<U>() -> *mut [U; _]
+            165..168 'gen': fn gen<U>() -> *mut [U; 2]
-            165..170 'gen()': *mut [U; _]
+            165..170 'gen()': *mut [U; 2]
            185..419 '{     ...rr); }': ()
-            195..198 'arr': &[u8; _]
+            195..198 'arr': &[u8; 1]
            211..215 '&[1]': &[u8; 1]
            212..215 '[1]': [u8; 1]
            213..214 '1': u8
            226..227 'a': &[u8]
-            236..239 'arr': &[u8; _]
+            236..239 'arr': &[u8; 1]
            249..250 'b': u8
            253..254 'f': fn f<u8>(&[u8]) -> u8
            253..259 'f(arr)': u8
-            255..258 'arr': &[u8; _]
+            255..258 'arr': &[u8; 1]
            269..270 'c': &[u8]
            279..286 '{ arr }': &[u8]
-            281..284 'arr': &[u8; _]
+            281..284 'arr': &[u8; 1]
            296..297 'd': u8
            300..301 'g': fn g<u8>(S<&[u8]>) -> u8
            300..315 'g(S { a: arr })': u8
            302..314 'S { a: arr }': S<&[u8]>
-            309..312 'arr': &[u8; _]
+            309..312 'arr': &[u8; 1]
-            325..326 'e': [&[u8]; _]
+            325..326 'e': [&[u8]; 1]
            340..345 '[arr]': [&[u8]; 1]
-            341..344 'arr': &[u8; _]
+            341..344 'arr': &[u8; 1]
-            355..356 'f': [&[u8]; _]
+            355..356 'f': [&[u8]; 2]
-            370..378 '[arr; 2]': [&[u8]; _]
+            370..378 '[arr; 2]': [&[u8]; 2]
-            371..374 'arr': &[u8; _]
+            371..374 'arr': &[u8; 1]
            376..377 '2': usize
            388..389 'g': (&[u8], &[u8])
            406..416 '(arr, arr)': (&[u8], &[u8])
-            407..410 'arr': &[u8; _]
+            407..410 'arr': &[u8; 1]
-            412..415 'arr': &[u8; _]
+            412..415 'arr': &[u8; 1]
        "#]],
    );
 }
@@ -159,7 +159,7 @@ fn infer_custom_coerce_unsized() {
        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
        "#,
-        expect![[r"
+        expect![[r#"
            257..258 'x': A<[T]>
            278..283 '{ x }': A<[T]>
            280..281 'x': A<[T]>
@@ -169,23 +169,23 @@ fn infer_custom_coerce_unsized() {
            333..334 'x': C<[T]>
            354..359 '{ x }': C<[T]>
            356..357 'x': C<[T]>
-            369..370 'a': A<[u8; _]>
+            369..370 'a': A<[u8; 2]>
-            384..385 'b': B<[u8; _]>
+            384..385 'b': B<[u8; 2]>
-            399..400 'c': C<[u8; _]>
+            399..400 'c': C<[u8; 2]>
            414..480 '{     ...(c); }': ()
            424..425 'd': A<[{unknown}]>
            428..432 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
            428..435 'foo1(a)': A<[{unknown}]>
-            433..434 'a': A<[u8; _]>
+            433..434 'a': A<[u8; 2]>
            445..446 'e': B<[u8]>
            449..453 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
            449..456 'foo2(b)': B<[u8]>
-            454..455 'b': B<[u8; _]>
+            454..455 'b': B<[u8; 2]>
            466..467 'f': C<[u8]>
            470..474 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
            470..477 'foo3(c)': C<[u8]>
-            475..476 'c': C<[u8; _]>
+            475..476 'c': C<[u8; 2]>
-        "]],
+        "#]],
    );
 }
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index a0a7b4d0b..787647e9f 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -345,19 +345,19 @@ fn infer_pattern_match_arr() {
        "#,
        expect![[r#"
            10..179 '{     ...   } }': ()
-            20..23 'arr': [f64; _]
+            20..23 'arr': [f64; 2]
            36..46 '[0.0, 1.0]': [f64; 2]
            37..40 '0.0': f64
            42..45 '1.0': f64
            52..177 'match ...     }': ()
-            58..61 'arr': [f64; _]
+            58..61 'arr': [f64; 2]
-            72..80 '[1.0, a]': [f64; _]
+            72..80 '[1.0, a]': [f64; 2]
            73..76 '1.0': f64
            73..76 '1.0': f64
            78..79 'a': f64
            84..110 '{     ...     }': ()
            98..99 'a': f64
-            120..126 '[b, c]': [f64; _]
+            120..126 '[b, c]': [f64; 2]
            121..122 'b': f64
            124..125 'c': f64
            130..171 '{     ...     }': ()
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 8b09f2e4a..a9cd42186 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -488,23 +488,34 @@ fn infer_literals() {
                mod foo {}
            "#;
            br#"yolo"#;
+            let a = b"a\x20b\
+            c";
+            let b = br"g\
+h";
+            let c = br#"x"\"yb"#;
        }
        "##,
        expect![[r##"
-            10..216 '{     ...o"#; }': ()
+            18..478 '{     ...     }': ()
-            16..20 '5i32': i32
+            32..36 '5i32': i32
-            26..30 '5f32': f32
+            50..54 '5f32': f32
-            36..40 '5f64': f64
+            68..72 '5f64': f64
-            46..53 '"hello"': &str
+            86..93 '"hello"': &str
-            59..67 'b"bytes"': &[u8; _]
+            107..115 'b"bytes"': &[u8; 5]
-            73..76 ''c'': char
+            129..132 ''c'': char
-            82..86 'b'b'': u8
+            146..150 'b'b'': u8
-            92..96 '3.14': f64
+            164..168 '3.14': f64
-            102..106 '5000': i32
+            182..186 '5000': i32
-            112..117 'false': bool
+            200..205 'false': bool
-            123..127 'true': bool
+            219..223 'true': bool
-            133..197 'r#"   ...    "#': &str
+            237..333 'r#"   ...    "#': &str
-            203..213 'br#"yolo"#': &[u8; _]
+            347..357 'br#"yolo"#': &[u8; 4]
+            375..376 'a': &[u8; 4]
+            379..403 'b"a\x2...    c"': &[u8; 4]
+            421..422 'b': &[u8; 4]
+            425..433 'br"g\ h"': &[u8; 4]
+            451..452 'c': &[u8; 6]
+            455..467 'br#"x"\"yb"#': &[u8; 6]
        "##]],
    );
 }
@@ -1260,12 +1271,14 @@ fn infer_array() {
            let b = [a, ["b"]];
            let x: [u8; 0] = [];
+            // FIXME: requires const evaluation/taking type from rhs somehow
+            let y: [u8; 2+2] = [1,2,3,4];
        }
        "#,
        expect![[r#"
            8..9 'x': &str
            17..18 'y': isize
-            27..292 '{     ... []; }': ()
+            27..395 '{     ...,4]; }': ()
            37..38 'a': [&str; 1]
            41..44 '[x]': [&str; 1]
            42..43 'x': &str
@@ -1313,8 +1326,14 @@ fn infer_array() {
            255..256 'a': [&str; 1]
            258..263 '["b"]': [&str; 1]
            259..262 '"b"': &str
-            274..275 'x': [u8; _]
+            274..275 'x': [u8; 0]
            287..289 '[]': [u8; 0]
+            368..369 'y': [u8; _]
+            383..392 '[1,2,3,4]': [u8; 4]
+            384..385 '1': u8
+            386..387 '2': u8
+            388..389 '3': u8
+            390..391 '4': u8
        "#]],
    );
 }
@@ -2409,38 +2428,38 @@ fn infer_operator_overload() {
            320..422 '{     ...     }': V2
            334..335 'x': f32
            338..342 'self': V2
-            338..344 'self.0': [f32; _]
+            338..344 'self.0': [f32; 2]
            338..347 'self.0[0]': {unknown}
            338..358 'self.0...s.0[0]': f32
            345..346 '0': i32
            350..353 'rhs': V2
-            350..355 'rhs.0': [f32; _]
+            350..355 'rhs.0': [f32; 2]
            350..358 'rhs.0[0]': {unknown}
            356..357 '0': i32
            372..373 'y': f32
            376..380 'self': V2
-            376..382 'self.0': [f32; _]
+            376..382 'self.0': [f32; 2]
            376..385 'self.0[1]': {unknown}
            376..396 'self.0...s.0[1]': f32
            383..384 '1': i32
            388..391 'rhs': V2
-            388..393 'rhs.0': [f32; _]
+            388..393 'rhs.0': [f32; 2]
            388..396 'rhs.0[1]': {unknown}
            394..395 '1': i32
-            406..408 'V2': V2([f32; _]) -> V2
+            406..408 'V2': V2([f32; 2]) -> V2
            406..416 'V2([x, y])': V2
            409..415 '[x, y]': [f32; 2]
            410..411 'x': f32
            413..414 'y': f32
            436..519 '{     ... vb; }': ()
            446..448 'va': V2
-            451..453 'V2': V2([f32; _]) -> V2
+            451..453 'V2': V2([f32; 2]) -> V2
            451..465 'V2([0.0, 1.0])': V2
            454..464 '[0.0, 1.0]': [f32; 2]
            455..458 '0.0': f32
            460..463 '1.0': f32
            475..477 'vb': V2
-            480..482 'V2': V2([f32; _]) -> V2
+            480..482 'V2': V2([f32; 2]) -> V2
            480..494 'V2([0.0, 1.0])': V2
            483..493 '[0.0, 1.0]': [f32; 2]
            484..487 '0.0': f32
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 47a1455fd..f80cf9879 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -3474,3 +3474,100 @@ fn main(){
        "#]],
    )
 }
+#[test]
+fn array_length() {
+    check_infer(
+        r#"
+trait T {
+    type Output;
+    fn do_thing(&self) -> Self::Output;
+}
+impl T for [u8; 4] {
+    type Output = usize;
+    fn do_thing(&self) -> Self::Output {
+        2
+    }
+}
+impl T for [u8; 2] {
+    type Output = u8;
+    fn do_thing(&self) -> Self::Output {
+        2
+    }
+}
+fn main() {
+    let v = [0u8; 2];
+    let v2 = v.do_thing();
+    let v3 = [0u8; 4];
+    let v4 = v3.do_thing();
+}
+"#,
+        expect![[r#"
+            44..48 'self': &Self
+            133..137 'self': &[u8; 4]
+            155..172 '{     ...     }': usize
+            165..166 '2': usize
+            236..240 'self': &[u8; 2]
+            258..275 '{     ...     }': u8
+            268..269 '2': u8
+            289..392 '{     ...g(); }': ()
+            299..300 'v': [u8; 2]
+            303..311 '[0u8; 2]': [u8; 2]
+            304..307 '0u8': u8
+            309..310 '2': usize
+            321..323 'v2': u8
+            326..327 'v': [u8; 2]
+            326..338 'v.do_thing()': u8
+            348..350 'v3': [u8; 4]
+            353..361 '[0u8; 4]': [u8; 4]
+            354..357 '0u8': u8
+            359..360 '4': usize
+            371..373 'v4': usize
+            376..378 'v3': [u8; 4]
+            376..389 'v3.do_thing()': usize
+        "#]],
+    )
+}
+// FIXME: We should infer the length of the returned array :)
+#[test]
+fn const_generics() {
+    check_infer(
+        r#"
+trait T {
+    type Output;
+    fn do_thing(&self) -> Self::Output;
+}
+impl<const L: usize> T for [u8; L] {
+    type Output = [u8; L];
+    fn do_thing(&self) -> Self::Output {
+        *self
+    }
+}
+fn main() {
+    let v = [0u8; 2];
+    let v2 = v.do_thing();
+}
+"#,
+        expect![[r#"
+            44..48 'self': &Self
+            151..155 'self': &[u8; _]
+            173..194 '{     ...     }': [u8; _]
+            183..188 '*self': [u8; _]
+            184..188 'self': &[u8; _]
+            208..260 '{     ...g(); }': ()
+            218..219 'v': [u8; 2]
+            222..230 '[0u8; 2]': [u8; 2]
+            223..226 '0u8': u8
+            228..229 '2': usize
+            240..242 'v2': [u8; _]
+            245..246 'v': [u8; 2]
+            245..257 'v.do_thing()': [u8; _]
+        "#]],
+    )
+}
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 273d8cfbb..d5fba6740 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -579,7 +579,7 @@ fn test_fn() {
 struct TestStruct { one: i32, two: i64 }
 fn test_fn() {
-    let s = TestStruct { one: (), two: ()};
+    let s = TestStruct { one: (), two: () };
 }
 "#,
        );
@@ -599,7 +599,7 @@ impl TestStruct {
 struct TestStruct { one: i32 }
 impl TestStruct {
-    fn test_fn() { let s = Self { one: ()}; }
+    fn test_fn() { let s = Self { one: () }; }
 }
 "#,
        );
@@ -792,7 +792,7 @@ fn main() {
 pub struct Foo { pub a: i32, pub b: i32 }
 "#,
            r#"
-fn some(, b: ()) {}
+fn some(, b: () ) {}
 fn items() {}
 fn here() {}
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 15821500f..695b59e27 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -100,11 +100,12 @@ impl DiagnosticWithFix for MissingFields {
        let root = sema.db.parse_or_expand(self.file)?;
        let field_list_parent = self.field_list_parent.to_node(&root);
        let old_field_list = field_list_parent.record_expr_field_list()?;
-        let mut new_field_list = old_field_list.clone();
+        let new_field_list = old_field_list.clone_for_update();
        for f in self.missed_fields.iter() {
            let field =
-                make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit()));
+                make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit()))
-            new_field_list = new_field_list.append_field(&field);
+                    .clone_for_update();
+            new_field_list.add_field(field);
        }
        let edit = {
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 61dcbb399..c67ccd1a9 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -4,7 +4,7 @@ use ide_assists::utils::extract_trivial_expression;
 use itertools::Itertools;
 use syntax::{
    algo::non_trivia_sibling,
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode, AstToken, IsString},
    Direction, NodeOrToken, SourceFile,
    SyntaxKind::{self, USE_TREE, WHITESPACE},
    SyntaxNode, SyntaxToken, TextRange, TextSize, T,
diff --git a/crates/ide/src/matching_brace.rs b/crates/ide/src/matching_brace.rs
index 261dcc255..011c8cc55 100644
--- a/crates/ide/src/matching_brace.rs
+++ b/crates/ide/src/matching_brace.rs
@@ -19,14 +19,10 @@ use syntax::{
 pub(crate) fn matching_brace(file: &SourceFile, offset: TextSize) -> Option<TextSize> {
    const BRACES: &[SyntaxKind] =
        &[T!['{'], T!['}'], T!['['], T![']'], T!['('], T![')'], T![<], T![>], T![|], T![|]];
-    let (brace_token, brace_idx) = file
+    let (brace_token, brace_idx) = file.syntax().token_at_offset(offset).find_map(|node| {
-        .syntax()
+        let idx = BRACES.iter().position(|&brace| brace == node.kind())?;
-        .token_at_offset(offset)
+        Some((node, idx))
-        .filter_map(|node| {
+    })?;
-            let idx = BRACES.iter().position(|&brace| brace == node.kind())?;
-            Some((node, idx))
-        })
-        .next()?;
    let parent = brace_token.parent()?;
    if brace_token.kind() == T![|] && !ast::ParamList::can_cast(parent.kind()) {
        cov_mark::hit!(pipes_not_braces);
diff --git a/crates/ide/src/parent_module.rs b/crates/ide/src/parent_module.rs
index 99365c8a7..9b1f48044 100644
--- a/crates/ide/src/parent_module.rs
+++ b/crates/ide/src/parent_module.rs
@@ -1,6 +1,8 @@
 use hir::Semantics;
-use ide_db::base_db::{CrateId, FileId, FilePosition};
+use ide_db::{
-use ide_db::RootDatabase;
+    base_db::{CrateId, FileId, FilePosition},
+    RootDatabase,
+};
 use itertools::Itertools;
 use syntax::{
    algo::find_node_at_offset,
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index bc221d599..4269d339e 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -6,7 +6,7 @@ use either::Either;
 use hir::{InFile, Semantics};
 use ide_db::{call_info::ActiveParameter, helpers::rust_doc::is_rust_fence, SymbolKind};
 use syntax::{
-    ast::{self, AstNode},
+    ast::{self, AstNode, IsString},
    AstToken, NodeOrToken, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 8d83ba206..921a956e6 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -37,13 +37,25 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="comment documentation">/// ```</span>
+<pre><code><span class="comment documentation">//! This is a module to test doc injection.</span>
+<span class="comment documentation">//! ```</span>
+<span class="comment documentation">//! </span><span class="keyword injected">fn</span><span class="none injected"> </span><span class="function declaration injected">test</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="none injected"> </span><span class="brace injected">{</span><span class="brace injected">}</span>
+<span class="comment documentation">//! ```</span>
+<span class="comment documentation">/// ```</span>
 <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="semicolon injected">;</span>
 <span class="comment documentation">/// ```</span>
 <span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="brace">{</span>
    <span class="field declaration">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span><span class="comma">,</span>
 <span class="brace">}</span>
+<span class="comment documentation">/// This is an impl with a code block.</span>
+<span class="comment documentation">///</span>
+<span class="comment documentation">/// ```</span>
+<span class="comment documentation">/// </span><span class="keyword injected">fn</span><span class="none injected"> </span><span class="function declaration injected">foo</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="none injected"> </span><span class="brace injected">{</span>
+<span class="comment documentation">///</span>
+<span class="comment documentation">/// </span><span class="brace injected">}</span>
+<span class="comment documentation">/// ```</span>
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="brace">{</span>
    <span class="comment documentation">/// ```</span>
    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Call me</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index e05971983..8c8878d36 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -524,6 +524,11 @@ fn main() {
 fn test_highlight_doc_comment() {
    check_highlighting(
        r#"
+//! This is a module to test doc injection.
+//! ```
+//! fn test() {}
+//! ```
 /// ```
 /// let _ = "early doctests should not go boom";
 /// ```
@@ -531,6 +536,13 @@ struct Foo {
    bar: bool,
 }
+/// This is an impl with a code block.
+///
+/// ```
+/// fn foo() {
+///
+/// }
+/// ```
 impl Foo {
    /// ```
    /// let _ = "Call me
diff --git a/crates/ide_assists/src/assist_context.rs b/crates/ide_assists/src/assist_context.rs
index 682f0ff5e..20754a02a 100644
--- a/crates/ide_assists/src/assist_context.rs
+++ b/crates/ide_assists/src/assist_context.rs
@@ -238,8 +238,8 @@ impl AssistBuilder {
        }
    }
-    pub(crate) fn make_ast_mut<N: AstNode>(&mut self, node: N) -> N {
+    pub(crate) fn make_mut<N: AstNode>(&mut self, node: N) -> N {
-        N::cast(self.make_mut(node.syntax().clone())).unwrap()
+        self.mutated_tree.get_or_insert_with(|| TreeMutator::new(node.syntax())).make_mut(&node)
    }
    /// Returns a copy of the `node`, suitable for mutation.
    ///
@@ -251,7 +251,7 @@ impl AssistBuilder {
    /// The typical pattern for an assist is to find specific nodes in the read
    /// phase, and then get their mutable couterparts using `make_mut` in the
    /// mutable state.
-    pub(crate) fn make_mut(&mut self, node: SyntaxNode) -> SyntaxNode {
+    pub(crate) fn make_syntax_mut(&mut self, node: SyntaxNode) -> SyntaxNode {
        self.mutated_tree.get_or_insert_with(|| TreeMutator::new(&node)).make_syntax_mut(&node)
    }
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::File(it) => ImportScope::File(builder.make_mut(it)),
-                    ImportScope::Module(it) => ImportScope::Module(builder.make_ast_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 source_file = builder.make_mut(ctx.sema.parse(ctx.frange.file_id));
-            let variant = builder.make_ast_mut(variant.clone());
+            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 new_match_arm_list = match_arm_list.clone_for_update();
-            let n_old_arms = new_arm_list.arms().count();
-            let new_arm_list = new_arm_list.append_arms(missing_arms);
+            let catch_all_arm = new_match_arm_list
-            let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+                .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 {
+enum A {
-                As,
+    As,
-                Bs{x:i32, y:Option<i32>},
+    Bs{x:i32, y:Option<i32>},
-                Cs(i32, Option<i32>),
+    Cs(i32, Option<i32>),
-            }
+}
-            fn main() {
+fn main() {
-                match A::As$0 {
+    match A::As$0 {
-                    A::As,
+        A::As,
-                    A::Bs{x,y:Some(_)} => {}
+        A::Bs{x,y:Some(_)} => {}
-                    A::Cs(_, Some(_)) => {}
+        A::Cs(_, Some(_)) => {}
-                }
+    }
-            }
+}
            "#,
        );
    }
@@ -284,13 +296,13 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match a$0 {
+    match a$0 {
-                    true => {}
+        true => {}
-                    false => {}
+        false => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -301,11 +313,11 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            fn main() {
+fn main() {
-                match (0, false)$0 {
+    match (0, false)$0 {
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -314,19 +326,19 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match a$0 {
+    match a$0 {
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match a {
+    match a {
-                    $0true => {}
+        $0true => {}
-                    false => {}
+        false => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -335,20 +347,20 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match a$0 {
+    match a$0 {
-                    true => {}
+        true => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match a {
+    match a {
-                    true => {}
+        true => {}
-                    $0false => {}
+        $0false => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -357,15 +369,15 @@ mod tests {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match (a, a)$0 {
+    match (a, a)$0 {
-                    (true, true) => {}
+        (true, true) => {}
-                    (true, false) => {}
+        (true, false) => {}
-                    (false, true) => {}
+        (false, true) => {}
-                    (false, false) => {}
+        (false, false) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -374,21 +386,21 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match (a, a)$0 {
+    match (a, a)$0 {
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match (a, a) {
+    match (a, a) {
-                    $0(true, true) => {}
+        $0(true, true) => {}
-                    (true, false) => {}
+        (true, false) => {}
-                    (false, true) => {}
+        (false, true) => {}
-                    (false, false) => {}
+        (false, false) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -397,22 +409,22 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match (a, a)$0 {
+    match (a, a)$0 {
-                    (false, true) => {}
+        (false, true) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            fn foo(a: bool) {
+fn foo(a: bool) {
-                match (a, a) {
+    match (a, a) {
-                    (false, true) => {}
+        (false, true) => {}
-                    $0(true, true) => {}
+        $0(true, true) => {}
-                    (true, false) => {}
+        (true, false) => {}
-                    (false, false) => {}
+        (false, false) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
@@ -421,32 +433,32 @@ mod tests {
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+enum A {
-                As,
+    As,
-                Bs { x: i32, y: Option<i32> },
+    Bs { x: i32, y: Option<i32> },
-                Cs(i32, Option<i32>),
+    Cs(i32, Option<i32>),
-            }
+}
-            fn main() {
+fn main() {
-                match A::As$0 {
+    match A::As$0 {
-                    A::Bs { x, y: Some(_) } => {}
+        A::Bs { x, y: Some(_) } => {}
-                    A::Cs(_, Some(_)) => {}
+        A::Cs(_, Some(_)) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A {
+enum A {
-                As,
+    As,
-                Bs { x: i32, y: Option<i32> },
+    Bs { x: i32, y: Option<i32> },
-                Cs(i32, Option<i32>),
+    Cs(i32, Option<i32>),
-            }
+}
-            fn main() {
+fn main() {
-                match A::As {
+    match A::As {
-                    A::Bs { x, y: Some(_) } => {}
+        A::Bs { x, y: Some(_) } => {}
-                    A::Cs(_, Some(_)) => {}
+        A::Cs(_, Some(_)) => {}
-                    $0A::As => {}
+        $0A::As => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -593,30 +605,30 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (a$0, b) {}
+    match (a$0, b) {}
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (a, b) {
+    match (a, b) {
-                    $0(A::One, B::One) => {}
+        $0(A::One, B::One) => {}
-                    (A::One, B::Two) => {}
+        (A::One, B::Two) => {}
-                    (A::Two, B::One) => {}
+        (A::Two, B::One) => {}
-                    (A::Two, B::Two) => {}
+        (A::Two, B::Two) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -625,30 +637,30 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (&a$0, &b) {}
+    match (&a$0, &b) {}
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (&a, &b) {
+    match (&a, &b) {
-                    $0(A::One, B::One) => {}
+        $0(A::One, B::One) => {}
-                    (A::One, B::Two) => {}
+        (A::One, B::Two) => {}
-                    (A::Two, B::One) => {}
+        (A::Two, B::One) => {}
-                    (A::Two, B::Two) => {}
+        (A::Two, B::Two) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -737,20 +749,20 @@ fn main() {
        check_assist_not_applicable(
            fill_match_arms,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            enum B { One, Two }
+enum B { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                let b = B::One;
+    let b = B::One;
-                match (a$0, b) {
+    match (a$0, b) {
-                    (A::Two, B::One) => {}
+        (A::Two, B::One) => {}
-                    (A::One, B::One) => {}
+        (A::One, B::One) => {}
-                    (A::One, B::Two) => {}
+        (A::One, B::Two) => {}
-                    (A::Two, 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() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                match (a$0, ) {
+    match (a$0, ) {
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            fn main() {
+fn main() {
-                let a = A::One;
+    let a = A::One;
-                match (a, ) {
+    match (a, ) {
-                    $0(A::One,) => {}
+        $0(A::One,) => {}
-                    (A::Two,) => {}
+        (A::Two,) => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -786,47 +798,47 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            enum A { As }
+enum A { As }
-            fn foo(a: &A) {
+fn foo(a: &A) {
-                match a$0 {
+    match a$0 {
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { As }
+enum A { As }
-            fn foo(a: &A) {
+fn foo(a: &A) {
-                match a {
+    match a {
-                    $0A::As => {}
+        $0A::As => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
        check_assist(
            fill_match_arms,
            r#"
-            enum A {
+enum A {
-                Es { x: usize, y: usize }
+    Es { x: usize, y: usize }
-            }
+}
-            fn foo(a: &mut A) {
+fn foo(a: &mut A) {
-                match a$0 {
+    match a$0 {
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A {
+enum A {
-                Es { x: usize, y: usize }
+    Es { x: usize, y: usize }
-            }
+}
-            fn foo(a: &mut A) {
+fn foo(a: &mut A) {
-                match a {
+    match a {
-                    $0A::Es { x, y } => {}
+        $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() {
+fn main() {
-                match E::X$0 {}
+    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() {
+fn main() {
-                match E::X {
+    match E::X {
-                    $0_ => {}
+        $0_ => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum E { X, Y }
+enum E { X, Y }
-            fn main() {
+fn main() {
-                match E::X {
+    match E::X {
-                    $0E::X => {}
+        $0E::X => {}
-                    E::Y => {}
+        E::Y => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -876,26 +888,26 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            mod foo { pub enum E { X, Y } }
+mod foo { pub enum E { X, Y } }
-            use foo::E::X;
+use foo::E::X;
-            fn main() {
+fn main() {
-                match X {
+    match X {
-                    $0
+        $0
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            mod foo { pub enum E { X, Y } }
+mod foo { pub enum E { X, Y } }
-            use foo::E::X;
+use foo::E::X;
-            fn main() {
+fn main() {
-                match X {
+    match X {
-                    $0X => {}
+        $0X => {}
-                    foo::E::Y => {}
+        foo::E::Y => {}
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -904,26 +916,26 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a {
+    match a {
-                    // foo bar baz$0
+        // foo bar baz$0
-                    A::One => {}
+        A::One => {}
-                    // This is where the rest should be
+        // This is where the rest should be
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a {
+    match a {
-                    // foo bar baz
+        // foo bar baz
-                    A::One => {}
+        A::One => {}
-                    // This is where the rest should be
+        $0A::Two => {}
-                    $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 }
+enum A { One, Two }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a {
+    match a {
-                    // foo bar baz$0
+        // foo bar baz$0
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two }
+enum A { One, Two }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a {
+    match a {
-                    // foo bar baz
+        $0A::One => {}
-                    $0A::One => {}
+        A::Two => {}
-                    A::Two => {}
+        // foo bar baz
-                }
+    }
-            }
+}
-            "#,
+"#,
        );
    }
@@ -957,22 +969,22 @@ fn main() {
        check_assist(
            fill_match_arms,
            r#"
-            enum A { One, Two, }
+enum A { One, Two, }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a$0 {
+    match a$0 {
-                    _ => (),
+        _ => (),
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            enum A { One, Two, }
+enum A { One, Two, }
-            fn foo(a: A) {
+fn foo(a: A) {
-                match a {
+    match a {
-                    $0A::One => {}
+        $0A::One => {}
-                    A::Two => {}
+        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 fn_def = builder.make_mut(fn_def);
-        let lifetime = builder.make_ast_mut(lifetime);
+        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 impl_def = builder.make_mut(impl_def);
-        let lifetime = builder.make_ast_mut(lifetime);
+        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::SelfParam(it) => Self::SelfParam(builder.make_mut(it)),
-            Self::RefType(it) => Self::RefType(builder.make_ast_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_replace = builder.make_mut(to_replace);
-                let to_remove = builder.make_ast_mut(to_remove);
+                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_replace = builder.make_mut(to_replace);
-                let to_remove = builder.make_ast_mut(to_remove);
+                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 type_param_list = edit.make_mut(type_param_list);
-            let parent = edit.make_mut(parent);
+            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 =
+            let methods = methods.into_iter().map(|fn_| builder.make_mut(fn_)).collect::<Vec<_>>();
-                methods.into_iter().map(|fn_| builder.make_ast_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 impl_trait_type = edit.make_mut(impl_trait_type);
-            let fn_ = edit.make_ast_mut(fn_);
+            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};
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index b635e0ca3..61b667104 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -9,22 +9,21 @@ use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKin
 pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
    // complete keyword "crate" in use stmt
    let source_range = ctx.source_range();
+    let kw_completion = move |text: &str| {
+        let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, text);
+        item.kind(CompletionItemKind::Keyword).insert_text(text);
+        item
+    };
    if ctx.use_item_syntax.is_some() {
        if ctx.path_qual.is_none() {
-            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "crate::");
+            kw_completion("crate::").add_to(acc);
-            item.kind(CompletionItemKind::Keyword).insert_text("crate::");
-            item.add_to(acc);
        }
-        let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "self");
+        kw_completion("self").add_to(acc);
-        item.kind(CompletionItemKind::Keyword);
-        item.add_to(acc);
        if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
            .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
        {
-            let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "super::");
+            kw_completion("super::").add_to(acc);
-            item.kind(CompletionItemKind::Keyword).insert_text("super::");
-            item.add_to(acc);
        }
    }
@@ -32,9 +31,8 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    if let Some(receiver) = &ctx.dot_receiver {
        if let Some(ty) = ctx.sema.type_of_expr(receiver) {
            if ty.impls_future(ctx.db) {
-                let mut item =
+                let mut item = kw_completion("await");
-                    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await");
+                item.detail("expr.await");
-                item.kind(CompletionItemKind::Keyword).detail("expr.await").insert_text("await");
                item.add_to(acc);
            }
        };
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 4b5f5c571..61952377f 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -10,12 +10,8 @@ use arrayvec::ArrayVec;
 use crate::{
    algo,
-    ast::{
+    ast::{self, make, AstNode},
-        self,
+    ted, AstToken, InsertPosition, NodeOrToken, SyntaxElement, SyntaxKind,
-        make::{self, tokens},
-        AstNode,
-    },
-    ted, AstToken, Direction, InsertPosition, NodeOrToken, SmolStr, SyntaxElement, SyntaxKind,
    SyntaxKind::{ATTR, COMMENT, WHITESPACE},
    SyntaxNode, SyntaxToken, T,
 };
@@ -29,114 +25,6 @@ impl ast::BinExpr {
    }
 }
-fn make_multiline<N>(node: N) -> N
-where
-    N: AstNode + Clone,
-{
-    let l_curly = match node.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) {
-        Some(it) => it,
-        None => return node,
-    };
-    let sibling = match l_curly.next_sibling_or_token() {
-        Some(it) => it,
-        None => return node,
-    };
-    let existing_ws = match sibling.as_token() {
-        None => None,
-        Some(tok) if tok.kind() != WHITESPACE => None,
-        Some(ws) => {
-            if ws.text().contains('\n') {
-                return node;
-            }
-            Some(ws.clone())
-        }
-    };
-    let indent = leading_indent(node.syntax()).unwrap_or_default();
-    let ws = tokens::WsBuilder::new(&format!("\n{}", indent));
-    let to_insert = iter::once(ws.ws().into());
-    match existing_ws {
-        None => node.insert_children(InsertPosition::After(l_curly), to_insert),
-        Some(ws) => node.replace_children(single_node(ws), to_insert),
-    }
-}
-impl ast::RecordExprFieldList {
-    #[must_use]
-    pub fn append_field(&self, field: &ast::RecordExprField) -> ast::RecordExprFieldList {
-        self.insert_field(InsertPosition::Last, field)
-    }
-    #[must_use]
-    pub fn insert_field(
-        &self,
-        position: InsertPosition<&'_ ast::RecordExprField>,
-        field: &ast::RecordExprField,
-    ) -> ast::RecordExprFieldList {
-        let is_multiline = self.syntax().text().contains_char('\n');
-        let ws;
-        let space = if is_multiline {
-            ws = tokens::WsBuilder::new(&format!(
-                "\n{}    ",
-                leading_indent(self.syntax()).unwrap_or_default()
-            ));
-            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().clone().into());
-        to_insert.push(make::token(T![,]).into());
-        macro_rules! after_l_curly {
-            () => {{
-                let anchor = match self.l_curly_token() {
-                    Some(it) => it.into(),
-                    None => return self.clone(),
-                };
-                InsertPosition::After(anchor)
-            }};
-        }
-        macro_rules! after_field {
-            ($anchor:expr) => {
-                if let Some(comma) = $anchor
-                    .syntax()
-                    .siblings_with_tokens(Direction::Next)
-                    .find(|it| it.kind() == T![,])
-                {
-                    InsertPosition::After(comma)
-                } else {
-                    to_insert.insert(0, make::token(T![,]).into());
-                    InsertPosition::After($anchor.syntax().clone().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.fields().last() {
-                    Some(it) => after_field!(it),
-                    None => after_l_curly!(),
-                }
-            }
-            InsertPosition::Before(anchor) => {
-                InsertPosition::Before(anchor.syntax().clone().into())
-            }
-            InsertPosition::After(anchor) => after_field!(anchor),
-        };
-        self.insert_children(position, to_insert)
-    }
-}
 impl ast::Path {
    #[must_use]
    pub fn with_segment(&self, segment: ast::PathSegment) -> ast::Path {
@@ -214,79 +102,6 @@ impl ast::UseTree {
    }
 }
-impl ast::MatchArmList {
-    #[must_use]
-    pub fn append_arms(&self, items: impl IntoIterator<Item = ast::MatchArm>) -> ast::MatchArmList {
-        let mut res = self.clone();
-        res = res.strip_if_only_whitespace();
-        if !res.syntax().text().contains_char('\n') {
-            res = make_multiline(res);
-        }
-        items.into_iter().for_each(|it| res = res.append_arm(it));
-        res
-    }
-    fn strip_if_only_whitespace(&self) -> ast::MatchArmList {
-        let mut iter = self.syntax().children_with_tokens().skip_while(|it| it.kind() != T!['{']);
-        iter.next(); // Eat the curly
-        let mut inner = iter.take_while(|it| it.kind() != T!['}']);
-        if !inner.clone().all(|it| it.kind() == WHITESPACE) {
-            return self.clone();
-        }
-        let start = match inner.next() {
-            Some(s) => s,
-            None => return self.clone(),
-        };
-        let end = match inner.last() {
-            Some(s) => s,
-            None => start.clone(),
-        };
-        self.replace_children(start..=end, &mut iter::empty())
-    }
-    #[must_use]
-    pub fn remove_placeholder(&self) -> ast::MatchArmList {
-        let placeholder =
-            self.arms().find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))));
-        if let Some(placeholder) = placeholder {
-            self.remove_arm(&placeholder)
-        } else {
-            self.clone()
-        }
-    }
-    #[must_use]
-    fn remove_arm(&self, arm: &ast::MatchArm) -> ast::MatchArmList {
-        let start = arm.syntax().clone();
-        let end = if let Some(comma) = start
-            .siblings_with_tokens(Direction::Next)
-            .skip(1)
-            .find(|it| !it.kind().is_trivia())
-            .filter(|it| it.kind() == T![,])
-        {
-            comma
-        } else {
-            start.clone().into()
-        };
-        self.replace_children(start.into()..=end, None)
-    }
-    #[must_use]
-    pub fn append_arm(&self, item: ast::MatchArm) -> ast::MatchArmList {
-        let r_curly = match self.syntax().children_with_tokens().find(|it| it.kind() == T!['}']) {
-            Some(t) => t,
-            None => return self.clone(),
-        };
-        let position = InsertPosition::Before(r_curly);
-        let arm_ws = tokens::WsBuilder::new("    ");
-        let match_indent = &leading_indent(self.syntax()).unwrap_or_default();
-        let match_ws = tokens::WsBuilder::new(&format!("\n{}", match_indent));
-        let to_insert: ArrayVec<SyntaxElement, 3> =
-            [arm_ws.ws().into(), item.syntax().clone().into(), match_ws.ws().into()].into();
-        self.insert_children(position, to_insert)
-    }
-}
 #[must_use]
 pub fn remove_attrs_and_docs<N: ast::AttrsOwner>(node: &N) -> N {
    N::cast(remove_attrs_and_docs_inner(node.syntax().clone())).unwrap()
@@ -413,22 +228,6 @@ impl IndentLevel {
    }
 }
-// FIXME: replace usages with IndentLevel above
-fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
-    for token in prev_tokens(node.first_token()?) {
-        if let Some(ws) = ast::Whitespace::cast(token.clone()) {
-            let ws_text = ws.text();
-            if let Some(pos) = ws_text.rfind('\n') {
-                return Some(ws_text[pos + 1..].into());
-            }
-        }
-        if token.text().contains('\n') {
-            break;
-        }
-    }
-    None
-}
 fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
    iter::successors(Some(token), |token| token.prev_token())
 }
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index ca777d057..14624c682 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -13,7 +13,7 @@ use crate::{
        make, GenericParamsOwner,
    },
    ted::{self, Position},
-    AstNode, AstToken, Direction,
+    AstNode, AstToken, Direction, SyntaxNode,
 };
 use super::NameOwner;
@@ -297,7 +297,7 @@ impl ast::AssocItemList {
            ),
            None => match self.l_curly_token() {
                Some(l_curly) => {
-                    self.normalize_ws_between_braces();
+                    normalize_ws_between_braces(self.syntax());
                    (IndentLevel::from_token(&l_curly) + 1, Position::after(&l_curly), "\n")
                }
                None => (IndentLevel::single(), Position::last_child_of(self.syntax()), "\n"),
@@ -309,25 +309,6 @@ impl ast::AssocItemList {
        ];
        ted::insert_all(position, elements);
    }
-    fn normalize_ws_between_braces(&self) -> Option<()> {
-        let l = self.l_curly_token()?;
-        let r = self.r_curly_token()?;
-        let indent = IndentLevel::from_node(self.syntax());
-        match l.next_sibling_or_token() {
-            Some(ws) if ws.kind() == SyntaxKind::WHITESPACE => {
-                if ws.next_sibling_or_token()?.into_token()? == r {
-                    ted::replace(ws, make::tokens::whitespace(&format!("\n{}", indent)));
-                }
-            }
-            Some(ws) if ws.kind() == T!['}'] => {
-                ted::insert(Position::after(l), make::tokens::whitespace(&format!("\n{}", indent)));
-            }
-            _ => (),
-        }
-        Some(())
-    }
 }
 impl ast::Fn {
@@ -346,6 +327,113 @@ impl ast::Fn {
    }
 }
+impl ast::MatchArm {
+    pub fn remove(&self) {
+        if let Some(sibling) = self.syntax().prev_sibling_or_token() {
+            if sibling.kind() == SyntaxKind::WHITESPACE {
+                ted::remove(sibling);
+            }
+        }
+        if let Some(sibling) = self.syntax().next_sibling_or_token() {
+            if sibling.kind() == T![,] {
+                ted::remove(sibling);
+            }
+        }
+        ted::remove(self.syntax());
+    }
+}
+impl ast::MatchArmList {
+    pub fn add_arm(&self, arm: ast::MatchArm) {
+        normalize_ws_between_braces(self.syntax());
+        let position = match self.arms().last() {
+            Some(last_arm) => {
+                let curly = last_arm
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .find(|it| it.kind() == T![,]);
+                Position::after(curly.unwrap_or_else(|| last_arm.syntax().clone().into()))
+            }
+            None => match self.l_curly_token() {
+                Some(it) => Position::after(it),
+                None => Position::last_child_of(self.syntax()),
+            },
+        };
+        let indent = IndentLevel::from_node(self.syntax()) + 1;
+        let elements = vec![
+            make::tokens::whitespace(&format!("\n{}", indent)).into(),
+            arm.syntax().clone().into(),
+        ];
+        ted::insert_all(position, elements);
+    }
+}
+impl ast::RecordExprFieldList {
+    pub fn add_field(&self, field: ast::RecordExprField) {
+        let is_multiline = self.syntax().text().contains_char('\n');
+        let whitespace = if is_multiline {
+            let indent = IndentLevel::from_node(self.syntax()) + 1;
+            make::tokens::whitespace(&format!("\n{}", indent))
+        } else {
+            make::tokens::single_space()
+        };
+        let position = match self.fields().last() {
+            Some(last_field) => {
+                let comma = match last_field
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .filter_map(|it| it.into_token())
+                    .find(|it| it.kind() == T![,])
+                {
+                    Some(it) => it,
+                    None => {
+                        let comma = ast::make::token(T![,]);
+                        ted::insert(Position::after(last_field.syntax()), &comma);
+                        comma
+                    }
+                };
+                Position::after(comma)
+            }
+            None => match self.l_curly_token() {
+                Some(it) => Position::after(it),
+                None => Position::last_child_of(self.syntax()),
+            },
+        };
+        ted::insert_all(position, vec![whitespace.into(), field.syntax().clone().into()]);
+        if is_multiline {
+            ted::insert(Position::after(field.syntax()), ast::make::token(T![,]));
+        }
+    }
+}
+fn normalize_ws_between_braces(node: &SyntaxNode) -> Option<()> {
+    let l = node
+        .children_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|it| it.kind() == T!['{'])?;
+    let r = node
+        .children_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|it| it.kind() == T!['}'])?;
+    let indent = IndentLevel::from_node(node);
+    match l.next_sibling_or_token() {
+        Some(ws) if ws.kind() == SyntaxKind::WHITESPACE => {
+            if ws.next_sibling_or_token()?.into_token()? == r {
+                ted::replace(ws, make::tokens::whitespace(&format!("\n{}", indent)));
+            }
+        }
+        Some(ws) if ws.kind() == T!['}'] => {
+            ted::insert(Position::after(l), make::tokens::whitespace(&format!("\n{}", indent)));
+        }
+        _ => (),
+    }
+    Some(())
+}
 #[cfg(test)]
 mod tests {
    use std::fmt;
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index 29d25a58a..4b1e1ccee 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -143,6 +143,30 @@ impl QuoteOffsets {
    }
 }
+pub trait IsString: AstToken {
+    fn quote_offsets(&self) -> Option<QuoteOffsets> {
+        let text = self.text();
+        let offsets = QuoteOffsets::new(text)?;
+        let o = self.syntax().text_range().start();
+        let offsets = QuoteOffsets {
+            quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o),
+            contents: offsets.contents + o,
+        };
+        Some(offsets)
+    }
+    fn text_range_between_quotes(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.contents)
+    }
+    fn open_quote_text_range(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.quotes.0)
+    }
+    fn close_quote_text_range(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.quotes.1)
+    }
+}
+impl IsString for ast::String {}
 impl ast::String {
    pub fn is_raw(&self) -> bool {
        self.text().starts_with('r')
@@ -187,32 +211,49 @@ impl ast::String {
            (false, false) => Some(Cow::Owned(buf)),
        }
    }
-    pub fn quote_offsets(&self) -> Option<QuoteOffsets> {
-        let text = self.text();
-        let offsets = QuoteOffsets::new(text)?;
-        let o = self.syntax().text_range().start();
-        let offsets = QuoteOffsets {
-            quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o),
-            contents: offsets.contents + o,
-        };
-        Some(offsets)
-    }
-    pub fn text_range_between_quotes(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.contents)
-    }
-    pub fn open_quote_text_range(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.quotes.0)
-    }
-    pub fn close_quote_text_range(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.quotes.1)
-    }
 }
+impl IsString for ast::ByteString {}
 impl ast::ByteString {
    pub fn is_raw(&self) -> bool {
        self.text().starts_with("br")
    }
+    pub fn value(&self) -> Option<Cow<'_, [u8]>> {
+        if self.is_raw() {
+            let text = self.text();
+            let text =
+                &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
+            return Some(Cow::Borrowed(text.as_bytes()));
+        }
+        let text = self.text();
+        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
+        let mut buf: Vec<u8> = Vec::new();
+        let mut text_iter = text.chars();
+        let mut has_error = false;
+        unescape_literal(text, Mode::ByteStr, &mut |char_range, unescaped_char| match (
+            unescaped_char,
+            buf.capacity() == 0,
+        ) {
+            (Ok(c), false) => buf.push(c as u8),
+            (Ok(c), true) if char_range.len() == 1 && Some(c) == text_iter.next() => (),
+            (Ok(c), true) => {
+                buf.reserve_exact(text.len());
+                buf.extend_from_slice(&text[..char_range.start].as_bytes());
+                buf.push(c as u8);
+            }
+            (Err(_), _) => has_error = true,
+        });
+        match (has_error, buf.capacity() == 0) {
+            (true, _) => None,
+            (false, true) => Some(Cow::Borrowed(text.as_bytes())),
+            (false, false) => Some(Cow::Owned(buf)),
+        }
+    }
 }
 #[derive(Debug)]
diff --git a/crates/syntax/src/parsing/text_tree_sink.rs b/crates/syntax/src/parsing/text_tree_sink.rs
index 1934204ea..d63ec080b 100644
--- a/crates/syntax/src/parsing/text_tree_sink.rs
+++ b/crates/syntax/src/parsing/text_tree_sink.rs
@@ -147,8 +147,8 @@ fn n_attached_trivias<'a>(
    trivias: impl Iterator<Item = (SyntaxKind, &'a str)>,
 ) -> usize {
    match kind {
-        MACRO_CALL | MACRO_RULES | MACRO_DEF | CONST | TYPE_ALIAS | STRUCT | UNION | ENUM
+        CONST | ENUM | FN | IMPL | MACRO_CALL | MACRO_DEF | MACRO_RULES | MODULE | RECORD_FIELD
-        | VARIANT | FN | TRAIT | MODULE | RECORD_FIELD | STATIC | USE => {
+        | STATIC | STRUCT | TRAIT | TUPLE_FIELD | TYPE_ALIAS | UNION | USE | VARIANT => {
            let mut res = 0;
            let mut trivias = trivias.enumerate().peekable();
diff --git a/crates/syntax/test_data/parser/ok/0045_block_attrs.rast b/crates/syntax/test_data/parser/ok/0045_block_attrs.rast
index 50ab52d32..5e50b4e0b 100644
--- a/crates/syntax/test_data/parser/ok/0045_block_attrs.rast
+++ b/crates/syntax/test_data/parser/ok/0045_block_attrs.rast
@@ -127,9 +127,9 @@ [email protected]
      [email protected] "\n"
      [email protected] "}"
  [email protected] "\n\n"
-  COMMENT@541..601 "// https://github.com ..."
+  IMPL@541..763
-  WHITESPACE@601..602 "\n"
+    COMMENT@541..601 "// https://github.com ..."
-  IMPL@602..763
+    WHITESPACE@601..602 "\n"
    [email protected] "impl"
    [email protected] " "
    [email protected]