97 files changed, 2870 insertions, 2134 deletions
diff --git a/Cargo.lock b/Cargo.lock
index f9c34547e..76a26ea4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -437,18 +437,18 @@ dependencies = [
 [[package]]
 name = "fsevent-sys"
-version = "3.0.2"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a29c77f1ca394c3e73a9a5d24cfcabb734682d9634fc398f2204a63c994120"
+checksum = "ca6f5e6817058771c10f0eb0f05ddf1e35844266f972004fe8e4b21fda295bd5"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "fst"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d79238883cf0307100b90aba4a755d8051a3182305dfe7f649a1e9dc0517006f"
+checksum = "e398fae362f4124bbe630d99519fb2d68a03e2e3a23b441028cdcdc4f4895687"
 [[package]]
 name = "gimli"
@@ -939,11 +939,10 @@ dependencies = [
 [[package]]
 name = "notify"
-version = "5.0.0-pre.7"
+version = "5.0.0-pre.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebe7699a0f8c5759450716ee03d231685c22b4fe8f406c42c22e0ad94d40ce7"
+checksum = "46bbbcd078f1f00ddb7a9abe70b96e91229b44b0b3afdec610f8e5137f8f014b"
 dependencies = [
- "anymap",
 "bitflags",
 "crossbeam-channel",
 "filetime",
@@ -1295,9 +1294,9 @@ checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
 [[package]]
 name = "rowan"
-version = "0.13.0-pre.5"
+version = "0.13.0-pre.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a5fc82ed0b7e7fba157331f0d8f64abd73bced6e7ac2a4dfa0c4cf0ab584e8"
+checksum = "82ccc04e145e9a5ab51b9c12a81d77c4a8250d87a407ab02ac650451141ff00d"
 dependencies = [
 "countme",
 "hashbrown",
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 1682d8bde..93cf6a3d6 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -215,6 +215,7 @@ impl FlycheckActor {
            } => {
                let mut cmd = Command::new(toolchain::cargo());
                cmd.arg(command);
+                cmd.current_dir(&self.workspace_root);
                cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
                    .arg(self.workspace_root.join("Cargo.toml"));
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index c9ef4b420..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,
@@ -873,6 +875,10 @@ impl Function {
        db.function_data(self.id).is_unsafe()
    }
+    pub fn is_async(self, db: &dyn HirDatabase) -> bool {
+        db.function_data(self.id).is_async()
+    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
        let krate = self.module(db).id.krate();
        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
@@ -1910,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.rs b/crates/hir_def/src/body.rs
index 8360426f1..98b485b60 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -21,8 +21,6 @@ use profile::Count;
 use rustc_hash::FxHashMap;
 use syntax::{ast, AstNode, AstPtr};
-pub use lower::LowerCtx;
 use crate::{
    attr::{Attrs, RawAttrs},
    db::DefDatabase,
@@ -35,6 +33,8 @@ use crate::{
    UnresolvedMacro,
 };
+pub use lower::LowerCtx;
 /// A subset of Expander that only deals with cfg attributes. We only need it to
 /// avoid cyclic queries in crate def map during enum processing.
 #[derive(Debug)]
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/find_path.rs b/crates/hir_def/src/find_path.rs
index 858e88038..ee52794aa 100644
--- a/crates/hir_def/src/find_path.rs
+++ b/crates/hir_def/src/find_path.rs
@@ -5,10 +5,10 @@ use std::iter;
 use hir_expand::name::{known, AsName, Name};
 use rustc_hash::FxHashSet;
-use crate::nameres::DefMap;
 use crate::{
    db::DefDatabase,
    item_scope::ItemInNs,
+    nameres::DefMap,
    path::{ModPath, PathKind},
    visibility::Visibility,
    ModuleDefId, ModuleId,
@@ -134,7 +134,16 @@ fn find_path_inner(
    for (name, def_id) in root_def_map.extern_prelude() {
        if item == ItemInNs::Types(*def_id) {
            let name = scope_name.unwrap_or_else(|| name.clone());
-            return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
+            let name_already_occupied_in_type_ns = def_map
+                .with_ancestor_maps(db, from.local_id, &mut |def_map, local_id| {
+                    def_map[local_id].scope.get(&name).take_types().filter(|&id| id != *def_id)
+                })
+                .is_some();
+            return Some(ModPath::from_segments(
+                if name_already_occupied_in_type_ns { PathKind::Abs } else { PathKind::Plain },
+                vec![name],
+            ));
        }
    }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index a68674c10..d4840be2f 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -481,6 +481,11 @@ impl DefCollector<'_> {
        let res = self.def_map.resolve_name_in_extern_prelude(self.db, &extern_crate.name);
        if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
+            if m == self.def_map.module_id(current_module_id) {
+                cov_mark::hit!(ignore_macro_use_extern_crate_self);
+                return;
+            }
            cov_mark::hit!(macro_rules_from_other_crates_are_visible_with_macro_use);
            self.import_all_macros_exported(current_module_id, m.krate);
        }
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 4f2e7a2f9..9f652731d 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -411,6 +411,22 @@ struct Arc;
 }
 #[test]
+fn macro_use_extern_crate_self() {
+    cov_mark::check!(ignore_macro_use_extern_crate_self);
+    check(
+        r#"
+//- /main.rs crate:main
+#[macro_use]
+extern crate self as bla;
+"#,
+        expect![[r#"
+            crate
+            bla: t
+        "#]],
+    );
+}
+#[test]
 fn reexport_across_crates() {
    check(
        r#"
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_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index af9802144..280c25f11 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -118,6 +118,7 @@ register_builtin! {
    EAGER:
    (compile_error, CompileError) => compile_error_expand,
    (concat, Concat) => concat_expand,
+    (concat_idents, ConcatIdents) => concat_idents_expand,
    (include, Include) => include_expand,
    (include_bytes, IncludeBytes) => include_bytes_expand,
    (include_str, IncludeStr) => include_str_expand,
@@ -373,6 +374,28 @@ fn concat_expand(
    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
 }
+fn concat_idents_expand(
+    _db: &dyn AstDatabase,
+    _arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> ExpandResult<Option<ExpandedEager>> {
+    let mut err = None;
+    let mut ident = String::new();
+    for (i, t) in tt.token_trees.iter().enumerate() {
+        match t {
+            tt::TokenTree::Leaf(tt::Leaf::Ident(id)) => {
+                ident.push_str(id.text.as_str());
+            }
+            tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if i % 2 == 1 && punct.char == ',' => (),
+            _ => {
+                err.get_or_insert(mbe::ExpandError::UnexpectedToken);
+            }
+        }
+    }
+    let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident), FragmentKind::Expr)), err }
+}
 fn relative_file(
    db: &dyn AstDatabase,
    call_id: MacroCallId,
@@ -794,4 +817,16 @@ mod tests {
            expect![[r#""foor0bar\nfalse""#]],
        );
    }
+    #[test]
+    fn test_concat_idents_expand() {
+        check_expansion(
+            r##"
+            #[rustc_builtin_macro]
+            macro_rules! concat_idents {}
+            concat_idents!(foo, bar);
+            "##,
+            expect![[r#"foobar"#]],
+        );
+    }
 }
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index bcfd3e524..5a5dc9afd 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -212,6 +212,7 @@ pub mod known {
        std_panic,
        stringify,
        concat,
+        concat_idents,
        include,
        include_bytes,
        include_str,
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/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index e9762622f..6ee0529c6 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -1119,6 +1119,7 @@ fn main() {
        (true, false, true) => (),
        (true) => (),
    }
+    match (true, false) { (true,) => {} }
    match (0) { () => () }
    match Unresolved::Bar { Unresolved::Baz => () }
 }
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/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index aea354cde..60b94a642 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -126,11 +126,12 @@ impl<'a> InferenceContext<'a> {
                    _ => &[],
                };
-                let (pre, post) = match ellipsis {
+                let ((pre, post), n_uncovered_patterns) = match ellipsis {
-                    Some(idx) => args.split_at(idx),
+                    Some(idx) => {
-                    None => (&args[..], &[][..]),
+                        (args.split_at(idx), expectations.len().saturating_sub(args.len()))
+                    }
+                    None => ((&args[..], &[][..]), 0),
                };
-                let n_uncovered_patterns = expectations.len().saturating_sub(args.len());
                let err_ty = self.err_ty();
                let mut expectations_iter =
                    expectations.iter().map(|a| a.assert_ty_ref(&Interner)).chain(repeat(&err_ty));
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 33305f208..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 '{     ...     }': ()
@@ -732,7 +732,7 @@ fn foo(tuple: (u8, i16, f32)) {
            111..112 'a': u8
            114..115 'b': i16
            124..126 '{}': ()
-            136..142 '(a, b)': (u8, i16, f32)
+            136..142 '(a, b)': (u8, i16)
            137..138 'a': u8
            140..141 'b': i16
            146..161 '{/*too short*/}': ()
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..27d347dbd 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -28,7 +28,7 @@ use unlinked_file::UnlinkedFile;
 use crate::{Assist, AssistId, AssistKind, FileId, Label, SourceChange};
-use self::fixes::DiagnosticWithFix;
+use self::fixes::DiagnosticWithFixes;
 #[derive(Debug)]
 pub struct Diagnostic {
@@ -36,14 +36,14 @@ pub struct Diagnostic {
    pub message: String,
    pub range: TextRange,
    pub severity: Severity,
-    pub fix: Option<Assist>,
+    pub fixes: Option<Vec<Assist>>,
    pub unused: bool,
    pub code: Option<DiagnosticCode>,
 }
 impl Diagnostic {
    fn error(range: TextRange, message: String) -> Self {
-        Self { message, range, severity: Severity::Error, fix: None, unused: false, code: None }
+        Self { message, range, severity: Severity::Error, fixes: None, unused: false, code: None }
    }
    fn hint(range: TextRange, message: String) -> Self {
@@ -51,14 +51,14 @@ impl Diagnostic {
            message,
            range,
            severity: Severity::WeakWarning,
-            fix: None,
+            fixes: None,
            unused: false,
            code: None,
        }
    }
-    fn with_fix(self, fix: Option<Assist>) -> Self {
+    fn with_fixes(self, fixes: Option<Vec<Assist>>) -> Self {
-        Self { fix, ..self }
+        Self { fixes, ..self }
    }
    fn with_unused(self, unused: bool) -> Self {
@@ -154,7 +154,7 @@ pub(crate) fn diagnostics(
            // Override severity and mark as unused.
            res.borrow_mut().push(
                Diagnostic::hint(range, d.message())
-                    .with_fix(d.fix(&sema, resolve))
+                    .with_fixes(d.fixes(&sema, resolve))
                    .with_code(Some(d.code())),
            );
        })
@@ -210,23 +210,23 @@ pub(crate) fn diagnostics(
    res.into_inner()
 }
-fn diagnostic_with_fix<D: DiagnosticWithFix>(
+fn diagnostic_with_fix<D: DiagnosticWithFixes>(
    d: &D,
    sema: &Semantics<RootDatabase>,
    resolve: &AssistResolveStrategy,
 ) -> Diagnostic {
    Diagnostic::error(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema, resolve))
+        .with_fixes(d.fixes(&sema, resolve))
        .with_code(Some(d.code()))
 }
-fn warning_with_fix<D: DiagnosticWithFix>(
+fn warning_with_fix<D: DiagnosticWithFixes>(
    d: &D,
    sema: &Semantics<RootDatabase>,
    resolve: &AssistResolveStrategy,
 ) -> Diagnostic {
    Diagnostic::hint(sema.diagnostics_display_range(d.display_source()).range, d.message())
-        .with_fix(d.fix(&sema, resolve))
+        .with_fixes(d.fixes(&sema, resolve))
        .with_code(Some(d.code()))
 }
@@ -256,12 +256,12 @@ fn check_unnecessary_braces_in_use_statement(
        acc.push(
            Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
-                .with_fix(Some(fix(
+                .with_fixes(Some(vec![fix(
                    "remove_braces",
                    "Remove unnecessary braces",
                    SourceChange::from_text_edit(file_id, edit),
                    use_range,
-                ))),
+                )])),
        );
    }
@@ -309,9 +309,23 @@ mod tests {
    /// Takes a multi-file input fixture with annotated cursor positions,
    /// and checks that:
    ///  * a diagnostic is produced
-    ///  * this diagnostic fix trigger range touches the input cursor position
+    ///  * the first diagnostic fix trigger range touches the input cursor position
    ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
    pub(crate) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
+        check_nth_fix(0, ra_fixture_before, ra_fixture_after);
+    }
+    /// Takes a multi-file input fixture with annotated cursor positions,
+    /// and checks that:
+    ///  * a diagnostic is produced
+    ///  * every diagnostic fixes trigger range touches the input cursor position
+    ///  * that the contents of the file containing the cursor match `after` after each diagnostic fix is applied
+    pub(crate) fn check_fixes(ra_fixture_before: &str, ra_fixtures_after: Vec<&str>) {
+        for (i, ra_fixture_after) in ra_fixtures_after.iter().enumerate() {
+            check_nth_fix(i, ra_fixture_before, ra_fixture_after)
+        }
+    }
+    fn check_nth_fix(nth: usize, ra_fixture_before: &str, ra_fixture_after: &str) {
        let after = trim_indent(ra_fixture_after);
        let (analysis, file_position) = fixture::position(ra_fixture_before);
@@ -324,9 +338,9 @@ mod tests {
            .unwrap()
            .pop()
            .unwrap();
-        let fix = diagnostic.fix.unwrap();
+        let fix = &diagnostic.fixes.unwrap()[nth];
        let actual = {
-            let source_change = fix.source_change.unwrap();
+            let source_change = fix.source_change.as_ref().unwrap();
            let file_id = *source_change.source_file_edits.keys().next().unwrap();
            let mut actual = analysis.file_text(file_id).unwrap().to_string();
@@ -344,7 +358,6 @@ mod tests {
            file_position.offset
        );
    }
    /// Checks that there's a diagnostic *without* fix at `$0`.
    fn check_no_fix(ra_fixture: &str) {
        let (analysis, file_position) = fixture::position(ra_fixture);
@@ -357,7 +370,7 @@ mod tests {
            .unwrap()
            .pop()
            .unwrap();
-        assert!(diagnostic.fix.is_none(), "got a fix when none was expected: {:?}", diagnostic);
+        assert!(diagnostic.fixes.is_none(), "got a fix when none was expected: {:?}", diagnostic);
    }
    /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
@@ -375,7 +388,7 @@ mod tests {
        assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics);
    }
-    fn check_expect(ra_fixture: &str, expect: Expect) {
+    pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) {
        let (analysis, file_id) = fixture::file(ra_fixture);
        let diagnostics = analysis
            .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id)
@@ -384,374 +397,6 @@ mod tests {
    }
    #[test]
-    fn test_wrap_return_type_option() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::option::Option::{self, Some, None};
-fn div(x: i32, y: i32) -> Option<i32> {
-    if y == 0 {
-        return None;
-    }
-    x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::option::Option::{self, Some, None};
-fn div(x: i32, y: i32) -> Option<i32> {
-    if y == 0 {
-        return None;
-    }
-    Some(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn div(x: i32, y: i32) -> Result<i32, ()> {
-    if y == 0 {
-        return Err(());
-    }
-    x / y$0
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-fn div(x: i32, y: i32) -> Result<i32, ()> {
-    if y == 0 {
-        return Err(());
-    }
-    Ok(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_handles_generic_functions() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn div<T>(x: T) -> Result<T, i32> {
-    if x == 0 {
-        return Err(7);
-    }
-    $0x
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-fn div<T>(x: T) -> Result<T, i32> {
-    if x == 0 {
-        return Err(7);
-    }
-    Ok(x)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_handles_type_aliases() {
-        check_fix(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-type MyResult<T> = Result<T, ()>;
-fn div(x: i32, y: i32) -> MyResult<i32> {
-    if y == 0 {
-        return Err(());
-    }
-    x $0/ y
-}
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-            r#"
-use core::result::Result::{self, Ok, Err};
-type MyResult<T> = Result<T, ()>;
-fn div(x: i32, y: i32) -> MyResult<i32> {
-    if y == 0 {
-        return Err(());
-    }
-    Ok(x / y)
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
-        check_no_diagnostics(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-fn foo() -> Result<(), i32> { 0 }
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() {
-        check_no_diagnostics(
-            r#"
-//- /main.rs crate:main deps:core
-use core::result::Result::{self, Ok, Err};
-enum SomeOtherEnum { Ok(i32), Err(String) }
-fn foo() -> SomeOtherEnum { 0 }
-//- /core/lib.rs crate:core
-pub mod result {
-    pub enum Result<T, E> { Ok(T), Err(E) }
-}
-pub mod option {
-    pub enum Option<T> { Some(T), None }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_empty() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct {$0};
-}
-"#,
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct { one: (), two: ()};
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_self() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32 }
-impl TestStruct {
-    fn test_fn() { let s = Self {$0}; }
-}
-"#,
-            r#"
-struct TestStruct { one: i32 }
-impl TestStruct {
-    fn test_fn() { let s = Self { one: ()}; }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_enum() {
-        check_fix(
-            r#"
-enum Expr {
-    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-impl Expr {
-    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-        Expr::Bin {$0 }
-    }
-}
-"#,
-            r#"
-enum Expr {
-    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
-}
-impl Expr {
-    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-        Expr::Bin { lhs: (), rhs: () }
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_partial() {
-        check_fix(
-            r#"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct{ two: 2$0 };
-}
-"#,
-            r"
-struct TestStruct { one: i32, two: i64 }
-fn test_fn() {
-    let s = TestStruct{ two: 2, one: () };
-}
-",
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_raw_ident() {
-        check_fix(
-            r#"
-struct TestStruct { r#type: u8 }
-fn test_fn() {
-    TestStruct { $0 };
-}
-"#,
-            r"
-struct TestStruct { r#type: u8 }
-fn test_fn() {
-    TestStruct { r#type: ()  };
-}
-",
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_no_diagnostic() {
-        check_no_diagnostics(
-            r"
-            struct TestStruct { one: i32, two: i64 }
-            fn test_fn() {
-                let one = 1;
-                let s = TestStruct{ one, two: 2 };
-            }
-        ",
-        );
-    }
-    #[test]
-    fn test_fill_struct_fields_no_diagnostic_on_spread() {
-        check_no_diagnostics(
-            r"
-            struct TestStruct { one: i32, two: i64 }
-            fn test_fn() {
-                let one = 1;
-                let s = TestStruct{ ..a };
-            }
-        ",
-        );
-    }
-    #[test]
-    fn test_unresolved_module_diagnostic() {
-        check_expect(
-            r#"mod foo;"#,
-            expect![[r#"
-                [
-                    Diagnostic {
-                        message: "unresolved module",
-                        range: 0..8,
-                        severity: Error,
-                        fix: Some(
-                            Assist {
-                                id: AssistId(
-                                    "create_module",
-                                    QuickFix,
-                                ),
-                                label: "Create module",
-                                group: None,
-                                target: 0..8,
-                                source_change: Some(
-                                    SourceChange {
-                                        source_file_edits: {},
-                                        file_system_edits: [
-                                            CreateFile {
-                                                dst: AnchoredPathBuf {
-                                                    anchor: FileId(
-                                                        0,
-                                                    ),
-                                                    path: "foo.rs",
-                                                },
-                                                initial_contents: "",
-                                            },
-                                        ],
-                                        is_snippet: false,
-                                    },
-                                ),
-                            },
-                        ),
-                        unused: false,
-                        code: Some(
-                            DiagnosticCode(
-                                "unresolved-module",
-                            ),
-                        ),
-                    },
-                ]
-            "#]],
-        );
-    }
-    #[test]
    fn test_unresolved_macro_range() {
        check_expect(
            r#"foo::bar!(92);"#,
@@ -761,7 +406,7 @@ fn test_fn() {
                        message: "unresolved macro `foo::bar!`",
                        range: 5..8,
                        severity: Error,
-                        fix: None,
+                        fixes: None,
                        unused: false,
                        code: Some(
                            DiagnosticCode(
@@ -792,7 +437,7 @@ fn main() {
 pub struct Foo { pub a: i32, pub b: i32 }
 "#,
            r#"
-fn some(, b: ()) {}
+fn some(, b: () ) {}
 fn items() {}
 fn here() {}
@@ -891,53 +536,6 @@ mod a {
    }
    #[test]
-    fn test_add_field_from_usage() {
-        check_fix(
-            r"
-fn main() {
-    Foo { bar: 3, baz$0: false};
-}
-struct Foo {
-    bar: i32
-}
-",
-            r"
-fn main() {
-    Foo { bar: 3, baz: false};
-}
-struct Foo {
-    bar: i32,
-    baz: bool
-}
-",
-        )
-    }
-    #[test]
-    fn test_add_field_in_other_file_from_usage() {
-        check_fix(
-            r#"
-//- /main.rs
-mod foo;
-fn main() {
-    foo::Foo { bar: 3, $0baz: false};
-}
-//- /foo.rs
-struct Foo {
-    bar: i32
-}
-"#,
-            r#"
-struct Foo {
-    bar: i32,
-    pub(crate) baz: bool
-}
-"#,
-        )
-    }
-    #[test]
    fn test_disabled_diagnostics() {
        let mut config = DiagnosticsConfig::default();
        config.disabled.insert("unresolved-module".into());
@@ -955,134 +553,28 @@ struct Foo {
    }
    #[test]
-    fn test_rename_incorrect_case() {
-        check_fix(
-            r#"
-pub struct test_struct$0 { one: i32 }
-pub fn some_fn(val: test_struct) -> test_struct {
-    test_struct { one: val.one + 1 }
-}
-"#,
-            r#"
-pub struct TestStruct { one: i32 }
-pub fn some_fn(val: TestStruct) -> TestStruct {
-    TestStruct { one: val.one + 1 }
-}
-"#,
-        );
-        check_fix(
-            r#"
-pub fn some_fn(NonSnakeCase$0: u8) -> u8 {
-    NonSnakeCase
-}
-"#,
-            r#"
-pub fn some_fn(non_snake_case: u8) -> u8 {
-    non_snake_case
-}
-"#,
-        );
-        check_fix(
-            r#"
-pub fn SomeFn$0(val: u8) -> u8 {
-    if val != 0 { SomeFn(val - 1) } else { val }
-}
-"#,
-            r#"
-pub fn some_fn(val: u8) -> u8 {
-    if val != 0 { some_fn(val - 1) } else { val }
-}
-"#,
-        );
-        check_fix(
-            r#"
-fn some_fn() {
-    let whatAWeird_Formatting$0 = 10;
-    another_func(whatAWeird_Formatting);
-}
-"#,
-            r#"
-fn some_fn() {
-    let what_a_weird_formatting = 10;
-    another_func(what_a_weird_formatting);
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_uppercase_const_no_diagnostics() {
-        check_no_diagnostics(
-            r#"
-fn foo() {
-    const ANOTHER_ITEM$0: &str = "some_item";
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_rename_incorrect_case_struct_method() {
-        check_fix(
-            r#"
-pub struct TestStruct;
-impl TestStruct {
-    pub fn SomeFn$0() -> TestStruct {
-        TestStruct
-    }
-}
-"#,
-            r#"
-pub struct TestStruct;
-impl TestStruct {
-    pub fn some_fn() -> TestStruct {
-        TestStruct
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
-        let input = r#"fn FOO$0() {}"#;
-        let expected = r#"fn foo() {}"#;
-        let (analysis, file_position) = fixture::position(input);
-        let diagnostics = analysis
-            .diagnostics(
-                &DiagnosticsConfig::default(),
-                AssistResolveStrategy::All,
-                file_position.file_id,
-            )
-            .unwrap();
-        assert_eq!(diagnostics.len(), 1);
-        check_fix(input, expected);
-    }
-    #[test]
    fn unlinked_file_prepend_first_item() {
        cov_mark::check!(unlinked_file_prepend_before_first_item);
-        check_fix(
+        // Only tests the first one for `pub mod` since the rest are the same
+        check_fixes(
            r#"
 //- /main.rs
 fn f() {}
 //- /foo.rs
 $0
 "#,
-            r#"
+            vec![
+                r#"
 mod foo;
 fn f() {}
 "#,
+                r#"
+pub mod foo;
+fn f() {}
+"#,
+            ],
        );
    }
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
index 2b1787f9b..01bd2dba6 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -46,14 +46,13 @@ fn check_expr_field_shorthand(
        let field_range = record_field.syntax().text_range();
        acc.push(
-            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string()).with_fix(
+            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string())
-                Some(fix(
+                .with_fixes(Some(vec![fix(
                    "use_expr_field_shorthand",
                    "Use struct shorthand initialization",
                    SourceChange::from_text_edit(file_id, edit),
                    field_range,
-                )),
+                )])),
-            ),
        );
    }
 }
@@ -86,13 +85,13 @@ fn check_pat_field_shorthand(
        let edit = edit_builder.finish();
        let field_range = record_pat_field.syntax().text_range();
-        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fix(
+        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fixes(
-            Some(fix(
+            Some(vec![fix(
                "use_pat_field_shorthand",
                "Use struct field shorthand",
                SourceChange::from_text_edit(file_id, edit),
                field_range,
-            )),
+            )]),
        ));
    }
 }
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 15821500f..258ac6974 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -1,297 +1,31 @@
 //! Provides a way to attach fixes to the diagnostics.
 //! The same module also has all curret custom fixes for the diagnostics implemented.
-use hir::{
+mod change_case;
-    db::AstDatabase,
+mod create_field;
-    diagnostics::{
+mod fill_missing_fields;
-        Diagnostic, IncorrectCase, MissingFields, MissingOkOrSomeInTailExpr, NoSuchField,
+mod remove_semicolon;
-        RemoveThisSemicolon, ReplaceFilterMapNextWithFindMap, UnresolvedModule,
+mod replace_with_find_map;
-    },
+mod unresolved_module;
-    HasSource, HirDisplay, InFile, Semantics, VariantDef,
+mod wrap_tail_expr;
-};
+use hir::{diagnostics::Diagnostic, Semantics};
 use ide_assists::AssistResolveStrategy;
-use ide_db::{
+use ide_db::RootDatabase;
-    base_db::{AnchoredPathBuf, FileId},
-    source_change::{FileSystemEdit, SourceChange},
-    RootDatabase,
-};
-use syntax::{
-    algo,
-    ast::{self, edit::IndentLevel, make, ArgListOwner},
-    AstNode, TextRange,
-};
-use text_edit::TextEdit;
-use crate::{
+use crate::Assist;
-    diagnostics::{fix, unresolved_fix},
-    references::rename::rename_with_semantics,
-    Assist, FilePosition,
-};
-/// A [Diagnostic] that potentially has a fix available.
+/// A [Diagnostic] that potentially has some fixes available.
 ///
 /// [Diagnostic]: hir::diagnostics::Diagnostic
-pub(crate) trait DiagnosticWithFix: Diagnostic {
+pub(crate) trait DiagnosticWithFixes: Diagnostic {
    /// `resolve` determines if the diagnostic should fill in the `edit` field
    /// of the assist.
    ///
    /// If `resolve` is false, the edit will be computed later, on demand, and
    /// can be omitted.
-    fn fix(
+    fn fixes(
        &self,
        sema: &Semantics<RootDatabase>,
        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist>;
+    ) -> Option<Vec<Assist>>;
-}
-impl DiagnosticWithFix for UnresolvedModule {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let unresolved_module = self.decl.to_node(&root);
-        Some(fix(
-            "create_module",
-            "Create module",
-            FileSystemEdit::CreateFile {
-                dst: AnchoredPathBuf {
-                    anchor: self.file.original_file(sema.db),
-                    path: self.candidate.clone(),
-                },
-                initial_contents: "".to_string(),
-            }
-            .into(),
-            unresolved_module.syntax().text_range(),
-        ))
-    }
-}
-impl DiagnosticWithFix for NoSuchField {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        missing_record_expr_field_fix(
-            &sema,
-            self.file.original_file(sema.db),
-            &self.field.to_node(&root),
-        )
-    }
-}
-impl DiagnosticWithFix for MissingFields {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        // Note that although we could add a diagnostics to
-        // fill the missing tuple field, e.g :
-        // `struct A(usize);`
-        // `let a = A { 0: () }`
-        // but it is uncommon usage and it should not be encouraged.
-        if self.missed_fields.iter().any(|it| it.as_tuple_index().is_some()) {
-            return None;
-        }
-        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();
-        for f in self.missed_fields.iter() {
-            let field =
-                make::record_expr_field(make::name_ref(&f.to_string()), Some(make::expr_unit()));
-            new_field_list = new_field_list.append_field(&field);
-        }
-        let edit = {
-            let mut builder = TextEdit::builder();
-            algo::diff(&old_field_list.syntax(), &new_field_list.syntax())
-                .into_text_edit(&mut builder);
-            builder.finish()
-        };
-        Some(fix(
-            "fill_missing_fields",
-            "Fill struct fields",
-            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
-            sema.original_range(&field_list_parent.syntax()).range,
-        ))
-    }
-}
-impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let tail_expr = self.expr.to_node(&root);
-        let tail_expr_range = tail_expr.syntax().text_range();
-        let replacement = format!("{}({})", self.required, tail_expr.syntax());
-        let edit = TextEdit::replace(tail_expr_range, replacement);
-        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
-        Some(fix("wrap_tail_expr", name, source_change, tail_expr_range))
-    }
-}
-impl DiagnosticWithFix for RemoveThisSemicolon {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let semicolon = self
-            .expr
-            .to_node(&root)
-            .syntax()
-            .parent()
-            .and_then(ast::ExprStmt::cast)
-            .and_then(|expr| expr.semicolon_token())?
-            .text_range();
-        let edit = TextEdit::delete(semicolon);
-        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(fix("remove_semicolon", "Remove this semicolon", source_change, semicolon))
-    }
-}
-impl DiagnosticWithFix for IncorrectCase {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let name_node = self.ident.to_node(&root);
-        let name_node = InFile::new(self.file, name_node.syntax());
-        let frange = name_node.original_file_range(sema.db);
-        let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
-        let label = format!("Rename to {}", self.suggested_text);
-        let mut res = unresolved_fix("change_case", &label, frange.range);
-        if resolve.should_resolve(&res.id) {
-            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
-            res.source_change = Some(source_change.ok().unwrap_or_default());
-        }
-        Some(res)
-    }
-}
-impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap {
-    fn fix(
-        &self,
-        sema: &Semantics<RootDatabase>,
-        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
-        let root = sema.db.parse_or_expand(self.file)?;
-        let next_expr = self.next_expr.to_node(&root);
-        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
-        let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?;
-        let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range();
-        let filter_map_args = filter_map_call.arg_list()?;
-        let range_to_replace =
-            TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end());
-        let replacement = format!("find_map{}", filter_map_args.syntax().text());
-        let trigger_range = next_expr.syntax().text_range();
-        let edit = TextEdit::replace(range_to_replace, replacement);
-        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-        Some(fix(
-            "replace_with_find_map",
-            "Replace filter_map(..).next() with find_map()",
-            source_change,
-            trigger_range,
-        ))
-    }
-}
-fn missing_record_expr_field_fix(
-    sema: &Semantics<RootDatabase>,
-    usage_file_id: FileId,
-    record_expr_field: &ast::RecordExprField,
-) -> Option<Assist> {
-    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
-    let def_id = sema.resolve_variant(record_lit)?;
-    let module;
-    let def_file_id;
-    let record_fields = match def_id {
-        VariantDef::Struct(s) => {
-            module = s.module(sema.db);
-            let source = s.source(sema.db)?;
-            def_file_id = source.file_id;
-            let fields = source.value.field_list()?;
-            record_field_list(fields)?
-        }
-        VariantDef::Union(u) => {
-            module = u.module(sema.db);
-            let source = u.source(sema.db)?;
-            def_file_id = source.file_id;
-            source.value.record_field_list()?
-        }
-        VariantDef::Variant(e) => {
-            module = e.module(sema.db);
-            let source = e.source(sema.db)?;
-            def_file_id = source.file_id;
-            let fields = source.value.field_list()?;
-            record_field_list(fields)?
-        }
-    };
-    let def_file_id = def_file_id.original_file(sema.db);
-    let new_field_type = sema.type_of_expr(&record_expr_field.expr()?)?;
-    if new_field_type.is_unknown() {
-        return None;
-    }
-    let new_field = make::record_field(
-        None,
-        make::name(&record_expr_field.field_name()?.text()),
-        make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
-    );
-    let last_field = record_fields.fields().last()?;
-    let last_field_syntax = last_field.syntax();
-    let indent = IndentLevel::from_node(last_field_syntax);
-    let mut new_field = new_field.to_string();
-    if usage_file_id != def_file_id {
-        new_field = format!("pub(crate) {}", new_field);
-    }
-    new_field = format!("\n{}{}", indent, new_field);
-    let needs_comma = !last_field_syntax.to_string().ends_with(',');
-    if needs_comma {
-        new_field = format!(",{}", new_field);
-    }
-    let source_change = SourceChange::from_text_edit(
-        def_file_id,
-        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
-    );
-    return Some(fix(
-        "create_field",
-        "Create field",
-        source_change,
-        record_expr_field.syntax().text_range(),
-    ));
-    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
-        match field_def_list {
-            ast::FieldList::RecordFieldList(it) => Some(it),
-            ast::FieldList::TupleFieldList(_) => None,
-        }
-    }
 }
diff --git a/crates/ide/src/diagnostics/fixes/change_case.rs b/crates/ide/src/diagnostics/fixes/change_case.rs
new file mode 100644
index 000000000..42be3375f
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/change_case.rs
@@ -0,0 +1,155 @@
+use hir::{db::AstDatabase, diagnostics::IncorrectCase, InFile, Semantics};
+use ide_assists::{Assist, AssistResolveStrategy};
+use ide_db::{base_db::FilePosition, RootDatabase};
+use syntax::AstNode;
+use crate::{
+    diagnostics::{unresolved_fix, DiagnosticWithFixes},
+    references::rename::rename_with_semantics,
+};
+impl DiagnosticWithFixes for IncorrectCase {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let name_node = self.ident.to_node(&root);
+        let name_node = InFile::new(self.file, name_node.syntax());
+        let frange = name_node.original_file_range(sema.db);
+        let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
+        let label = format!("Rename to {}", self.suggested_text);
+        let mut res = unresolved_fix("change_case", &label, frange.range);
+        if resolve.should_resolve(&res.id) {
+            let source_change = rename_with_semantics(sema, file_position, &self.suggested_text);
+            res.source_change = Some(source_change.ok().unwrap_or_default());
+        }
+        Some(vec![res])
+    }
+}
+#[cfg(test)]
+mod change_case {
+    use crate::{
+        diagnostics::tests::{check_fix, check_no_diagnostics},
+        fixture, AssistResolveStrategy, DiagnosticsConfig,
+    };
+    #[test]
+    fn test_rename_incorrect_case() {
+        check_fix(
+            r#"
+pub struct test_struct$0 { one: i32 }
+pub fn some_fn(val: test_struct) -> test_struct {
+    test_struct { one: val.one + 1 }
+}
+"#,
+            r#"
+pub struct TestStruct { one: i32 }
+pub fn some_fn(val: TestStruct) -> TestStruct {
+    TestStruct { one: val.one + 1 }
+}
+"#,
+        );
+        check_fix(
+            r#"
+pub fn some_fn(NonSnakeCase$0: u8) -> u8 {
+    NonSnakeCase
+}
+"#,
+            r#"
+pub fn some_fn(non_snake_case: u8) -> u8 {
+    non_snake_case
+}
+"#,
+        );
+        check_fix(
+            r#"
+pub fn SomeFn$0(val: u8) -> u8 {
+    if val != 0 { SomeFn(val - 1) } else { val }
+}
+"#,
+            r#"
+pub fn some_fn(val: u8) -> u8 {
+    if val != 0 { some_fn(val - 1) } else { val }
+}
+"#,
+        );
+        check_fix(
+            r#"
+fn some_fn() {
+    let whatAWeird_Formatting$0 = 10;
+    another_func(whatAWeird_Formatting);
+}
+"#,
+            r#"
+fn some_fn() {
+    let what_a_weird_formatting = 10;
+    another_func(what_a_weird_formatting);
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_uppercase_const_no_diagnostics() {
+        check_no_diagnostics(
+            r#"
+fn foo() {
+    const ANOTHER_ITEM$0: &str = "some_item";
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_rename_incorrect_case_struct_method() {
+        check_fix(
+            r#"
+pub struct TestStruct;
+impl TestStruct {
+    pub fn SomeFn$0() -> TestStruct {
+        TestStruct
+    }
+}
+"#,
+            r#"
+pub struct TestStruct;
+impl TestStruct {
+    pub fn some_fn() -> TestStruct {
+        TestStruct
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
+        let input = r#"fn FOO$0() {}"#;
+        let expected = r#"fn foo() {}"#;
+        let (analysis, file_position) = fixture::position(input);
+        let diagnostics = analysis
+            .diagnostics(
+                &DiagnosticsConfig::default(),
+                AssistResolveStrategy::All,
+                file_position.file_id,
+            )
+            .unwrap();
+        assert_eq!(diagnostics.len(), 1);
+        check_fix(input, expected);
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/create_field.rs b/crates/ide/src/diagnostics/fixes/create_field.rs
new file mode 100644
index 000000000..a5f457dce
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/create_field.rs
@@ -0,0 +1,156 @@
+use hir::{db::AstDatabase, diagnostics::NoSuchField, HasSource, HirDisplay, Semantics};
+use ide_db::{base_db::FileId, source_change::SourceChange, RootDatabase};
+use syntax::{
+    ast::{self, edit::IndentLevel, make},
+    AstNode,
+};
+use text_edit::TextEdit;
+use crate::{
+    diagnostics::{fix, DiagnosticWithFixes},
+    Assist, AssistResolveStrategy,
+};
+impl DiagnosticWithFixes for NoSuchField {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        missing_record_expr_field_fixes(
+            &sema,
+            self.file.original_file(sema.db),
+            &self.field.to_node(&root),
+        )
+    }
+}
+fn missing_record_expr_field_fixes(
+    sema: &Semantics<RootDatabase>,
+    usage_file_id: FileId,
+    record_expr_field: &ast::RecordExprField,
+) -> Option<Vec<Assist>> {
+    let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?;
+    let def_id = sema.resolve_variant(record_lit)?;
+    let module;
+    let def_file_id;
+    let record_fields = match def_id {
+        hir::VariantDef::Struct(s) => {
+            module = s.module(sema.db);
+            let source = s.source(sema.db)?;
+            def_file_id = source.file_id;
+            let fields = source.value.field_list()?;
+            record_field_list(fields)?
+        }
+        hir::VariantDef::Union(u) => {
+            module = u.module(sema.db);
+            let source = u.source(sema.db)?;
+            def_file_id = source.file_id;
+            source.value.record_field_list()?
+        }
+        hir::VariantDef::Variant(e) => {
+            module = e.module(sema.db);
+            let source = e.source(sema.db)?;
+            def_file_id = source.file_id;
+            let fields = source.value.field_list()?;
+            record_field_list(fields)?
+        }
+    };
+    let def_file_id = def_file_id.original_file(sema.db);
+    let new_field_type = sema.type_of_expr(&record_expr_field.expr()?)?;
+    if new_field_type.is_unknown() {
+        return None;
+    }
+    let new_field = make::record_field(
+        None,
+        make::name(&record_expr_field.field_name()?.text()),
+        make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
+    );
+    let last_field = record_fields.fields().last()?;
+    let last_field_syntax = last_field.syntax();
+    let indent = IndentLevel::from_node(last_field_syntax);
+    let mut new_field = new_field.to_string();
+    if usage_file_id != def_file_id {
+        new_field = format!("pub(crate) {}", new_field);
+    }
+    new_field = format!("\n{}{}", indent, new_field);
+    let needs_comma = !last_field_syntax.to_string().ends_with(',');
+    if needs_comma {
+        new_field = format!(",{}", new_field);
+    }
+    let source_change = SourceChange::from_text_edit(
+        def_file_id,
+        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
+    );
+    return Some(vec![fix(
+        "create_field",
+        "Create field",
+        source_change,
+        record_expr_field.syntax().text_range(),
+    )]);
+    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
+        match field_def_list {
+            ast::FieldList::RecordFieldList(it) => Some(it),
+            ast::FieldList::TupleFieldList(_) => None,
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_fix;
+    #[test]
+    fn test_add_field_from_usage() {
+        check_fix(
+            r"
+fn main() {
+    Foo { bar: 3, baz$0: false};
+}
+struct Foo {
+    bar: i32
+}
+",
+            r"
+fn main() {
+    Foo { bar: 3, baz: false};
+}
+struct Foo {
+    bar: i32,
+    baz: bool
+}
+",
+        )
+    }
+    #[test]
+    fn test_add_field_in_other_file_from_usage() {
+        check_fix(
+            r#"
+//- /main.rs
+mod foo;
+fn main() {
+    foo::Foo { bar: 3, $0baz: false};
+}
+//- /foo.rs
+struct Foo {
+    bar: i32
+}
+"#,
+            r#"
+struct Foo {
+    bar: i32,
+    pub(crate) baz: bool
+}
+"#,
+        )
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs b/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs
new file mode 100644
index 000000000..b5dd64c08
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/fill_missing_fields.rs
@@ -0,0 +1,217 @@
+use hir::{db::AstDatabase, diagnostics::MissingFields, Semantics};
+use ide_assists::AssistResolveStrategy;
+use ide_db::{source_change::SourceChange, RootDatabase};
+use syntax::{algo, ast::make, AstNode};
+use text_edit::TextEdit;
+use crate::{
+    diagnostics::{fix, fixes::DiagnosticWithFixes},
+    Assist,
+};
+impl DiagnosticWithFixes for MissingFields {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        // Note that although we could add a diagnostics to
+        // fill the missing tuple field, e.g :
+        // `struct A(usize);`
+        // `let a = A { 0: () }`
+        // but it is uncommon usage and it should not be encouraged.
+        if self.missed_fields.iter().any(|it| it.as_tuple_index().is_some()) {
+            return None;
+        }
+        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 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()))
+                    .clone_for_update();
+            new_field_list.add_field(field);
+        }
+        let edit = {
+            let mut builder = TextEdit::builder();
+            algo::diff(&old_field_list.syntax(), &new_field_list.syntax())
+                .into_text_edit(&mut builder);
+            builder.finish()
+        };
+        Some(vec![fix(
+            "fill_missing_fields",
+            "Fill struct fields",
+            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
+            sema.original_range(&field_list_parent.syntax()).range,
+        )])
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
+    #[test]
+    fn test_fill_struct_fields_empty() {
+        check_fix(
+            r#"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let s = TestStruct {$0};
+}
+"#,
+            r#"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let s = TestStruct { one: (), two: () };
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_self() {
+        check_fix(
+            r#"
+struct TestStruct { one: i32 }
+impl TestStruct {
+    fn test_fn() { let s = Self {$0}; }
+}
+"#,
+            r#"
+struct TestStruct { one: i32 }
+impl TestStruct {
+    fn test_fn() { let s = Self { one: () }; }
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_enum() {
+        check_fix(
+            r#"
+enum Expr {
+    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+}
+impl Expr {
+    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+        Expr::Bin {$0 }
+    }
+}
+"#,
+            r#"
+enum Expr {
+    Bin { lhs: Box<Expr>, rhs: Box<Expr> }
+}
+impl Expr {
+    fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
+        Expr::Bin { lhs: (), rhs: () }
+    }
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_partial() {
+        check_fix(
+            r#"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let s = TestStruct{ two: 2$0 };
+}
+"#,
+            r"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let s = TestStruct{ two: 2, one: () };
+}
+",
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_raw_ident() {
+        check_fix(
+            r#"
+struct TestStruct { r#type: u8 }
+fn test_fn() {
+    TestStruct { $0 };
+}
+"#,
+            r"
+struct TestStruct { r#type: u8 }
+fn test_fn() {
+    TestStruct { r#type: ()  };
+}
+",
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_no_diagnostic() {
+        check_no_diagnostics(
+            r#"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let one = 1;
+    let s = TestStruct{ one, two: 2 };
+}
+        "#,
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_no_diagnostic_on_spread() {
+        check_no_diagnostics(
+            r#"
+struct TestStruct { one: i32, two: i64 }
+fn test_fn() {
+    let one = 1;
+    let s = TestStruct{ ..a };
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_fill_struct_fields_blank_line() {
+        check_fix(
+            r#"
+struct S { a: (), b: () }
+fn f() {
+    S {
+        $0
+    };
+}
+"#,
+            r#"
+struct S { a: (), b: () }
+fn f() {
+    S {
+        a: (),
+        b: (),
+    };
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/remove_semicolon.rs b/crates/ide/src/diagnostics/fixes/remove_semicolon.rs
new file mode 100644
index 000000000..f1724d479
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/remove_semicolon.rs
@@ -0,0 +1,41 @@
+use hir::{db::AstDatabase, diagnostics::RemoveThisSemicolon, Semantics};
+use ide_assists::{Assist, AssistResolveStrategy};
+use ide_db::{source_change::SourceChange, RootDatabase};
+use syntax::{ast, AstNode};
+use text_edit::TextEdit;
+use crate::diagnostics::{fix, DiagnosticWithFixes};
+impl DiagnosticWithFixes for RemoveThisSemicolon {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let semicolon = self
+            .expr
+            .to_node(&root)
+            .syntax()
+            .parent()
+            .and_then(ast::ExprStmt::cast)
+            .and_then(|expr| expr.semicolon_token())?
+            .text_range();
+        let edit = TextEdit::delete(semicolon);
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
+        Some(vec![fix("remove_semicolon", "Remove this semicolon", source_change, semicolon)])
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_fix;
+    #[test]
+    fn remove_semicolon() {
+        check_fix(r#"fn f() -> i32 { 92$0; }"#, r#"fn f() -> i32 { 92 }"#);
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs b/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs
new file mode 100644
index 000000000..444bf563b
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs
@@ -0,0 +1,84 @@
+use hir::{db::AstDatabase, diagnostics::ReplaceFilterMapNextWithFindMap, Semantics};
+use ide_assists::{Assist, AssistResolveStrategy};
+use ide_db::{source_change::SourceChange, RootDatabase};
+use syntax::{
+    ast::{self, ArgListOwner},
+    AstNode, TextRange,
+};
+use text_edit::TextEdit;
+use crate::diagnostics::{fix, DiagnosticWithFixes};
+impl DiagnosticWithFixes for ReplaceFilterMapNextWithFindMap {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let next_expr = self.next_expr.to_node(&root);
+        let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?;
+        let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?;
+        let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range();
+        let filter_map_args = filter_map_call.arg_list()?;
+        let range_to_replace =
+            TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end());
+        let replacement = format!("find_map{}", filter_map_args.syntax().text());
+        let trigger_range = next_expr.syntax().text_range();
+        let edit = TextEdit::replace(range_to_replace, replacement);
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
+        Some(vec![fix(
+            "replace_with_find_map",
+            "Replace filter_map(..).next() with find_map()",
+            source_change,
+            trigger_range,
+        )])
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::check_fix;
+    #[test]
+    fn replace_with_wind_map() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::iter::Iterator;
+use core::option::Option::{self, Some, None};
+fn foo() {
+    let m = [1, 2, 3].iter().$0filter_map(|x| if *x == 2 { Some (4) } else { None }).next();
+}
+//- /core/lib.rs crate:core
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+pub mod iter {
+    pub trait Iterator {
+        type Item;
+        fn filter_map<B, F>(self, f: F) -> FilterMap where F: FnMut(Self::Item) -> Option<B> { FilterMap }
+        fn next(&mut self) -> Option<Self::Item>;
+    }
+    pub struct FilterMap {}
+    impl Iterator for FilterMap {
+        type Item = i32;
+        fn next(&mut self) -> i32 { 7 }
+    }
+}
+"#,
+            r#"
+use core::iter::Iterator;
+use core::option::Option::{self, Some, None};
+fn foo() {
+    let m = [1, 2, 3].iter().find_map(|x| if *x == 2 { Some (4) } else { None });
+}
+"#,
+        )
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/unresolved_module.rs b/crates/ide/src/diagnostics/fixes/unresolved_module.rs
new file mode 100644
index 000000000..b3d0283bb
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/unresolved_module.rs
@@ -0,0 +1,89 @@
+use hir::{db::AstDatabase, diagnostics::UnresolvedModule, Semantics};
+use ide_assists::{Assist, AssistResolveStrategy};
+use ide_db::{base_db::AnchoredPathBuf, source_change::FileSystemEdit, RootDatabase};
+use syntax::AstNode;
+use crate::diagnostics::{fix, DiagnosticWithFixes};
+impl DiagnosticWithFixes for UnresolvedModule {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let unresolved_module = self.decl.to_node(&root);
+        Some(vec![fix(
+            "create_module",
+            "Create module",
+            FileSystemEdit::CreateFile {
+                dst: AnchoredPathBuf {
+                    anchor: self.file.original_file(sema.db),
+                    path: self.candidate.clone(),
+                },
+                initial_contents: "".to_string(),
+            }
+            .into(),
+            unresolved_module.syntax().text_range(),
+        )])
+    }
+}
+#[cfg(test)]
+mod tests {
+    use expect_test::expect;
+    use crate::diagnostics::tests::check_expect;
+    #[test]
+    fn test_unresolved_module_diagnostic() {
+        check_expect(
+            r#"mod foo;"#,
+            expect![[r#"
+                [
+                    Diagnostic {
+                        message: "unresolved module",
+                        range: 0..8,
+                        severity: Error,
+                        fixes: Some(
+                            [
+                                Assist {
+                                    id: AssistId(
+                                        "create_module",
+                                        QuickFix,
+                                    ),
+                                    label: "Create module",
+                                    group: None,
+                                    target: 0..8,
+                                    source_change: Some(
+                                        SourceChange {
+                                            source_file_edits: {},
+                                            file_system_edits: [
+                                                CreateFile {
+                                                    dst: AnchoredPathBuf {
+                                                        anchor: FileId(
+                                                            0,
+                                                        ),
+                                                        path: "foo.rs",
+                                                    },
+                                                    initial_contents: "",
+                                                },
+                                            ],
+                                            is_snippet: false,
+                                        },
+                                    ),
+                                },
+                            ],
+                        ),
+                        unused: false,
+                        code: Some(
+                            DiagnosticCode(
+                                "unresolved-module",
+                            ),
+                        ),
+                    },
+                ]
+            "#]],
+        );
+    }
+}
diff --git a/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs b/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs
new file mode 100644
index 000000000..715a403b9
--- /dev/null
+++ b/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs
@@ -0,0 +1,211 @@
+use hir::{db::AstDatabase, diagnostics::MissingOkOrSomeInTailExpr, Semantics};
+use ide_assists::{Assist, AssistResolveStrategy};
+use ide_db::{source_change::SourceChange, RootDatabase};
+use syntax::AstNode;
+use text_edit::TextEdit;
+use crate::diagnostics::{fix, DiagnosticWithFixes};
+impl DiagnosticWithFixes for MissingOkOrSomeInTailExpr {
+    fn fixes(
+        &self,
+        sema: &Semantics<RootDatabase>,
+        _resolve: &AssistResolveStrategy,
+    ) -> Option<Vec<Assist>> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let tail_expr = self.expr.to_node(&root);
+        let tail_expr_range = tail_expr.syntax().text_range();
+        let replacement = format!("{}({})", self.required, tail_expr.syntax());
+        let edit = TextEdit::replace(tail_expr_range, replacement);
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
+        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
+        Some(vec![fix("wrap_tail_expr", name, source_change, tail_expr_range)])
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
+    #[test]
+    fn test_wrap_return_type_option() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::option::Option::{self, Some, None};
+fn div(x: i32, y: i32) -> Option<i32> {
+    if y == 0 {
+        return None;
+    }
+    x / y$0
+}
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+            r#"
+use core::option::Option::{self, Some, None};
+fn div(x: i32, y: i32) -> Option<i32> {
+    if y == 0 {
+        return None;
+    }
+    Some(x / y)
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_wrap_return_type() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::result::Result::{self, Ok, Err};
+fn div(x: i32, y: i32) -> Result<i32, ()> {
+    if y == 0 {
+        return Err(());
+    }
+    x / y$0
+}
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
+fn div(x: i32, y: i32) -> Result<i32, ()> {
+    if y == 0 {
+        return Err(());
+    }
+    Ok(x / y)
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_wrap_return_type_handles_generic_functions() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::result::Result::{self, Ok, Err};
+fn div<T>(x: T) -> Result<T, i32> {
+    if x == 0 {
+        return Err(7);
+    }
+    $0x
+}
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
+fn div<T>(x: T) -> Result<T, i32> {
+    if x == 0 {
+        return Err(7);
+    }
+    Ok(x)
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_wrap_return_type_handles_type_aliases() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::result::Result::{self, Ok, Err};
+type MyResult<T> = Result<T, ()>;
+fn div(x: i32, y: i32) -> MyResult<i32> {
+    if y == 0 {
+        return Err(());
+    }
+    x $0/ y
+}
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+            r#"
+use core::result::Result::{self, Ok, Err};
+type MyResult<T> = Result<T, ()>;
+fn div(x: i32, y: i32) -> MyResult<i32> {
+    if y == 0 {
+        return Err(());
+    }
+    Ok(x / y)
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
+        check_no_diagnostics(
+            r#"
+//- /main.rs crate:main deps:core
+use core::result::Result::{self, Ok, Err};
+fn foo() -> Result<(), i32> { 0 }
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() {
+        check_no_diagnostics(
+            r#"
+//- /main.rs crate:main deps:core
+use core::result::Result::{self, Ok, Err};
+enum SomeOtherEnum { Ok(i32), Err(String) }
+fn foo() -> SomeOtherEnum { 0 }
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
index 93fd25dea..51fe0f360 100644
--- a/crates/ide/src/diagnostics/unlinked_file.rs
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -18,7 +18,7 @@ use syntax::{
 use text_edit::TextEdit;
 use crate::{
-    diagnostics::{fix, fixes::DiagnosticWithFix},
+    diagnostics::{fix, fixes::DiagnosticWithFixes},
    Assist,
 };
@@ -50,13 +50,13 @@ impl Diagnostic for UnlinkedFile {
    }
 }
-impl DiagnosticWithFix for UnlinkedFile {
+impl DiagnosticWithFixes for UnlinkedFile {
-    fn fix(
+    fn fixes(
        &self,
        sema: &hir::Semantics<RootDatabase>,
        _resolve: &AssistResolveStrategy,
-    ) -> Option<Assist> {
+    ) -> Option<Vec<Assist>> {
-        // If there's an existing module that could add a `mod` item to include the unlinked file,
+        // If there's an existing module that could add `mod` or `pub mod` items to include the unlinked file,
        // suggest that as a fix.
        let source_root = sema.db.source_root(sema.db.file_source_root(self.file_id));
@@ -90,7 +90,7 @@ impl DiagnosticWithFix for UnlinkedFile {
                        }
                        if module.origin.file_id() == Some(*parent_id) {
-                            return make_fix(sema.db, *parent_id, module_name, self.file_id);
+                            return make_fixes(sema.db, *parent_id, module_name, self.file_id);
                        }
                    }
                }
@@ -101,20 +101,23 @@ impl DiagnosticWithFix for UnlinkedFile {
    }
 }
-fn make_fix(
+fn make_fixes(
    db: &RootDatabase,
    parent_file_id: FileId,
    new_mod_name: &str,
    added_file_id: FileId,
-) -> Option<Assist> {
+) -> Option<Vec<Assist>> {
    fn is_outline_mod(item: &ast::Item) -> bool {
        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
    }
    let mod_decl = format!("mod {};", new_mod_name);
+    let pub_mod_decl = format!("pub mod {};", new_mod_name);
    let ast: ast::SourceFile = db.parse(parent_file_id).tree();
-    let mut builder = TextEdit::builder();
+    let mut mod_decl_builder = TextEdit::builder();
+    let mut pub_mod_decl_builder = TextEdit::builder();
    // If there's an existing `mod m;` statement matching the new one, don't emit a fix (it's
    // probably `#[cfg]`d out).
@@ -138,30 +141,43 @@ fn make_fix(
    {
        Some(last) => {
            cov_mark::hit!(unlinked_file_append_to_existing_mods);
-            builder.insert(last.syntax().text_range().end(), format!("\n{}", mod_decl));
+            let offset = last.syntax().text_range().end();
+            mod_decl_builder.insert(offset, format!("\n{}", mod_decl));
+            pub_mod_decl_builder.insert(offset, format!("\n{}", pub_mod_decl));
        }
        None => {
            // Prepend before the first item in the file.
            match ast.items().next() {
                Some(item) => {
                    cov_mark::hit!(unlinked_file_prepend_before_first_item);
-                    builder.insert(item.syntax().text_range().start(), format!("{}\n\n", mod_decl));
+                    let offset = item.syntax().text_range().start();
+                    mod_decl_builder.insert(offset, format!("{}\n\n", mod_decl));
+                    pub_mod_decl_builder.insert(offset, format!("{}\n\n", pub_mod_decl));
                }
                None => {
                    // No items in the file, so just append at the end.
                    cov_mark::hit!(unlinked_file_empty_file);
-                    builder.insert(ast.syntax().text_range().end(), format!("{}\n", mod_decl));
+                    let offset = ast.syntax().text_range().end();
+                    mod_decl_builder.insert(offset, format!("{}\n", mod_decl));
+                    pub_mod_decl_builder.insert(offset, format!("{}\n", pub_mod_decl));
                }
            }
        }
    }
-    let edit = builder.finish();
    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
-    Some(fix(
+    Some(vec![
-        "add_mod_declaration",
+        fix(
-        &format!("Insert `{}`", mod_decl),
+            "add_mod_declaration",
-        SourceChange::from_text_edit(parent_file_id, edit),
+            &format!("Insert `{}`", mod_decl),
-        trigger_range,
+            SourceChange::from_text_edit(parent_file_id, mod_decl_builder.finish()),
-    ))
+            trigger_range,
+        ),
+        fix(
+            "add_pub_mod_declaration",
+            &format!("Insert `{}`", pub_mod_decl),
+            SourceChange::from_text_edit(parent_file_id, pub_mod_decl_builder.finish()),
+            trigger_range,
+        ),
+    ])
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index cb5a8e19a..320694a17 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -29,7 +29,8 @@ pub(crate) type DocumentationLink = String;
 /// Rewrite documentation links in markdown to point to an online host (e.g. docs.rs)
 pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition) -> String {
    let mut cb = broken_link_clone_cb;
-    let doc = Parser::new_with_broken_link_callback(markdown, Options::empty(), Some(&mut cb));
+    let doc =
+        Parser::new_with_broken_link_callback(markdown, Options::ENABLE_TASKLISTS, Some(&mut cb));
    let doc = map_links(doc, |target, title: &str| {
        // This check is imperfect, there's some overlap between valid intra-doc links
@@ -64,8 +65,7 @@ pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Defi
 pub(crate) fn remove_links(markdown: &str) -> String {
    let mut drop_link = false;
-    let mut opts = Options::empty();
+    let opts = Options::ENABLE_TASKLISTS | Options::ENABLE_FOOTNOTES;
-    opts.insert(Options::ENABLE_FOOTNOTES);
    let mut cb = |_: BrokenLink| {
        let empty = InlineStr::try_from("").unwrap();
@@ -123,7 +123,7 @@ pub(crate) fn extract_definitions_from_markdown(
 ) -> Vec<(TextRange, String, Option<hir::Namespace>)> {
    Parser::new_with_broken_link_callback(
        markdown,
-        Options::empty(),
+        Options::ENABLE_TASKLISTS,
        Some(&mut broken_link_clone_cb),
    )
    .into_offset_iter()
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},