127 files changed, 2456 insertions, 805 deletions
diff --git a/crates/assists/Cargo.toml b/crates/assists/Cargo.toml
index 3fd8327d6..ed8ad666f 100644
--- a/crates/assists/Cargo.toml
+++ b/crates/assists/Cargo.toml
@@ -11,7 +11,7 @@ doctest = false
 [dependencies]
 rustc-hash = "1.1.0"
-itertools = "0.9.0"
+itertools = "0.10.0"
 either = "1.6.1"
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index 69499ea32..4f59d39a9 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -4,10 +4,10 @@ use std::mem;
 use algo::find_covering_element;
 use hir::Semantics;
-use ide_db::base_db::{FileId, FileRange};
+use ide_db::base_db::{AnchoredPathBuf, FileId, FileRange};
 use ide_db::{
    label::Label,
-    source_change::{SourceChange, SourceFileEdit},
+    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
    RootDatabase,
 };
 use syntax::{
@@ -19,7 +19,7 @@ use text_edit::{TextEdit, TextEditBuilder};
 use crate::{
    assist_config::{AssistConfig, SnippetCap},
-    Assist, AssistId, AssistKind, GroupLabel, ResolvedAssist,
+    Assist, AssistId, AssistKind, GroupLabel,
 };
 /// `AssistContext` allows to apply an assist or check if it could be applied.
@@ -105,46 +105,23 @@ impl<'a> AssistContext<'a> {
 pub(crate) struct Assists {
    resolve: bool,
    file: FileId,
-    buf: Vec<(Assist, Option<SourceChange>)>,
+    buf: Vec<Assist>,
    allowed: Option<Vec<AssistKind>>,
 }
 impl Assists {
-    pub(crate) fn new_resolved(ctx: &AssistContext) -> Assists {
+    pub(crate) fn new(ctx: &AssistContext, resolve: bool) -> Assists {
        Assists {
-            resolve: true,
+            resolve,
            file: ctx.frange.file_id,
            buf: Vec::new(),
            allowed: ctx.config.allowed.clone(),
        }
    }
-    pub(crate) fn new_unresolved(ctx: &AssistContext) -> Assists {
+    pub(crate) fn finish(mut self) -> Vec<Assist> {
-        Assists {
+        self.buf.sort_by_key(|assist| assist.target.len());
-            resolve: false,
+        self.buf
-            file: ctx.frange.file_id,
-            buf: Vec::new(),
-            allowed: ctx.config.allowed.clone(),
-        }
-    }
-    pub(crate) fn finish_unresolved(self) -> Vec<Assist> {
-        assert!(!self.resolve);
-        self.finish()
-            .into_iter()
-            .map(|(label, edit)| {
-                assert!(edit.is_none());
-                label
-            })
-            .collect()
-    }
-    pub(crate) fn finish_resolved(self) -> Vec<ResolvedAssist> {
-        assert!(self.resolve);
-        self.finish()
-            .into_iter()
-            .map(|(label, edit)| ResolvedAssist { assist: label, source_change: edit.unwrap() })
-            .collect()
    }
    pub(crate) fn add(
@@ -158,7 +135,7 @@ impl Assists {
            return None;
        }
        let label = Label::new(label.into());
-        let assist = Assist { id, label, group: None, target };
+        let assist = Assist { id, label, group: None, target, source_change: None };
        self.add_impl(assist, f)
    }
@@ -174,11 +151,11 @@ impl Assists {
            return None;
        }
        let label = Label::new(label.into());
-        let assist = Assist { id, label, group: Some(group.clone()), target };
+        let assist = Assist { id, label, group: Some(group.clone()), target, source_change: None };
        self.add_impl(assist, f)
    }
-    fn add_impl(&mut self, assist: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
+    fn add_impl(&mut self, mut assist: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
        let source_change = if self.resolve {
            let mut builder = AssistBuilder::new(self.file);
            f(&mut builder);
@@ -186,16 +163,12 @@ impl Assists {
        } else {
            None
        };
+        assist.source_change = source_change.clone();
-        self.buf.push((assist, source_change));
+        self.buf.push(assist);
        Some(())
    }
-    fn finish(mut self) -> Vec<(Assist, Option<SourceChange>)> {
-        self.buf.sort_by_key(|(label, _edit)| label.target.len());
-        self.buf
-    }
    fn is_allowed(&self, id: &AssistId) -> bool {
        match &self.allowed {
            Some(allowed) => allowed.iter().any(|kind| kind.contains(id.1)),
@@ -209,6 +182,7 @@ pub(crate) struct AssistBuilder {
    file_id: FileId,
    is_snippet: bool,
    source_file_edits: Vec<SourceFileEdit>,
+    file_system_edits: Vec<FileSystemEdit>,
 }
 impl AssistBuilder {
@@ -218,6 +192,7 @@ impl AssistBuilder {
            file_id,
            is_snippet: false,
            source_file_edits: Vec::default(),
+            file_system_edits: Vec::default(),
        }
    }
@@ -282,12 +257,17 @@ impl AssistBuilder {
            algo::diff(&node, &new).into_text_edit(&mut self.edit);
        }
    }
+    pub(crate) fn create_file(&mut self, dst: AnchoredPathBuf, content: impl Into<String>) {
+        let file_system_edit =
+            FileSystemEdit::CreateFile { dst: dst.clone(), initial_contents: content.into() };
+        self.file_system_edits.push(file_system_edit);
+    }
    fn finish(mut self) -> SourceChange {
        self.commit();
        SourceChange {
            source_file_edits: mem::take(&mut self.source_file_edits),
-            file_system_edits: Default::default(),
+            file_system_edits: mem::take(&mut self.file_system_edits),
            is_snippet: self.is_snippet,
        }
    }
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs
index e413505d3..7df05b841 100644
--- a/crates/assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/assists/src/handlers/add_missing_impl_members.rs
@@ -15,7 +15,7 @@ use crate::{
 //
 // ```
 // trait Trait<T> {
-//     Type X;
+//     type X;
 //     fn foo(&self) -> T;
 //     fn bar(&self) {}
 // }
@@ -27,14 +27,16 @@ use crate::{
 // ->
 // ```
 // trait Trait<T> {
-//     Type X;
+//     type X;
 //     fn foo(&self) -> T;
 //     fn bar(&self) {}
 // }
 //
 // impl Trait<u32> for () {
+//     $0type X;
+//
 //     fn foo(&self) -> u32 {
-//         ${0:todo!()}
+//         todo!()
 //     }
 // }
 // ```
@@ -54,13 +56,13 @@ pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) -
 //
 // ```
 // trait Trait {
-//     Type X;
+//     type X;
 //     fn foo(&self);
 //     fn bar(&self) {}
 // }
 //
 // impl Trait for () {
-//     Type X = ();
+//     type X = ();
 //     fn foo(&self) {}<|>
 //
 // }
@@ -68,13 +70,13 @@ pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) -
 // ->
 // ```
 // trait Trait {
-//     Type X;
+//     type X;
 //     fn foo(&self);
 //     fn bar(&self) {}
 // }
 //
 // impl Trait for () {
-//     Type X = ();
+//     type X = ();
 //     fn foo(&self) {}
 //
 //     $0fn bar(&self) {}
diff --git a/crates/assists/src/handlers/extract_module_to_file.rs b/crates/assists/src/handlers/extract_module_to_file.rs
new file mode 100644
index 000000000..50bf67ef7
--- /dev/null
+++ b/crates/assists/src/handlers/extract_module_to_file.rs
@@ -0,0 +1,133 @@
+use ast::edit::IndentLevel;
+use ide_db::base_db::AnchoredPathBuf;
+use syntax::{
+    ast::{self, edit::AstNodeEdit, NameOwner},
+    AstNode,
+};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: extract_module_to_file
+//
+// This assist extract module to file.
+//
+// ```
+// mod foo {<|>
+//     fn t() {}
+// }
+// ```
+// ->
+// ```
+// mod foo;
+// ```
+pub(crate) fn extract_module_to_file(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let module_ast = ctx.find_node_at_offset::<ast::Module>()?;
+    let module_name = module_ast.name()?;
+    let module_def = ctx.sema.to_def(&module_ast)?;
+    let parent_module = module_def.parent(ctx.db())?;
+    let module_items = module_ast.item_list()?;
+    let target = module_ast.syntax().text_range();
+    let anchor_file_id = ctx.frange.file_id;
+    acc.add(
+        AssistId("extract_module_to_file", AssistKind::RefactorExtract),
+        "Extract module to file",
+        target,
+        |builder| {
+            let path = {
+                let dir = match parent_module.name(ctx.db()) {
+                    Some(name) if !parent_module.is_mod_rs(ctx.db()) => format!("{}/", name),
+                    _ => String::new(),
+                };
+                format!("./{}{}.rs", dir, module_name)
+            };
+            let contents = {
+                let items = module_items.dedent(IndentLevel(1)).to_string();
+                let mut items =
+                    items.trim_start_matches('{').trim_end_matches('}').trim().to_string();
+                if !items.is_empty() {
+                    items.push('\n');
+                }
+                items
+            };
+            builder.replace(target, format!("mod {};", module_name));
+            let dst = AnchoredPathBuf { anchor: anchor_file_id, path };
+            builder.create_file(dst, contents);
+        },
+    )
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::check_assist;
+    use super::*;
+    #[test]
+    fn extract_from_root() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+mod tests {<|>
+    #[test] fn t() {}
+}
+"#,
+            r#"
+//- /main.rs
+mod tests;
+//- /tests.rs
+#[test] fn t() {}
+"#,
+        );
+    }
+    #[test]
+    fn extract_from_submodule() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+//- /main.rs
+mod submod;
+//- /submod.rs
+mod inner<|> {
+    fn f() {}
+}
+fn g() {}
+"#,
+            r#"
+//- /submod.rs
+mod inner;
+fn g() {}
+//- /submod/inner.rs
+fn f() {}
+"#,
+        );
+    }
+    #[test]
+    fn extract_from_mod_rs() {
+        check_assist(
+            extract_module_to_file,
+            r#"
+//- /main.rs
+mod submodule;
+//- /submodule/mod.rs
+mod inner<|> {
+    fn f() {}
+}
+fn g() {}
+"#,
+            r#"
+//- /submodule/mod.rs
+mod inner;
+fn g() {}
+//- /submodule/inner.rs
+fn f() {}
+"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/extract_variable.rs b/crates/assists/src/handlers/extract_variable.rs
index d2ae137cd..9957012fe 100644
--- a/crates/assists/src/handlers/extract_variable.rs
+++ b/crates/assists/src/handlers/extract_variable.rs
@@ -91,7 +91,7 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
            // extra newlines in the indent block
            let text = indent.text();
            if text.starts_with('\n') {
-                buf.push_str("\n");
+                buf.push('\n');
                buf.push_str(text.trim_start_matches('\n'));
            } else {
                buf.push_str(text);
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index 91e2f5c8c..f9c33b3f7 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -78,6 +78,15 @@ mod tests {
    }
    #[test]
+    fn invert_if_remove_not_parentheses() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f !(x == 3 || x == 4 || x == 5) { 3 * 2 } else { 1 } }",
+            "fn f() { if x == 3 || x == 4 || x == 5 { 1 } else { 3 * 2 } }",
+        )
+    }
+    #[test]
    fn invert_if_remove_inequality() {
        check_assist(
            invert_if,
diff --git a/crates/assists/src/handlers/remove_unused_param.rs b/crates/assists/src/handlers/remove_unused_param.rs
index 1ff5e92b0..f72dd49ed 100644
--- a/crates/assists/src/handlers/remove_unused_param.rs
+++ b/crates/assists/src/handlers/remove_unused_param.rs
@@ -2,9 +2,10 @@ use ide_db::{defs::Definition, search::Reference};
 use syntax::{
    algo::find_node_at_range,
    ast::{self, ArgListOwner},
-    AstNode, SyntaxNode, TextRange, T,
+    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use test_utils::mark;
+use SyntaxKind::WHITESPACE;
 use crate::{
    assist_context::AssistBuilder, utils::next_prev, AssistContext, AssistId, AssistKind, Assists,
@@ -56,7 +57,7 @@ pub(crate) fn remove_unused_param(acc: &mut Assists, ctx: &AssistContext) -> Opt
        "Remove unused parameter",
        param.syntax().text_range(),
        |builder| {
-            builder.delete(range_with_coma(param.syntax()));
+            builder.delete(range_to_remove(param.syntax()));
            for usage in fn_def.usages(&ctx.sema).all() {
                process_usage(ctx, builder, usage, param_position);
            }
@@ -80,19 +81,34 @@ fn process_usage(
    let arg = call_expr.arg_list()?.args().nth(arg_to_remove)?;
    builder.edit_file(usage.file_range.file_id);
-    builder.delete(range_with_coma(arg.syntax()));
+    builder.delete(range_to_remove(arg.syntax()));
    Some(())
 }
-fn range_with_coma(node: &SyntaxNode) -> TextRange {
+fn range_to_remove(node: &SyntaxNode) -> TextRange {
-    let up_to = next_prev().find_map(|dir| {
+    let up_to_comma = next_prev().find_map(|dir| {
        node.siblings_with_tokens(dir)
            .filter_map(|it| it.into_token())
            .find(|it| it.kind() == T![,])
+            .map(|it| (dir, it))
    });
-    let up_to = up_to.map_or(node.text_range(), |it| it.text_range());
+    if let Some((dir, token)) = up_to_comma {
-    node.text_range().cover(up_to)
+        if node.next_sibling().is_some() {
+            let up_to_space = token
+                .siblings_with_tokens(dir)
+                .skip(1)
+                .take_while(|it| it.kind() == WHITESPACE)
+                .last()
+                .and_then(|it| it.into_token());
+            return node
+                .text_range()
+                .cover(up_to_space.map_or(token.text_range(), |it| it.text_range()));
+        }
+        node.text_range().cover(token.text_range())
+    } else {
+        node.text_range()
+    }
 }
 #[cfg(test)]
@@ -119,6 +135,57 @@ fn b() { foo(9, ) }
    }
    #[test]
+    fn remove_unused_first_param() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(<|>x: i32, y: i32) { y; }
+fn a() { foo(1, 2) }
+fn b() { foo(1, 2,) }
+"#,
+            r#"
+fn foo(y: i32) { y; }
+fn a() { foo(2) }
+fn b() { foo(2,) }
+"#,
+        );
+    }
+    #[test]
+    fn remove_unused_single_param() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(<|>x: i32) { 0; }
+fn a() { foo(1) }
+fn b() { foo(1, ) }
+"#,
+            r#"
+fn foo() { 0; }
+fn a() { foo() }
+fn b() { foo( ) }
+"#,
+        );
+    }
+    #[test]
+    fn remove_unused_surrounded_by_parms() {
+        check_assist(
+            remove_unused_param,
+            r#"
+fn foo(x: i32, <|>y: i32, z: i32) { x; }
+fn a() { foo(1, 2, 3) }
+fn b() { foo(1, 2, 3,) }
+"#,
+            r#"
+fn foo(x: i32, z: i32) { x; }
+fn a() { foo(1, 3) }
+fn b() { foo(1, 3,) }
+"#,
+        );
+    }
+    #[test]
    fn remove_unused_qualified_call() {
        check_assist(
            remove_unused_param,
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index 4d6a1956b..cb7a5c104 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -62,21 +62,22 @@ pub(crate) fn replace_derive_with_manual_impl(
    let current_module = ctx.sema.scope(annotated_name.syntax()).module()?;
    let current_crate = current_module.krate();
-    let found_traits =
+    let found_traits = imports_locator::find_exact_imports(
-        imports_locator::find_exact_imports(&ctx.sema, current_crate, trait_token.text())
+        &ctx.sema,
-            .filter_map(
+        current_crate,
-                |candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate {
+        trait_token.text().to_string(),
-                    either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_),
+    )
-                    _ => None,
+    .filter_map(|candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate {
-                },
+        either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_),
-            )
+        _ => None,
-            .flat_map(|trait_| {
+    })
-                current_module
+    .flat_map(|trait_| {
-                    .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+        current_module
-                    .as_ref()
+            .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
-                    .map(mod_path_to_ast)
+            .as_ref()
-                    .zip(Some(trait_))
+            .map(mod_path_to_ast)
-            });
+            .zip(Some(trait_))
+    });
    let mut no_traits_found = true;
    for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) {
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 6e736ccb3..fdec886e9 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -73,45 +73,32 @@ pub struct Assist {
    /// Target ranges are used to sort assists: the smaller the target range,
    /// the more specific assist is, and so it should be sorted first.
    pub target: TextRange,
-}
+    /// Computing source change sometimes is much more costly then computing the
+    /// other fields. Additionally, the actual change is not required to show
-#[derive(Debug, Clone)]
+    /// the lightbulb UI, it only is needed when the user tries to apply an
-pub struct ResolvedAssist {
+    /// assist. So, we compute it lazily: the API allow requesting assists with
-    pub assist: Assist,
+    /// or without source change. We could (and in fact, used to) distinguish
-    pub source_change: SourceChange,
+    /// between resolved and unresolved assists at the type level, but this is
+    /// cumbersome, especially if you want to embed an assist into another data
+    /// structure, such as a diagnostic.
+    pub source_change: Option<SourceChange>,
 }
 impl Assist {
    /// Return all the assists applicable at the given position.
-    ///
+    pub fn get(
-    /// Assists are returned in the "unresolved" state, that is only labels are
-    /// returned, without actual edits.
-    pub fn unresolved(db: &RootDatabase, config: &AssistConfig, range: FileRange) -> Vec<Assist> {
-        let sema = Semantics::new(db);
-        let ctx = AssistContext::new(sema, config, range);
-        let mut acc = Assists::new_unresolved(&ctx);
-        handlers::all().iter().for_each(|handler| {
-            handler(&mut acc, &ctx);
-        });
-        acc.finish_unresolved()
-    }
-    /// Return all the assists applicable at the given position.
-    ///
-    /// Assists are returned in the "resolved" state, that is with edit fully
-    /// computed.
-    pub fn resolved(
        db: &RootDatabase,
        config: &AssistConfig,
+        resolve: bool,
        range: FileRange,
-    ) -> Vec<ResolvedAssist> {
+    ) -> Vec<Assist> {
        let sema = Semantics::new(db);
        let ctx = AssistContext::new(sema, config, range);
-        let mut acc = Assists::new_resolved(&ctx);
+        let mut acc = Assists::new(&ctx, resolve);
        handlers::all().iter().for_each(|handler| {
            handler(&mut acc, &ctx);
        });
-        acc.finish_resolved()
+        acc.finish()
    }
 }
@@ -129,6 +116,7 @@ mod handlers {
    mod convert_integer_literal;
    mod early_return;
    mod expand_glob_import;
+    mod extract_module_to_file;
    mod extract_struct_from_enum_variant;
    mod extract_variable;
    mod fill_match_arms;
@@ -179,6 +167,7 @@ mod handlers {
            convert_integer_literal::convert_integer_literal,
            early_return::convert_to_guarded_return,
            expand_glob_import::expand_glob_import,
+            extract_module_to_file::extract_module_to_file,
            extract_struct_from_enum_variant::extract_struct_from_enum_variant,
            extract_variable::extract_variable,
            fill_match_arms::fill_match_arms,
diff --git a/crates/assists/src/tests.rs b/crates/assists/src/tests.rs
index 709a34d03..21e448fb8 100644
--- a/crates/assists/src/tests.rs
+++ b/crates/assists/src/tests.rs
@@ -2,6 +2,7 @@ mod generated;
 use hir::Semantics;
 use ide_db::base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
+use ide_db::source_change::FileSystemEdit;
 use ide_db::RootDatabase;
 use syntax::TextRange;
 use test_utils::{assert_eq_text, extract_offset, extract_range};
@@ -47,25 +48,29 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
    let before = db.file_text(file_id).to_string();
    let frange = FileRange { file_id, range: selection.into() };
-    let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
+    let assist = Assist::get(&db, &AssistConfig::default(), true, frange)
        .into_iter()
-        .find(|assist| assist.assist.id.0 == assist_id)
+        .find(|assist| assist.id.0 == assist_id)
        .unwrap_or_else(|| {
            panic!(
                "\n\nAssist is not applicable: {}\nAvailable assists: {}",
                assist_id,
-                Assist::resolved(&db, &AssistConfig::default(), frange)
+                Assist::get(&db, &AssistConfig::default(), false, frange)
                    .into_iter()
-                    .map(|assist| assist.assist.id.0)
+                    .map(|assist| assist.id.0)
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        });
    let actual = {
-        let change = assist.source_change.source_file_edits.pop().unwrap();
+        let source_change = assist.source_change.unwrap();
        let mut actual = before;
-        change.edit.apply(&mut actual);
+        for source_file_edit in source_change.source_file_edits {
+            if source_file_edit.file_id == file_id {
+                source_file_edit.edit.apply(&mut actual)
+            }
+        }
        actual
    };
    assert_eq_text!(&after, &actual);
@@ -86,20 +91,21 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
    let sema = Semantics::new(&db);
    let config = AssistConfig::default();
    let ctx = AssistContext::new(sema, &config, frange);
-    let mut acc = Assists::new_resolved(&ctx);
+    let mut acc = Assists::new(&ctx, true);
    handler(&mut acc, &ctx);
-    let mut res = acc.finish_resolved();
+    let mut res = acc.finish();
    let assist = match assist_label {
-        Some(label) => res.into_iter().find(|resolved| resolved.assist.label == label),
+        Some(label) => res.into_iter().find(|resolved| resolved.label == label),
        None => res.pop(),
    };
    match (assist, expected) {
        (Some(assist), ExpectedResult::After(after)) => {
-            let mut source_change = assist.source_change;
+            let mut source_change = assist.source_change.unwrap();
            assert!(!source_change.source_file_edits.is_empty());
-            let skip_header = source_change.source_file_edits.len() == 1;
+            let skip_header = source_change.source_file_edits.len() == 1
+                && source_change.file_system_edits.len() == 0;
            source_change.source_file_edits.sort_by_key(|it| it.file_id);
            let mut buf = String::new();
@@ -115,10 +121,25 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
                buf.push_str(&text);
            }
+            for file_system_edit in source_change.file_system_edits.clone() {
+                match file_system_edit {
+                    FileSystemEdit::CreateFile { dst, initial_contents } => {
+                        let sr = db.file_source_root(dst.anchor);
+                        let sr = db.source_root(sr);
+                        let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
+                        base.pop();
+                        let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
+                        format_to!(buf, "//- {}\n", created_file_path);
+                        buf.push_str(&initial_contents);
+                    }
+                    _ => (),
+                }
+            }
            assert_eq_text!(after, &buf);
        }
        (Some(assist), ExpectedResult::Target(target)) => {
-            let range = assist.assist.target;
+            let range = assist.target;
            assert_eq_text!(&text_without_caret[range], target);
        }
        (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
@@ -135,14 +156,11 @@ fn assist_order_field_struct() {
    let (before_cursor_pos, before) = extract_offset(before);
    let (db, file_id) = with_single_file(&before);
    let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
-    let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+    let assists = Assist::get(&db, &AssistConfig::default(), false, frange);
    let mut assists = assists.iter();
-    assert_eq!(
+    assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
-        assists.next().expect("expected assist").assist.label,
+    assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
-        "Change visibility to pub(crate)"
-    );
-    assert_eq!(assists.next().expect("expected assist").assist.label, "Add `#[derive]`");
 }
 #[test]
@@ -158,11 +176,11 @@ fn assist_order_if_expr() {
    let (range, before) = extract_range(before);
    let (db, file_id) = with_single_file(&before);
    let frange = FileRange { file_id, range };
-    let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+    let assists = Assist::get(&db, &AssistConfig::default(), false, frange);
    let mut assists = assists.iter();
-    assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
+    assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
-    assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
+    assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
 }
 #[test]
@@ -183,27 +201,27 @@ fn assist_filter_works() {
        let mut cfg = AssistConfig::default();
        cfg.allowed = Some(vec![AssistKind::Refactor]);
-        let assists = Assist::resolved(&db, &cfg, frange);
+        let assists = Assist::get(&db, &cfg, false, frange);
        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
+        assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
-        assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
+        assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
    }
    {
        let mut cfg = AssistConfig::default();
        cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
-        let assists = Assist::resolved(&db, &cfg, frange);
+        let assists = Assist::get(&db, &cfg, false, frange);
        assert_eq!(assists.len(), 1);
        let mut assists = assists.iter();
-        assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
+        assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
    }
    {
        let mut cfg = AssistConfig::default();
        cfg.allowed = Some(vec![AssistKind::QuickFix]);
-        let assists = Assist::resolved(&db, &cfg, frange);
+        let assists = Assist::get(&db, &cfg, false, frange);
        assert!(assists.is_empty(), "All asserts but quickfixes should be filtered out");
    }
 }
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index cc7c4a343..d3dfe24e7 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -42,26 +42,26 @@ fn doctest_add_impl_default_members() {
        "add_impl_default_members",
        r#####"
 trait Trait {
-    Type X;
+    type X;
    fn foo(&self);
    fn bar(&self) {}
 }
 impl Trait for () {
-    Type X = ();
+    type X = ();
    fn foo(&self) {}<|>
 }
 "#####,
        r#####"
 trait Trait {
-    Type X;
+    type X;
    fn foo(&self);
    fn bar(&self) {}
 }
 impl Trait for () {
-    Type X = ();
+    type X = ();
    fn foo(&self) {}
    $0fn bar(&self) {}
@@ -76,7 +76,7 @@ fn doctest_add_impl_missing_members() {
        "add_impl_missing_members",
        r#####"
 trait Trait<T> {
-    Type X;
+    type X;
    fn foo(&self) -> T;
    fn bar(&self) {}
 }
@@ -87,14 +87,16 @@ impl Trait<u32> for () {<|>
 "#####,
        r#####"
 trait Trait<T> {
-    Type X;
+    type X;
    fn foo(&self) -> T;
    fn bar(&self) {}
 }
 impl Trait<u32> for () {
+    $0type X;
    fn foo(&self) -> u32 {
-        ${0:todo!()}
+        todo!()
    }
 }
 "#####,
@@ -236,6 +238,21 @@ fn qux(bar: Bar, baz: Baz) {}
 }
 #[test]
+fn doctest_extract_module_to_file() {
+    check_doc_test(
+        "extract_module_to_file",
+        r#####"
+mod foo {<|>
+    fn t() {}
+}
+"#####,
+        r#####"
+mod foo;
+"#####,
+    )
+}
+#[test]
 fn doctest_extract_struct_from_enum_variant() {
    check_doc_test(
        "extract_struct_from_enum_variant",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index f2cacf7c8..d41084b59 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -232,7 +232,13 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
            };
            Some(make::expr_method_call(receiver, method, arg_list))
        }
-        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => pe.expr(),
+        ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::PrefixOp::Not => {
+            if let ast::Expr::ParenExpr(parexpr) = pe.expr()? {
+                parexpr.expr()
+            } else {
+                pe.expr()
+            }
+        }
        // FIXME:
        // ast::Expr::Literal(true | false )
        _ => None,
diff --git a/crates/assists/src/utils/import_assets.rs b/crates/assists/src/utils/import_assets.rs
index ff5c0e78e..4ce82c1ba 100644
--- a/crates/assists/src/utils/import_assets.rs
+++ b/crates/assists/src/utils/import_assets.rs
@@ -179,25 +179,24 @@ impl ImportAssets {
            }
        };
-        let mut res =
+        let mut res = imports_locator::find_exact_imports(
-            imports_locator::find_exact_imports(sema, current_crate, &self.get_search_query())
+            sema,
-                .filter_map(filter)
+            current_crate,
-                .filter_map(|candidate| {
+            self.get_search_query().to_string(),
-                    let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
+        )
-                    if let Some(prefix_kind) = prefixed {
+        .filter_map(filter)
-                        self.module_with_name_to_import.find_use_path_prefixed(
+        .filter_map(|candidate| {
-                            db,
+            let item: hir::ItemInNs = candidate.either(Into::into, Into::into);
-                            item,
+            if let Some(prefix_kind) = prefixed {
-                            prefix_kind,
+                self.module_with_name_to_import.find_use_path_prefixed(db, item, prefix_kind)
-                        )
+            } else {
-                    } else {
+                self.module_with_name_to_import.find_use_path(db, item)
-                        self.module_with_name_to_import.find_use_path(db, item)
+            }
-                    }
+            .map(|path| (path, item))
-                    .map(|path| (path, item))
+        })
-                })
+        .filter(|(use_path, _)| use_path.len() > 1)
-                .filter(|(use_path, _)| use_path.len() > 1)
+        .take(20)
-                .take(20)
+        .collect::<Vec<_>>();
-                .collect::<Vec<_>>();
        res.sort_by_key(|(path, _)| path.clone());
        res
    }
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index cda5e57dc..9567bcc42 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -6,12 +6,12 @@
 //! actual IO. See `vfs` and `project_model` in the `rust-analyzer` crate for how
 //! actual IO is done and lowered to input.
-use std::{fmt, iter::FromIterator, ops, str::FromStr, sync::Arc};
+use std::{fmt, iter::FromIterator, ops, panic::RefUnwindSafe, str::FromStr, sync::Arc};
 use cfg::CfgOptions;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::SmolStr;
-use tt::TokenExpander;
+use tt::{ExpansionError, Subtree};
 use vfs::{file_set::FileSet, FileId, VfsPath};
 /// Files are grouped into source roots. A source root is a directory on the
@@ -150,11 +150,20 @@ pub enum ProcMacroKind {
    Attr,
 }
+pub trait ProcMacroExpander: fmt::Debug + Send + Sync + RefUnwindSafe {
+    fn expand(
+        &self,
+        subtree: &Subtree,
+        attrs: Option<&Subtree>,
+        env: &Env,
+    ) -> Result<Subtree, ExpansionError>;
+}
 #[derive(Debug, Clone)]
 pub struct ProcMacro {
    pub name: SmolStr,
    pub kind: ProcMacroKind,
-    pub expander: Arc<dyn TokenExpander>,
+    pub expander: Arc<dyn ProcMacroExpander>,
 }
 impl Eq for ProcMacro {}
@@ -413,6 +422,10 @@ impl Env {
    pub fn get(&self, env: &str) -> Option<String> {
        self.entries.get(env).cloned()
    }
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.entries.iter().map(|(k, v)| (k.as_str(), v.as_str()))
+    }
 }
 #[derive(Debug)]
diff --git a/crates/base_db/src/lib.rs b/crates/base_db/src/lib.rs
index 595f28ada..5f77a0b1f 100644
--- a/crates/base_db/src/lib.rs
+++ b/crates/base_db/src/lib.rs
@@ -14,7 +14,7 @@ pub use crate::{
    change::Change,
    input::{
        CrateData, CrateDisplayName, CrateGraph, CrateId, CrateName, Dependency, Edition, Env,
-        ProcMacro, ProcMacroId, ProcMacroKind, SourceRoot, SourceRootId,
+        ProcMacro, ProcMacroExpander, ProcMacroId, ProcMacroKind, SourceRoot, SourceRootId,
    },
 };
 pub use salsa;
diff --git a/crates/completion/Cargo.toml b/crates/completion/Cargo.toml
index 35e169a28..78e93e78e 100644
--- a/crates/completion/Cargo.toml
+++ b/crates/completion/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-itertools = "0.9.0"
+itertools = "0.10.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.6.1"
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index 1ef6b5f48..d9fe13485 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -19,9 +19,14 @@ use hir::{ModPath, ScopeDef, Type};
 use crate::{
    item::Builder,
    render::{
-        const_::render_const, enum_variant::render_variant, function::render_fn,
+        const_::render_const,
-        macro_::render_macro, render_field, render_resolution, render_tuple_field,
+        enum_variant::render_variant,
-        type_alias::render_type_alias, RenderContext,
+        function::render_fn,
+        macro_::render_macro,
+        pattern::{render_struct_pat, render_variant_pat},
+        render_field, render_resolution, render_tuple_field,
+        type_alias::render_type_alias,
+        RenderContext,
    },
    CompletionContext, CompletionItem,
 };
@@ -105,6 +110,28 @@ impl Completions {
        self.add(item)
    }
+    pub(crate) fn add_variant_pat(
+        &mut self,
+        ctx: &CompletionContext,
+        variant: hir::Variant,
+        local_name: Option<hir::Name>,
+    ) {
+        if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name) {
+            self.add(item);
+        }
+    }
+    pub(crate) fn add_struct_pat(
+        &mut self,
+        ctx: &CompletionContext,
+        strukt: hir::Struct,
+        local_name: Option<hir::Name>,
+    ) {
+        if let Some(item) = render_struct_pat(RenderContext::new(ctx), strukt, local_name) {
+            self.add(item);
+        }
+    }
    pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
        if let Some(item) = render_const(RenderContext::new(ctx), constant) {
            self.add(item);
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index 19ce2482f..8695eed39 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -234,7 +234,7 @@ fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<Strin
                        current_derive = String::new();
                    }
                } else {
-                    current_derive.push_str(token.to_string().trim());
+                    current_derive.push_str(token.text().trim());
                }
            }
diff --git a/crates/completion/src/completions/pattern.rs b/crates/completion/src/completions/pattern.rs
index 4d56731ec..eee31098d 100644
--- a/crates/completion/src/completions/pattern.rs
+++ b/crates/completion/src/completions/pattern.rs
@@ -2,9 +2,9 @@
 use crate::{CompletionContext, Completions};
-/// Completes constats and paths in patterns.
+/// Completes constants and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_let_pat_binding) {
+    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_pat_binding) {
        return;
    }
    if ctx.record_pat_syntax.is_some() {
@@ -15,20 +15,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
    // suggest variants + auto-imports
    ctx.scope.process_all_names(&mut |name, res| {
        let add_resolution = match &res {
-            hir::ScopeDef::ModuleDef(def) => {
+            hir::ScopeDef::ModuleDef(def) => match def {
-                if ctx.is_irrefutable_let_pat_binding {
+                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    matches!(def, hir::ModuleDef::Adt(hir::Adt::Struct(_)))
+                    acc.add_struct_pat(ctx, strukt.clone(), Some(name.clone()));
-                } else {
+                    true
-                    matches!(
-                        def,
-                        hir::ModuleDef::Adt(hir::Adt::Enum(..))
-                            | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                            | hir::ModuleDef::Variant(..)
-                            | hir::ModuleDef::Const(..)
-                            | hir::ModuleDef::Module(..)
-                    )
                }
-            }
+                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
+                    acc.add_variant_pat(ctx, variant.clone(), Some(name.clone()));
+                    true
+                }
+                hir::ModuleDef::Adt(hir::Adt::Enum(..))
+                | hir::ModuleDef::Variant(..)
+                | hir::ModuleDef::Const(..)
+                | hir::ModuleDef::Module(..) => !ctx.is_irrefutable_pat_binding,
+                _ => false,
+            },
            hir::ScopeDef::MacroDef(_) => true,
            _ => false,
        };
@@ -42,13 +43,21 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
    use expect_test::{expect, Expect};
-    use crate::{test_utils::completion_list, CompletionKind};
+    use crate::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
    fn check(ra_fixture: &str, expect: Expect) {
        let actual = completion_list(ra_fixture, CompletionKind::Reference);
        expect.assert_eq(&actual)
    }
+    fn check_snippet(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Snippet);
+        expect.assert_eq(&actual)
+    }
    #[test]
    fn completes_enum_variants_and_modules() {
        check(
@@ -69,7 +78,7 @@ fn foo() {
                en E
                ct Z
                st Bar
-                ev X   ()
+                ev X
                md m
            "#]],
        );
@@ -114,4 +123,139 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn completes_in_param() {
+        check(
+            r#"
+enum E { X }
+static FOO: E = E::X;
+struct Bar { f: u32 }
+fn foo(<|>) {
+}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
+        );
+    }
+    #[test]
+    fn completes_pat_in_let() {
+        check_snippet(
+            r#"
+struct Bar { f: u32 }
+fn foo() {
+   let <|>
+}
+"#,
+            expect![[r#"
+                bn Bar Bar { f$1 }$0
+            "#]],
+        );
+    }
+    #[test]
+    fn completes_param_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer(<|>) {}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }: Foo$0
+                bn Bar Bar($1, $2): Bar$0
+            "#]],
+        )
+    }
+    #[test]
+    fn completes_let_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: String, baz: String }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    let <|>
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn completes_refutable_pattern() {
+        check_snippet(
+            r#"
+struct Foo { bar: i32, baz: i32 }
+struct Bar(String, String);
+struct Baz;
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, baz$2 }$0
+                bn Bar Bar($1, $2)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn omits_private_fields_pat() {
+        check_snippet(
+            r#"
+mod foo {
+    pub struct Foo { pub bar: i32, baz: i32 }
+    pub struct Bar(pub String, String);
+    pub struct Invisible(String, String);
+}
+use foo::*;
+fn outer() {
+    match () {
+        <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1, .. }$0
+                bn Bar Bar($1, ..)$0
+            "#]],
+        )
+    }
+    #[test]
+    fn only_shows_ident_completion() {
+        check_edit(
+            "Foo",
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        <|>(92) => (),
+    }
+}
+"#,
+            r#"
+struct Foo(i32);
+fn main() {
+    match Foo(92) {
+        Foo(92) => (),
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index d6db82a93..3883d6d21 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -502,7 +502,7 @@ fn main() {
    #[test]
    fn postfix_completion_for_format_like_strings() {
        check_edit(
-            "fmt",
+            "format",
            r#"fn main() { "{some_var:?}".<|> }"#,
            r#"fn main() { format!("{:?}", some_var) }"#,
        );
diff --git a/crates/completion/src/completions/postfix/format_like.rs b/crates/completion/src/completions/postfix/format_like.rs
index 88ba86acb..def4b13fb 100644
--- a/crates/completion/src/completions/postfix/format_like.rs
+++ b/crates/completion/src/completions/postfix/format_like.rs
@@ -22,7 +22,7 @@ use syntax::ast::{self, AstToken};
 /// Mapping ("postfix completion item" => "macro to use")
 static KINDS: &[(&str, &str)] = &[
-    ("fmt", "format!"),
+    ("format", "format!"),
    ("panic", "panic!"),
    ("println", "println!"),
    ("eprintln", "eprintln!"),
@@ -108,7 +108,8 @@ impl FormatStrParser {
        // "{MyStruct { val_a: 0, val_b: 1 }}".
        let mut inexpr_open_count = 0;
-        for chr in self.input.chars() {
+        let mut chars = self.input.chars().peekable();
+        while let Some(chr) = chars.next() {
            match (self.state, chr) {
                (State::NotExpr, '{') => {
                    self.output.push(chr);
@@ -157,6 +158,11 @@ impl FormatStrParser {
                        inexpr_open_count -= 1;
                    }
                }
+                (State::Expr, ':') if chars.peek().copied() == Some(':') => {
+                    // path seperator
+                    current_expr.push_str("::");
+                    chars.next();
+                }
                (State::Expr, ':') => {
                    if inexpr_open_count == 0 {
                        // We're outside of braces, thus assume that it's a specifier, like "{Some(value):?}"
@@ -249,6 +255,9 @@ mod tests {
                expect![["{:?}; SomeStruct { val_a: 0, val_b: 1 }"]],
            ),
            ("{     2 + 2        }", expect![["{}; 2 + 2"]]),
+            ("{strsim::jaro_winkle(a)}", expect![["{}; strsim::jaro_winkle(a)"]]),
+            ("{foo::bar::baz()}", expect![["{}; foo::bar::baz()"]]),
+            ("{foo::bar():?}", expect![["{:?}; foo::bar()"]]),
        ];
        for (input, output) in test_vector {
diff --git a/crates/completion/src/completions/qualified_path.rs b/crates/completion/src/completions/qualified_path.rs
index 1300f00b2..882c4dcbc 100644
--- a/crates/completion/src/completions/qualified_path.rs
+++ b/crates/completion/src/completions/qualified_path.rs
@@ -118,6 +118,12 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                    _ => return,
                };
+                if let Some(Adt::Enum(e)) = ty.as_adt() {
+                    for variant in e.variants(ctx.db) {
+                        acc.add_enum_variant(ctx, variant, None);
+                    }
+                }
                let traits_in_scope = ctx.scope.traits_in_scope();
                let mut seen = FxHashSet::default();
                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
@@ -752,4 +758,27 @@ fn main() {
            "#]],
        );
    }
+    #[test]
+    fn completes_self_enum() {
+        check(
+            r#"
+enum Foo {
+    Bar,
+    Baz,
+}
+impl Foo {
+    fn foo(self) {
+        Self::<|>
+    }
+}
+"#,
+            expect![[r#"
+                ev Bar    ()
+                ev Baz    ()
+                me foo(…) fn foo(self)
+            "#]],
+        );
+    }
 }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 099ffb4d4..81a6d00e2 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -1,5 +1,7 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
+use std::iter;
 use either::Either;
 use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
 use ide_db::helpers::insert_use::ImportScope;
@@ -50,7 +52,9 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
 }
 fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
-    if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
+    if let Some(Adt::Enum(enum_data)) =
+        iter::successors(Some(ty.clone()), |ty| ty.remove_ref()).last().and_then(|ty| ty.as_adt())
+    {
        let variants = enum_data.variants(ctx.db);
        let module = if let Some(module) = ctx.scope.module() {
@@ -97,8 +101,9 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 //
 // .Fuzzy search details
 //
-// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the identifiers only
+// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
-// (i.e. in `HashMap` in the `std::collections::HashMap` path), also not in the module indentifiers.
+// (i.e. in `HashMap` in the `std::collections::HashMap` path).
+// For the same reasons, avoids searching for any imports for inputs with their length less that 2 symbols.
 //
 // .Merge Behavior
 //
@@ -122,15 +127,20 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
    let _p = profile::span("fuzzy_completion");
    let potential_import_name = ctx.token.to_string();
+    if potential_import_name.len() < 2 {
+        return None;
+    }
    let current_module = ctx.scope.module()?;
    let anchor = ctx.name_ref_syntax.as_ref()?;
    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    let user_input_lowercased = potential_import_name.to_lowercase();
    let mut all_mod_paths = imports_locator::find_similar_imports(
        &ctx.sema,
        ctx.krate?,
-        Some(100),
+        Some(40),
-        &potential_import_name,
+        potential_import_name,
        true,
    )
    .filter_map(|import_candidate| {
@@ -146,7 +156,6 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
    .filter(|(mod_path, _)| mod_path.len() > 1)
    .collect::<Vec<_>>();
-    let user_input_lowercased = potential_import_name.to_lowercase();
    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
    });
@@ -701,6 +710,7 @@ fn main() { <|> }
            "#]],
        );
    }
    #[test]
    fn completes_enum_variant_matcharm() {
        check(
@@ -722,6 +732,26 @@ fn main() {
    }
    #[test]
+    fn completes_enum_variant_matcharm_ref() {
+        check(
+            r#"
+enum Foo { Bar, Baz, Quux }
+fn main() {
+    let foo = Foo::Quux;
+    match &foo { Qu<|> }
+}
+"#,
+            expect![[r#"
+                ev Foo::Bar  ()
+                ev Foo::Baz  ()
+                ev Foo::Quux ()
+                en Foo
+            "#]],
+        )
+    }
+    #[test]
    fn completes_enum_variant_iflet() {
        check(
            r#"
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index 5cd11cf77..41de324d8 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -51,7 +51,7 @@ pub(crate) struct CompletionContext<'a> {
    /// If a name-binding or reference to a const in a pattern.
    /// Irrefutable patterns (like let) are excluded.
    pub(super) is_pat_binding_or_const: bool,
-    pub(super) is_irrefutable_let_pat_binding: bool,
+    pub(super) is_irrefutable_pat_binding: bool,
    /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
    pub(super) is_trivial_path: bool,
    /// If not a trivial path, the prefix (qualifier).
@@ -147,7 +147,7 @@ impl<'a> CompletionContext<'a> {
            active_parameter: ActiveParameter::at(db, position),
            is_param: false,
            is_pat_binding_or_const: false,
-            is_irrefutable_let_pat_binding: false,
+            is_irrefutable_pat_binding: false,
            is_trivial_path: false,
            path_qual: None,
            after_if: false,
@@ -327,14 +327,19 @@ impl<'a> CompletionContext<'a> {
                if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() {
                    self.is_pat_binding_or_const = false;
                }
-                if let Some(let_stmt) = bind_pat.syntax().ancestors().find_map(ast::LetStmt::cast) {
+                if let Some(Some(pat)) = bind_pat.syntax().ancestors().find_map(|node| {
-                    if let Some(pat) = let_stmt.pat() {
+                    match_ast! {
-                        if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range())
+                        match node {
-                        {
+                            ast::LetStmt(it) => Some(it.pat()),
-                            self.is_pat_binding_or_const = false;
+                            ast::Param(it) => Some(it.pat()),
-                            self.is_irrefutable_let_pat_binding = true;
+                            _ => None,
                        }
                    }
+                }) {
+                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
+                        self.is_pat_binding_or_const = false;
+                        self.is_irrefutable_pat_binding = true;
+                    }
                }
            }
            if is_node::<ast::Param>(name.syntax()) {
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index 8e27bb153..c57d05bbe 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -137,7 +137,7 @@ pub fn resolve_completion_edits(
    config: &CompletionConfig,
    position: FilePosition,
    full_import_path: &str,
-    imported_name: &str,
+    imported_name: String,
 ) -> Option<Vec<TextEdit>> {
    let ctx = CompletionContext::new(db, position, config)?;
    let anchor = ctx.name_ref_syntax.as_ref()?;
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 1092a4825..1ba7201a1 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -5,6 +5,7 @@ pub(crate) mod macro_;
 pub(crate) mod function;
 pub(crate) mod enum_variant;
 pub(crate) mod const_;
+pub(crate) mod pattern;
 pub(crate) mod type_alias;
 mod builder_ext;
@@ -159,6 +160,12 @@ impl<'a> Render<'a> {
                let item = render_fn(self.ctx, import_to_add, Some(local_name), *func);
                return Some(item);
            }
+            ScopeDef::ModuleDef(Variant(_))
+                if self.ctx.completion.is_pat_binding_or_const
+                    | self.ctx.completion.is_irrefutable_pat_binding =>
+            {
+                CompletionItemKind::EnumVariant
+            }
            ScopeDef::ModuleDef(Variant(var)) => {
                let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None);
                return Some(item);
diff --git a/crates/completion/src/render/builder_ext.rs b/crates/completion/src/render/builder_ext.rs
index ce8718bd5..d053a988b 100644
--- a/crates/completion/src/render/builder_ext.rs
+++ b/crates/completion/src/render/builder_ext.rs
@@ -34,7 +34,6 @@ impl Builder {
            return false;
        }
        if ctx.is_pattern_call {
-            mark::hit!(dont_duplicate_pattern_parens);
            return false;
        }
        if ctx.is_call {
diff --git a/crates/completion/src/render/enum_variant.rs b/crates/completion/src/render/enum_variant.rs
index 7176fd9b3..732e139ec 100644
--- a/crates/completion/src/render/enum_variant.rs
+++ b/crates/completion/src/render/enum_variant.rs
@@ -126,50 +126,5 @@ fn main() -> Option<i32> {
 }
 "#,
        );
-        check_edit(
-            "Some",
-            r#"
-enum Option<T> { Some(T), None }
-use Option::*;
-fn main(value: Option<i32>) {
-    match value {
-        Som<|>
-    }
-}
-"#,
-            r#"
-enum Option<T> { Some(T), None }
-use Option::*;
-fn main(value: Option<i32>) {
-    match value {
-        Some($0)
-    }
-}
-"#,
-        );
-    }
-    #[test]
-    fn dont_duplicate_pattern_parens() {
-        mark::check!(dont_duplicate_pattern_parens);
-        check_edit(
-            "Var",
-            r#"
-enum E { Var(i32) }
-fn main() {
-    match E::Var(92) {
-        E::<|>(92) => (),
-    }
-}
-"#,
-            r#"
-enum E { Var(i32) }
-fn main() {
-    match E::Var(92) {
-        E::Var(92) => (),
-    }
-}
-"#,
-        );
    }
 }
diff --git a/crates/completion/src/render/pattern.rs b/crates/completion/src/render/pattern.rs
new file mode 100644
index 000000000..a3b6a3cac
--- /dev/null
+++ b/crates/completion/src/render/pattern.rs
@@ -0,0 +1,148 @@
+//! Renderer for patterns.
+use hir::{db::HirDatabase, HasAttrs, HasVisibility, Name, StructKind};
+use itertools::Itertools;
+use crate::{
+    config::SnippetCap, item::CompletionKind, render::RenderContext, CompletionItem,
+    CompletionItemKind,
+};
+fn visible_fields(
+    ctx: &RenderContext<'_>,
+    fields: &[hir::Field],
+    item: impl HasAttrs,
+) -> Option<(Vec<hir::Field>, bool)> {
+    let module = ctx.completion.scope.module()?;
+    let n_fields = fields.len();
+    let fields = fields
+        .into_iter()
+        .filter(|field| field.is_visible_from(ctx.db(), module))
+        .copied()
+        .collect::<Vec<_>>();
+    let fields_omitted =
+        n_fields - fields.len() > 0 || item.attrs(ctx.db()).by_key("non_exhaustive").exists();
+    Some((fields, fields_omitted))
+}
+pub(crate) fn render_struct_pat(
+    ctx: RenderContext<'_>,
+    strukt: hir::Struct,
+    local_name: Option<Name>,
+) -> Option<CompletionItem> {
+    let _p = profile::span("render_struct_pat");
+    let fields = strukt.fields(ctx.db());
+    let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, strukt)?;
+    if visible_fields.is_empty() {
+        // Matching a struct without matching its fields is pointless, unlike matching a Variant without its fields
+        return None;
+    }
+    let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_string();
+    let pat = render_pat(&ctx, &name, strukt.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    Some(build_completion(ctx, name, pat, strukt))
+}
+pub(crate) fn render_variant_pat(
+    ctx: RenderContext<'_>,
+    variant: hir::Variant,
+    local_name: Option<Name>,
+) -> Option<CompletionItem> {
+    let _p = profile::span("render_variant_pat");
+    let fields = variant.fields(ctx.db());
+    let (visible_fields, fields_omitted) = visible_fields(&ctx, &fields, variant)?;
+    let name = local_name.unwrap_or_else(|| variant.name(ctx.db())).to_string();
+    let pat = render_pat(&ctx, &name, variant.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    Some(build_completion(ctx, name, pat, variant))
+}
+fn build_completion(
+    ctx: RenderContext<'_>,
+    name: String,
+    pat: String,
+    item: impl HasAttrs + Copy,
+) -> CompletionItem {
+    let completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name)
+        .kind(CompletionItemKind::Binding)
+        .set_documentation(ctx.docs(item))
+        .set_deprecated(ctx.is_deprecated(item))
+        .detail(&pat);
+    let completion = if let Some(snippet_cap) = ctx.snippet_cap() {
+        completion.insert_snippet(snippet_cap, pat)
+    } else {
+        completion.insert_text(pat)
+    };
+    completion.build()
+}
+fn render_pat(
+    ctx: &RenderContext<'_>,
+    name: &str,
+    kind: StructKind,
+    fields: &[hir::Field],
+    fields_omitted: bool,
+) -> Option<String> {
+    let mut pat = match kind {
+        StructKind::Tuple if ctx.snippet_cap().is_some() => {
+            render_tuple_as_pat(&fields, &name, fields_omitted)
+        }
+        StructKind::Record => {
+            render_record_as_pat(ctx.db(), ctx.snippet_cap(), &fields, &name, fields_omitted)
+        }
+        _ => return None,
+    };
+    if ctx.completion.is_param {
+        pat.push(':');
+        pat.push(' ');
+        pat.push_str(&name);
+    }
+    if ctx.snippet_cap().is_some() {
+        pat.push_str("$0");
+    }
+    Some(pat)
+}
+fn render_record_as_pat(
+    db: &dyn HirDatabase,
+    snippet_cap: Option<SnippetCap>,
+    fields: &[hir::Field],
+    name: &str,
+    fields_omitted: bool,
+) -> String {
+    let fields = fields.iter();
+    if snippet_cap.is_some() {
+        format!(
+            "{name} {{ {}{} }}",
+            fields
+                .enumerate()
+                .map(|(idx, field)| format!("{}${}", field.name(db), idx + 1))
+                .format(", "),
+            if fields_omitted { ", .." } else { "" },
+            name = name
+        )
+    } else {
+        format!(
+            "{name} {{ {}{} }}",
+            fields.map(|field| field.name(db)).format(", "),
+            if fields_omitted { ", .." } else { "" },
+            name = name
+        )
+    }
+}
+fn render_tuple_as_pat(fields: &[hir::Field], name: &str, fields_omitted: bool) -> String {
+    format!(
+        "{name}({}{})",
+        fields.iter().enumerate().map(|(idx, _)| format!("${}", idx + 1)).format(", "),
+        if fields_omitted { ", .." } else { "" },
+        name = name
+    )
+}
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml
index 6dc5ad63b..d4ea7327e 100644
--- a/crates/hir/Cargo.toml
+++ b/crates/hir/Cargo.toml
@@ -14,7 +14,7 @@ log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
 arrayvec = "0.5.1"
-itertools = "0.9.0"
+itertools = "0.10.0"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 73ca6ba9f..b7ded3478 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -9,7 +9,7 @@ use hir_def::{
    adt::StructKind,
    adt::VariantData,
    builtin_type::BuiltinType,
-    expr::{BindingAnnotation, Pat, PatId},
+    expr::{BindingAnnotation, LabelId, Pat, PatId},
    import_map,
    item_tree::ItemTreeNode,
    lang_item::LangItemTarget,
@@ -374,8 +374,6 @@ impl Module {
        let crate_def_map = db.crate_def_map(self.id.krate);
        crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
        for decl in self.declarations(db) {
-            decl.diagnostics(db, sink);
            match decl {
                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
                crate::ModuleDef::Module(m) => {
@@ -384,7 +382,9 @@ impl Module {
                        m.diagnostics(db, sink)
                    }
                }
-                _ => (),
+                _ => {
+                    decl.diagnostics(db, sink);
+                }
            }
        }
@@ -511,6 +511,10 @@ impl Struct {
        db.struct_data(self.id).repr.clone()
    }
+    pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
+        self.variant_data(db).kind()
+    }
    fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
        db.struct_data(self.id).variant_data.clone()
    }
@@ -1202,6 +1206,34 @@ impl Local {
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct Label {
+    pub(crate) parent: DefWithBodyId,
+    pub(crate) label_id: LabelId,
+}
+impl Label {
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        self.parent(db).module(db)
+    }
+    pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
+        self.parent.into()
+    }
+    pub fn name(self, db: &dyn HirDatabase) -> Name {
+        let body = db.body(self.parent.into());
+        body[self.label_id].name.clone()
+    }
+    pub fn source(self, db: &dyn HirDatabase) -> InFile<ast::Label> {
+        let (_body, source_map) = db.body_with_source_map(self.parent.into());
+        let src = source_map.label_syntax(self.label_id);
+        let root = src.file_syntax(db.upcast());
+        src.map(|ast| ast.to_node(&root))
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum GenericParam {
    TypeParam(TypeParam),
    LifetimeParam(LifetimeParam),
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 8e0c571b8..a0792b9a6 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -4,12 +4,15 @@
 //! are splitting the hir.
 use hir_def::{
-    expr::PatId, item_scope::ItemInNs, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId,
+    expr::{LabelId, PatId},
-    GenericDefId, ModuleDefId, VariantId,
+    item_scope::ItemInNs,
+    AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, GenericDefId, ModuleDefId,
+    VariantId,
 };
 use crate::{
-    Adt, AssocItem, DefWithBody, Field, GenericDef, Local, MacroDef, ModuleDef, Variant, VariantDef,
+    Adt, AssocItem, DefWithBody, Field, GenericDef, Label, Local, MacroDef, ModuleDef, Variant,
+    VariantDef,
 };
 macro_rules! from_id {
@@ -228,6 +231,12 @@ impl From<(DefWithBodyId, PatId)> for Local {
    }
 }
+impl From<(DefWithBodyId, LabelId)> for Label {
+    fn from((parent, label_id): (DefWithBodyId, LabelId)) -> Self {
+        Label { parent, label_id }
+    }
+}
 impl From<MacroDef> for ItemInNs {
    fn from(macro_def: MacroDef) -> Self {
        ItemInNs::Macros(macro_def.into())
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index bdd270c58..7ac9fd507 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -35,8 +35,8 @@ pub use crate::{
    code_model::{
        Access, Adt, AsAssocItem, AssocItem, AssocItemContainer, Callable, CallableKind, Const,
        Crate, CrateDependency, DefWithBody, Enum, Field, FieldSource, Function, GenericDef,
-        HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module, ModuleDef, ScopeDef, Static,
+        HasVisibility, Impl, Label, LifetimeParam, Local, MacroDef, Module, ModuleDef, ScopeDef,
-        Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
+        Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
    },
    has_source::HasSource,
    semantics::{PathResolution, Semantics, SemanticsScope},
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 25ebf73d8..67cd16e31 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -15,7 +15,7 @@ use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
    algo::find_node_at_offset,
-    ast::{self, GenericParamsOwner},
+    ast::{self, GenericParamsOwner, LoopBodyOwner},
    match_ast, AstNode, SyntaxNode, SyntaxToken, TextSize,
 };
@@ -25,8 +25,8 @@ use crate::{
    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, SourceAnalyzer},
-    AssocItem, Callable, Crate, Field, Function, HirFileId, Impl, InFile, LifetimeParam, Local,
+    AssocItem, Callable, Crate, Field, Function, HirFileId, Impl, InFile, Label, LifetimeParam,
-    MacroDef, Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
+    Local, MacroDef, Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
    VariantDef,
 };
@@ -182,6 +182,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.resolve_lifetime_param(lifetime)
    }
+    pub fn resolve_label(&self, lifetime: &ast::Lifetime) -> Option<Label> {
+        self.imp.resolve_label(lifetime)
+    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.imp.type_of_expr(expr)
    }
@@ -425,6 +429,28 @@ impl<'db> SemanticsImpl<'db> {
        ToDef::to_def(self, src)
    }
+    fn resolve_label(&self, lifetime: &ast::Lifetime) -> Option<Label> {
+        let text = lifetime.text();
+        let label = lifetime.syntax().ancestors().find_map(|syn| {
+            let label = match_ast! {
+                match syn {
+                    ast::ForExpr(it) => it.label(),
+                    ast::WhileExpr(it) => it.label(),
+                    ast::LoopExpr(it) => it.label(),
+                    ast::EffectExpr(it) => it.label(),
+                    _ => None,
+                }
+            };
+            label.filter(|l| {
+                l.lifetime()
+                    .and_then(|lt| lt.lifetime_ident_token())
+                    .map_or(false, |lt| lt.text() == text)
+            })
+        })?;
+        let src = self.find_file(label.syntax().clone()).with_value(label);
+        ToDef::to_def(self, src)
+    }
    fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.analyze(expr.syntax()).type_of_expr(self.db, expr)
    }
@@ -720,6 +746,7 @@ to_def_impls![
    (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
    (crate::MacroDef, ast::MacroRules, macro_rules_to_def),
    (crate::Local, ast::IdentPat, bind_pat_to_def),
+    (crate::Label, ast::Label, label_to_def),
 ];
 fn find_root(node: &SyntaxNode) -> SyntaxNode {
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 3efca5baa..424e6e8a9 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -4,7 +4,7 @@ use base_db::FileId;
 use hir_def::{
    child_by_source::ChildBySource,
    dyn_map::DynMap,
-    expr::PatId,
+    expr::{LabelId, PatId},
    keys::{self, Key},
    ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId,
    LifetimeParamId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
@@ -108,12 +108,21 @@ impl SourceToDefCtx<'_, '_> {
        &mut self,
        src: InFile<ast::IdentPat>,
    ) -> Option<(DefWithBodyId, PatId)> {
-        let container = self.find_pat_container(src.as_ref().map(|it| it.syntax()))?;
+        let container = self.find_pat_or_label_container(src.as_ref().map(|it| it.syntax()))?;
        let (_body, source_map) = self.db.body_with_source_map(container);
        let src = src.map(ast::Pat::from);
        let pat_id = source_map.node_pat(src.as_ref())?;
        Some((container, pat_id))
    }
+    pub(super) fn label_to_def(
+        &mut self,
+        src: InFile<ast::Label>,
+    ) -> Option<(DefWithBodyId, LabelId)> {
+        let container = self.find_pat_or_label_container(src.as_ref().map(|it| it.syntax()))?;
+        let (_body, source_map) = self.db.body_with_source_map(container);
+        let label_id = source_map.node_label(src.as_ref())?;
+        Some((container, label_id))
+    }
    fn to_def<Ast: AstNode + 'static, ID: Copy + 'static>(
        &mut self,
@@ -237,7 +246,7 @@ impl SourceToDefCtx<'_, '_> {
        None
    }
-    fn find_pat_container(&mut self, src: InFile<&SyntaxNode>) -> Option<DefWithBodyId> {
+    fn find_pat_or_label_container(&mut self, src: InFile<&SyntaxNode>) -> Option<DefWithBodyId> {
        for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
            let res: DefWithBodyId = match_ast! {
                match (container.value) {
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index a88b5f57e..e8b581e2f 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -17,7 +17,7 @@ either = "1.5.3"
 anymap = "0.12.1"
 drop_bomb = "0.1.4"
 fst = { version = "0.4", default-features = false }
-itertools = "0.9.0"
+itertools = "0.10.0"
 indexmap = "1.4.0"
 smallvec = "1.4.0"
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 998b82601..d07004b9d 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -26,7 +26,7 @@ pub(crate) use lower::LowerCtx;
 use crate::{
    attr::{Attrs, RawAttrs},
    db::DefDatabase,
-    expr::{Expr, ExprId, Pat, PatId},
+    expr::{Expr, ExprId, Label, LabelId, Pat, PatId},
    item_scope::BuiltinShadowMode,
    item_scope::ItemScope,
    nameres::CrateDefMap,
@@ -226,6 +226,7 @@ pub(crate) struct Mark {
 pub struct Body {
    pub exprs: Arena<Expr>,
    pub pats: Arena<Pat>,
+    pub labels: Arena<Label>,
    /// The patterns for the function's parameters. While the parameter types are
    /// part of the function signature, the patterns are not (they don't change
    /// the external type of the function).
@@ -244,6 +245,8 @@ pub type ExprSource = InFile<ExprPtr>;
 pub type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
 pub type PatSource = InFile<PatPtr>;
+pub type LabelPtr = AstPtr<ast::Label>;
+pub type LabelSource = InFile<LabelPtr>;
 /// An item body together with the mapping from syntax nodes to HIR expression
 /// IDs. This is needed to go from e.g. a position in a file to the HIR
 /// expression containing it; but for type inference etc., we want to operate on
@@ -261,6 +264,8 @@ pub struct BodySourceMap {
    expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
+    label_map: FxHashMap<LabelSource, LabelId>,
+    label_map_back: ArenaMap<LabelId, LabelSource>,
    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
@@ -334,6 +339,14 @@ impl Index<PatId> for Body {
    }
 }
+impl Index<LabelId> for Body {
+    type Output = Label;
+    fn index(&self, label: LabelId) -> &Label {
+        &self.labels[label]
+    }
+}
 impl BodySourceMap {
    pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
        self.expr_map_back[expr].clone()
@@ -363,6 +376,15 @@ impl BodySourceMap {
        self.pat_map.get(&src).cloned()
    }
+    pub fn label_syntax(&self, label: LabelId) -> LabelSource {
+        self.label_map_back[label].clone()
+    }
+    pub fn node_label(&self, node: InFile<&ast::Label>) -> Option<LabelId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.label_map.get(&src).cloned()
+    }
    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
        self.field_map[&(expr, field)].clone()
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 0f404be1b..17c72779b 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -22,13 +22,14 @@ use test_utils::mark;
 use crate::{
    adt::StructKind,
-    body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
+    body::{Body, BodySourceMap, Expander, LabelSource, PatPtr, SyntheticSyntax},
    builtin_type::{BuiltinFloat, BuiltinInt},
    db::DefDatabase,
    diagnostics::{InactiveCode, MacroError, UnresolvedProcMacro},
    expr::{
-        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal,
+        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Label,
-        LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
+        LabelId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField,
+        Statement,
    },
    item_scope::BuiltinShadowMode,
    item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
@@ -72,6 +73,7 @@ pub(super) fn lower(
        body: Body {
            exprs: Arena::default(),
            pats: Arena::default(),
+            labels: Arena::default(),
            params: Vec::new(),
            body_expr: dummy_expr_id(),
            item_scope: Default::default(),
@@ -175,6 +177,18 @@ impl ExprCollector<'_> {
        id
    }
+    fn alloc_label(&mut self, label: Label, ptr: AstPtr<ast::Label>) -> LabelId {
+        let src = self.expander.to_source(ptr);
+        let id = self.make_label(label, src.clone());
+        self.source_map.label_map.insert(src, id);
+        id
+    }
+    fn make_label(&mut self, label: Label, src: LabelSource) -> LabelId {
+        let id = self.body.labels.alloc(label);
+        self.source_map.label_map_back.insert(id, src);
+        id
+    }
    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
        let syntax_ptr = AstPtr::new(&expr);
        if self.check_cfg(&expr).is_none() {
@@ -228,37 +242,40 @@ impl ExprCollector<'_> {
                    self.alloc_expr(Expr::Unsafe { body }, syntax_ptr)
                }
                // FIXME: we need to record these effects somewhere...
-                ast::Effect::Label(label) => match e.block_expr() {
+                ast::Effect::Label(label) => {
-                    Some(block) => {
+                    let label = self.collect_label(label);
-                        let res = self.collect_block(block);
+                    match e.block_expr() {
-                        match &mut self.body.exprs[res] {
+                        Some(block) => {
-                            Expr::Block { label: block_label, .. } => {
+                            let res = self.collect_block(block);
-                                *block_label = label.lifetime().map(|t| Name::new_lifetime(&t))
+                            match &mut self.body.exprs[res] {
+                                Expr::Block { label: block_label, .. } => {
+                                    *block_label = Some(label);
+                                }
+                                _ => unreachable!(),
                            }
-                            _ => unreachable!(),
+                            res
                        }
-                        res
+                        None => self.missing_expr(),
                    }
-                    None => self.missing_expr(),
+                }
-                },
                // FIXME: we need to record these effects somewhere...
                ast::Effect::Async(_) => {
                    let body = self.collect_block_opt(e.block_expr());
                    self.alloc_expr(Expr::Async { body }, syntax_ptr)
                }
+                ast::Effect::Const(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::Const { body }, syntax_ptr)
+                }
            },
            ast::Expr::BlockExpr(e) => self.collect_block(e),
            ast::Expr::LoopExpr(e) => {
+                let label = e.label().map(|label| self.collect_label(label));
                let body = self.collect_block_opt(e.loop_body());
-                self.alloc_expr(
+                self.alloc_expr(Expr::Loop { body, label }, syntax_ptr)
-                    Expr::Loop {
-                        body,
-                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                    },
-                    syntax_ptr,
-                )
            }
            ast::Expr::WhileExpr(e) => {
+                let label = e.label().map(|label| self.collect_label(label));
                let body = self.collect_block_opt(e.loop_body());
                let condition = match e.condition() {
@@ -279,42 +296,20 @@ impl ExprCollector<'_> {
                            ];
                            let match_expr =
                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
-                            return self.alloc_expr(
+                            return self
-                                Expr::Loop {
+                                .alloc_expr(Expr::Loop { body: match_expr, label }, syntax_ptr);
-                                    body: match_expr,
-                                    label: e
-                                        .label()
-                                        .and_then(|l| l.lifetime())
-                                        .map(|l| Name::new_lifetime(&l)),
-                                },
-                                syntax_ptr,
-                            );
                        }
                    },
                };
-                self.alloc_expr(
+                self.alloc_expr(Expr::While { condition, body, label }, syntax_ptr)
-                    Expr::While {
-                        condition,
-                        body,
-                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                    },
-                    syntax_ptr,
-                )
            }
            ast::Expr::ForExpr(e) => {
+                let label = e.label().map(|label| self.collect_label(label));
                let iterable = self.collect_expr_opt(e.iterable());
                let pat = self.collect_pat_opt(e.pat());
                let body = self.collect_block_opt(e.loop_body());
-                self.alloc_expr(
+                self.alloc_expr(Expr::For { iterable, pat, body, label }, syntax_ptr)
-                    Expr::For {
-                        iterable,
-                        pat,
-                        body,
-                        label: e.label().and_then(|l| l.lifetime()).map(|l| Name::new_lifetime(&l)),
-                    },
-                    syntax_ptr,
-                )
            }
            ast::Expr::CallExpr(e) => {
                let callee = self.collect_expr_opt(e.expr());
@@ -814,6 +809,13 @@ impl ExprCollector<'_> {
        }
    }
+    fn collect_label(&mut self, ast_label: ast::Label) -> LabelId {
+        let label = Label {
+            name: ast_label.lifetime().as_ref().map_or_else(Name::missing, Name::new_lifetime),
+        };
+        self.alloc_label(label, AstPtr::new(&ast_label))
+    }
    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
        let pattern = match &pat {
            ast::Pat::IdentPat(bp) => {
@@ -932,6 +934,14 @@ impl ExprCollector<'_> {
                let inner = self.collect_pat_opt(boxpat.pat());
                Pat::Box { inner }
            }
+            ast::Pat::ConstBlockPat(const_block_pat) => {
+                if let Some(expr) = const_block_pat.block_expr() {
+                    let expr_id = self.collect_block(expr);
+                    Pat::ConstBlock(expr_id)
+                } else {
+                    Pat::Missing
+                }
+            }
            // FIXME: implement
            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
        };
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index e5d740a36..6a481769d 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -30,6 +30,12 @@ pub(crate) fn dummy_expr_id() -> ExprId {
 pub type PatId = Idx<Pat>;
 #[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Label {
+    pub name: Name,
+}
+pub type LabelId = Idx<Label>;
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Literal {
    String(String),
    ByteString(Vec<u8>),
@@ -52,22 +58,22 @@ pub enum Expr {
    Block {
        statements: Vec<Statement>,
        tail: Option<ExprId>,
-        label: Option<Name>,
+        label: Option<LabelId>,
    },
    Loop {
        body: ExprId,
-        label: Option<Name>,
+        label: Option<LabelId>,
    },
    While {
        condition: ExprId,
        body: ExprId,
-        label: Option<Name>,
+        label: Option<LabelId>,
    },
    For {
        iterable: ExprId,
        pat: PatId,
        body: ExprId,
-        label: Option<Name>,
+        label: Option<LabelId>,
    },
    Call {
        callee: ExprId,
@@ -114,6 +120,9 @@ pub enum Expr {
    Async {
        body: ExprId,
    },
+    Const {
+        body: ExprId,
+    },
    Cast {
        expr: ExprId,
        type_ref: TypeRef,
@@ -253,7 +262,10 @@ impl Expr {
                    f(*expr);
                }
            }
-            Expr::TryBlock { body } | Expr::Unsafe { body } | Expr::Async { body } => f(*body),
+            Expr::TryBlock { body }
+            | Expr::Unsafe { body }
+            | Expr::Async { body }
+            | Expr::Const { body } => f(*body),
            Expr::Loop { body, .. } => f(*body),
            Expr::While { condition, body, .. } => {
                f(*condition);
@@ -399,12 +411,18 @@ pub enum Pat {
    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
    Ref { pat: PatId, mutability: Mutability },
    Box { inner: PatId },
+    ConstBlock(ExprId),
 }
 impl Pat {
    pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) {
        match self {
-            Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
+            Pat::Range { .. }
+            | Pat::Lit(..)
+            | Pat::Path(..)
+            | Pat::ConstBlock(..)
+            | Pat::Wild
+            | Pat::Missing => {}
            Pat::Bind { subpat, .. } => {
                subpat.iter().copied().for_each(f);
            }
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index c0f108848..30b22f51d 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -238,32 +238,53 @@ pub enum ImportKind {
    BuiltinType,
 }
+/// A way to match import map contents against the search query.
+#[derive(Debug)]
+pub enum SearchMode {
+    /// Import map entry should strictly match the query string.
+    Equals,
+    /// Import map entry should contain the query string.
+    Contains,
+    /// Import map entry should contain all letters from the query string,
+    /// in the same order, but not necessary adjacent.
+    Fuzzy,
+}
 #[derive(Debug)]
 pub struct Query {
    query: String,
    lowercased: String,
-    anchor_end: bool,
+    name_only: bool,
+    search_mode: SearchMode,
    case_sensitive: bool,
    limit: usize,
    exclude_import_kinds: FxHashSet<ImportKind>,
 }
 impl Query {
-    pub fn new(query: &str) -> Self {
+    pub fn new(query: String) -> Self {
+        let lowercased = query.to_lowercase();
        Self {
-            lowercased: query.to_lowercase(),
+            query,
-            query: query.to_string(),
+            lowercased,
-            anchor_end: false,
+            name_only: false,
+            search_mode: SearchMode::Contains,
            case_sensitive: false,
            limit: usize::max_value(),
            exclude_import_kinds: FxHashSet::default(),
        }
    }
-    /// Only returns items whose paths end with the (case-insensitive) query string as their last
+    /// Matches entries' names only, ignoring the rest of
-    /// segment.
+    /// the qualifier.
-    pub fn anchor_end(self) -> Self {
+    /// Example: for `std::marker::PhantomData`, the name is `PhantomData`.
-        Self { anchor_end: true, ..self }
+    pub fn name_only(self) -> Self {
+        Self { name_only: true, ..self }
+    }
+    /// Specifies the way to search for the entries using the query.
+    pub fn search_mode(self, search_mode: SearchMode) -> Self {
+        Self { search_mode, ..self }
    }
    /// Limits the returned number of items to `limit`.
@@ -283,6 +304,40 @@ impl Query {
    }
 }
+fn contains_query(query: &Query, input_path: &ImportPath, enforce_lowercase: bool) -> bool {
+    let mut input = if query.name_only {
+        input_path.segments.last().unwrap().to_string()
+    } else {
+        input_path.to_string()
+    };
+    if enforce_lowercase || !query.case_sensitive {
+        input.make_ascii_lowercase();
+    }
+    let query_string =
+        if !enforce_lowercase && query.case_sensitive { &query.query } else { &query.lowercased };
+    match query.search_mode {
+        SearchMode::Equals => &input == query_string,
+        SearchMode::Contains => input.contains(query_string),
+        SearchMode::Fuzzy => {
+            let mut unchecked_query_chars = query_string.chars();
+            let mut mismatching_query_char = unchecked_query_chars.next();
+            for input_char in input.chars() {
+                match mismatching_query_char {
+                    None => return true,
+                    Some(matching_query_char) if matching_query_char == input_char => {
+                        mismatching_query_char = unchecked_query_chars.next();
+                    }
+                    _ => (),
+                }
+            }
+            mismatching_query_char.is_none()
+        }
+    }
+}
 /// Searches dependencies of `krate` for an importable path matching `query`.
 ///
 /// This returns a list of items that could be imported from dependencies of `krate`.
@@ -312,39 +367,29 @@ pub fn search_dependencies<'a>(
            let importables = &import_map.importables[indexed_value.value as usize..];
            // Path shared by the importable items in this group.
-            let path = &import_map.map[&importables[0]].path;
+            let common_importables_path = &import_map.map[&importables[0]].path;
+            if !contains_query(&query, common_importables_path, true) {
-            if query.anchor_end {
+                continue;
-                // Last segment must match query.
-                let last = path.segments.last().unwrap().to_string();
-                if last.to_lowercase() != query.lowercased {
-                    continue;
-                }
            }
+            let common_importables_path_fst = fst_path(common_importables_path);
            // Add the items from this `ModPath` group. Those are all subsequent items in
            // `importables` whose paths match `path`.
            let iter = importables
                .iter()
                .copied()
                .take_while(|item| {
-                    let item_path = &import_map.map[item].path;
+                    common_importables_path_fst == fst_path(&import_map.map[item].path)
-                    fst_path(item_path) == fst_path(path)
                })
                .filter(|&item| match item_import_kind(item) {
                    Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind),
                    None => true,
+                })
+                .filter(|item| {
+                    !query.case_sensitive // we've already checked the common importables path case-insensitively
+                        || contains_query(&query, &import_map.map[item].path, false)
                });
+            res.extend(iter);
-            if query.case_sensitive {
-                // FIXME: This does not do a subsequence match.
-                res.extend(iter.filter(|item| {
-                    let item_path = &import_map.map[item].path;
-                    item_path.to_string().contains(&query.query)
-                }));
-            } else {
-                res.extend(iter);
-            }
            if res.len() >= query.limit {
                res.truncate(query.limit);
@@ -387,8 +432,9 @@ fn item_import_kind(item: ItemInNs) -> Option<ImportKind> {
 mod tests {
    use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
    use expect_test::{expect, Expect};
+    use stdx::format_to;
-    use crate::{test_db::TestDB, AssocContainerId, Lookup};
+    use crate::{data::FunctionData, test_db::TestDB, AssocContainerId, Lookup};
    use super::*;
@@ -407,14 +453,32 @@ mod tests {
            .into_iter()
            .filter_map(|item| {
                let mark = match item {
+                    ItemInNs::Types(ModuleDefId::FunctionId(_))
+                    | ItemInNs::Values(ModuleDefId::FunctionId(_)) => "f",
                    ItemInNs::Types(_) => "t",
                    ItemInNs::Values(_) => "v",
                    ItemInNs::Macros(_) => "m",
                };
-                let item = assoc_to_trait(&db, item);
                item.krate(db.upcast()).map(|krate| {
                    let map = db.import_map(krate);
-                    let path = map.path_of(item).unwrap();
+                    let path = match assoc_to_trait(&db, item) {
+                        Some(trait_) => {
+                            let mut full_path = map.path_of(trait_).unwrap().to_string();
+                            if let ItemInNs::Types(ModuleDefId::FunctionId(function_id))
+                            | ItemInNs::Values(ModuleDefId::FunctionId(function_id)) = item
+                            {
+                                format_to!(
+                                    full_path,
+                                    "::{}",
+                                    FunctionData::fn_data_query(&db, function_id).name,
+                                );
+                            }
+                            full_path
+                        }
+                        None => map.path_of(item).unwrap().to_string(),
+                    };
                    format!(
                        "{}::{} ({})\n",
                        crate_graph[krate].display_name.as_ref().unwrap(),
@@ -427,15 +491,15 @@ mod tests {
        expect.assert_eq(&actual)
    }
-    fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> ItemInNs {
+    fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> Option<ItemInNs> {
        let assoc: AssocItemId = match item {
            ItemInNs::Types(it) | ItemInNs::Values(it) => match it {
                ModuleDefId::TypeAliasId(it) => it.into(),
                ModuleDefId::FunctionId(it) => it.into(),
                ModuleDefId::ConstId(it) => it.into(),
-                _ => return item,
+                _ => return None,
            },
-            _ => return item,
+            _ => return None,
        };
        let container = match assoc {
@@ -445,8 +509,8 @@ mod tests {
        };
        match container {
-            AssocContainerId::TraitId(it) => ItemInNs::Types(it.into()),
+            AssocContainerId::TraitId(it) => Some(ItemInNs::Types(it.into())),
-            _ => item,
+            _ => None,
        }
    }
@@ -685,7 +749,7 @@ mod tests {
    }
    #[test]
-    fn search() {
+    fn search_mode() {
        let ra_fixture = r#"
            //- /main.rs crate:main deps:dep
            //- /dep.rs crate:dep deps:tdep
@@ -713,28 +777,96 @@ mod tests {
        check_search(
            ra_fixture,
            "main",
-            Query::new("fmt"),
+            Query::new("fmt".to_string()).search_mode(SearchMode::Fuzzy),
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (t)
                dep::Fmt (v)
                dep::Fmt (m)
                dep::fmt::Display (t)
-                dep::format (v)
+                dep::format (f)
+                dep::fmt::Display::fmt (f)
+            "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).search_mode(SearchMode::Equals),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+                dep::Fmt (v)
+                dep::Fmt (m)
+                dep::fmt::Display::fmt (f)
+            "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).search_mode(SearchMode::Contains),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+                dep::Fmt (v)
+                dep::Fmt (m)
                dep::fmt::Display (t)
+                dep::fmt::Display::fmt (f)
            "#]],
        );
+    }
+    #[test]
+    fn name_only() {
+        let ra_fixture = r#"
+            //- /main.rs crate:main deps:dep
+            //- /dep.rs crate:dep deps:tdep
+            use tdep::fmt as fmt_dep;
+            pub mod fmt {
+                pub trait Display {
+                    fn fmt();
+                }
+            }
+            #[macro_export]
+            macro_rules! Fmt {
+                () => {};
+            }
+            pub struct Fmt;
+            pub fn format() {}
+            pub fn no() {}
+            //- /tdep.rs crate:tdep
+            pub mod fmt {
+                pub struct NotImportableFromMain;
+            }
+        "#;
        check_search(
            ra_fixture,
            "main",
-            Query::new("fmt").anchor_end(),
+            Query::new("fmt".to_string()),
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (t)
                dep::Fmt (v)
                dep::Fmt (m)
                dep::fmt::Display (t)
+                dep::fmt::Display::fmt (f)
+            "#]],
+        );
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt".to_string()).name_only(),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+                dep::Fmt (v)
+                dep::Fmt (m)
+                dep::fmt::Display::fmt (f)
            "#]],
        );
    }
@@ -752,7 +884,7 @@ mod tests {
        check_search(
            ra_fixture,
            "main",
-            Query::new("FMT"),
+            Query::new("FMT".to_string()),
            expect![[r#"
                dep::fmt (t)
                dep::fmt (v)
@@ -764,7 +896,7 @@ mod tests {
        check_search(
            ra_fixture,
            "main",
-            Query::new("FMT").case_sensitive(),
+            Query::new("FMT".to_string()).case_sensitive(),
            expect![[r#"
                dep::FMT (t)
                dep::FMT (v)
@@ -793,7 +925,7 @@ mod tests {
        pub fn no() {}
    "#,
            "main",
-            Query::new("").limit(2),
+            Query::new("".to_string()).limit(2),
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (t)
@@ -814,7 +946,7 @@ mod tests {
        check_search(
            ra_fixture,
            "main",
-            Query::new("FMT"),
+            Query::new("FMT".to_string()),
            expect![[r#"
                dep::fmt (t)
                dep::fmt (v)
@@ -826,7 +958,7 @@ mod tests {
        check_search(
            ra_fixture,
            "main",
-            Query::new("FMT").exclude_import_kind(ImportKind::Adt),
+            Query::new("FMT".to_string()).exclude_import_kind(ImportKind::Adt),
            expect![[r#""#]],
        );
    }
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index ffd0381d4..5682e122d 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -249,7 +249,7 @@ impl CrateDefMap {
                    buf.push_str(" _");
                }
-                buf.push_str("\n");
+                buf.push('\n');
            }
            for (name, child) in map.modules[module].children.iter() {
@@ -454,7 +454,7 @@ mod diagnostics {
                                    });
                                for token in tokens {
                                    if token.kind() == SyntaxKind::IDENT
-                                        && token.to_string() == *name
+                                        && token.text() == name.as_str()
                                    {
                                        precise_location = Some(token.text_range());
                                        break 'outer;
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs
index b4ccd4488..af3262439 100644
--- a/crates/hir_def/src/nameres/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/mod_resolution.rs
@@ -79,7 +79,7 @@ impl ModDir {
        for candidate in candidate_files.iter() {
            let path = AnchoredPath { anchor: file_id, path: candidate.as_str() };
            if let Some(file_id) = db.resolve_path(path) {
-                let is_mod_rs = candidate.ends_with("mod.rs");
+                let is_mod_rs = candidate.ends_with("/mod.rs");
                let (dir_path, root_non_dir_owner) = if is_mod_rs || attr_path.is_some() {
                    (DirPath::empty(), false)
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index f9bf5bc72..e5e9e8ca1 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -677,7 +677,7 @@ fn macro_expansion_overflow() {
        r#"
 macro_rules! a {
    ($e:expr; $($t:tt)*) => {
-        b!($($t)*);
+        b!(static = (); $($t)*);
    };
    () => {};
 }
@@ -689,7 +689,7 @@ macro_rules! b {
    () => {};
 }
-b! { static = #[] (); }
+b! { static = #[] ();}
 "#,
        expect![[r#"
            crate
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index dddbbcdac..80b60d59f 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -259,7 +259,8 @@ fn format_args_expand(
    }
    for arg in &mut args {
        // Remove `key =`.
-        if matches!(arg.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=') {
+        if matches!(arg.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=' && p.spacing != tt::Spacing::Joint)
+        {
            arg.drain(..2);
        }
    }
@@ -563,6 +564,7 @@ mod tests {
                let args = macro_call.token_tree().unwrap();
                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
+                let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
                let arg_id = db.intern_eager_expansion({
                    EagerCallLoc {
@@ -570,7 +572,7 @@ mod tests {
                        fragment: FragmentKind::Expr,
                        subtree: Arc::new(parsed_args.clone()),
                        krate,
-                        file_id: file_id.into(),
+                        call: call_id,
                    }
                });
@@ -580,7 +582,7 @@ mod tests {
                    fragment,
                    subtree: Arc::new(subtree),
                    krate,
-                    file_id: file_id.into(),
+                    call: call_id,
                };
                let id: MacroCallId = db.intern_eager_expansion(eager).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 4477d867f..06f0a3ed9 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 use base_db::{salsa, SourceDatabase};
 use mbe::{ExpandError, ExpandResult, MacroRules};
 use parser::FragmentKind;
-use syntax::{algo::diff, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
+use syntax::{algo::diff, ast::NameOwner, AstNode, GreenNode, Parse, SyntaxKind::*, SyntaxNode};
 use crate::{
    ast_id_map::AstIdMap, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerCallLoc, EagerMacroId,
@@ -129,11 +129,11 @@ fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
        MacroDefKind::Declarative => {
-            let macro_call = match id.ast_id?.to_node(db) {
+            let macro_rules = match id.ast_id?.to_node(db) {
                syntax::ast::Macro::MacroRules(mac) => mac,
                syntax::ast::Macro::MacroDef(_) => return None,
            };
-            let arg = macro_call.token_tree()?;
+            let arg = macro_rules.token_tree()?;
            let (tt, tmap) = mbe::ast_to_token_tree(&arg).or_else(|| {
                log::warn!("fail on macro_def to token tree: {:#?}", arg);
                None
@@ -141,7 +141,8 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander,
            let rules = match MacroRules::parse(&tt) {
                Ok(it) => it,
                Err(err) => {
-                    log::warn!("fail on macro_def parse: error: {:#?} {:#?}", err, tt);
+                    let name = macro_rules.name().map(|n| n.to_string()).unwrap_or_default();
+                    log::warn!("fail on macro_def parse ({}): {:?} {:#?}", name, err, tt);
                    return None;
                }
            };
@@ -270,7 +271,7 @@ fn expand_proc_macro(
        _ => unreachable!(),
    };
-    expander.expand(db, lazy_id, &macro_arg.0)
+    expander.expand(db, loc.krate, &macro_arg.0)
 }
 fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 0229a836e..6354b090d 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -110,6 +110,9 @@ pub fn expand_eager_macro(
        || err("malformed macro invocation"),
    )?;
+    let ast_map = db.ast_id_map(macro_call.file_id);
+    let call_id = InFile::new(macro_call.file_id, ast_map.ast_id(&macro_call.value));
    // Note:
    // When `lazy_expand` is called, its *parent* file must be already exists.
    // Here we store an eager macro id for the argument expanded subtree here
@@ -120,7 +123,7 @@ pub fn expand_eager_macro(
            fragment: FragmentKind::Expr,
            subtree: Arc::new(parsed_args.clone()),
            krate,
-            file_id: macro_call.file_id,
+            call: call_id,
        }
    });
    let arg_file_id: MacroCallId = arg_id.into();
@@ -141,13 +144,8 @@ pub fn expand_eager_macro(
        let res = eager.expand(db, arg_id, &subtree);
        let (subtree, fragment) = diagnostic_sink.expand_result_option(res)?;
-        let eager = EagerCallLoc {
+        let eager =
-            def,
+            EagerCallLoc { def, fragment, subtree: Arc::new(subtree), krate, call: call_id };
-            fragment,
-            subtree: Arc::new(subtree),
-            krate,
-            file_id: macro_call.file_id,
-        };
        Ok(db.intern_eager_expansion(eager))
    } else {
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index d486186e5..3fa1b1d77 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -83,7 +83,7 @@ impl HirFileId {
                    }
                    MacroCallId::EagerMacro(id) => {
                        let loc = db.lookup_intern_eager_expansion(id);
-                        loc.file_id
+                        loc.call.file_id
                    }
                };
                file_id.original_file(db)
@@ -103,7 +103,7 @@ impl HirFileId {
                }
                MacroCallId::EagerMacro(id) => {
                    let loc = db.lookup_intern_eager_expansion(id);
-                    loc.file_id
+                    loc.call.file_id
                }
            };
        }
@@ -114,17 +114,16 @@ impl HirFileId {
    pub fn call_node(self, db: &dyn db::AstDatabase) -> Option<InFile<SyntaxNode>> {
        match self.0 {
            HirFileIdRepr::FileId(_) => None,
-            HirFileIdRepr::MacroFile(macro_file) => {
+            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
-                let lazy_id = match macro_file.macro_call_id {
+                MacroCallId::LazyMacro(lazy_id) => {
-                    MacroCallId::LazyMacro(id) => id,
+                    let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
-                    MacroCallId::EagerMacro(_id) => {
+                    Some(loc.kind.node(db))
-                        // FIXME: handle call node for eager macro
+                }
-                        return None;
+                MacroCallId::EagerMacro(id) => {
-                    }
+                    let loc: EagerCallLoc = db.lookup_intern_eager_expansion(id);
-                };
+                    Some(loc.call.with_value(loc.call.to_node(db).syntax().clone()))
-                let loc = db.lookup_intern_macro(lazy_id);
+                }
-                Some(loc.kind.node(db))
+            },
-            }
        }
    }
@@ -304,7 +303,7 @@ pub struct EagerCallLoc {
    pub(crate) fragment: FragmentKind,
    pub(crate) subtree: Arc<tt::Subtree>,
    pub(crate) krate: CrateId,
-    pub(crate) file_id: HirFileId,
+    pub(crate) call: AstId<ast::MacroCall>,
 }
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
diff --git a/crates/hir_expand/src/proc_macro.rs b/crates/hir_expand/src/proc_macro.rs
index 38882d2b6..7c77f6ce0 100644
--- a/crates/hir_expand/src/proc_macro.rs
+++ b/crates/hir_expand/src/proc_macro.rs
@@ -1,6 +1,6 @@
 //! Proc Macro Expander stub
-use crate::{db::AstDatabase, LazyMacroId};
+use crate::db::AstDatabase;
 use base_db::{CrateId, ProcMacroId};
 use tt::buffer::{Cursor, TokenBuffer};
@@ -32,7 +32,7 @@ impl ProcMacroExpander {
    pub fn expand(
        self,
        db: &dyn AstDatabase,
-        _id: LazyMacroId,
+        calling_crate: CrateId,
        tt: &tt::Subtree,
    ) -> Result<tt::Subtree, mbe::ExpandError> {
        match self.proc_macro_id {
@@ -47,7 +47,10 @@ impl ProcMacroExpander {
                let tt = remove_derive_attrs(tt)
                    .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
-                proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
+                // Proc macros have access to the environment variables of the invoking crate.
+                let env = &krate_graph[calling_crate].env;
+                proc_macro.expander.expand(&tt, None, &env).map_err(mbe::ExpandError::from)
            }
            None => Err(mbe::ExpandError::UnresolvedProcMacro),
        }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 289e812fe..2dfccd191 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -10,16 +10,16 @@ edition = "2018"
 doctest = false
 [dependencies]
-itertools = "0.9.0"
+itertools = "0.10.0"
 arrayvec = "0.5.1"
 smallvec = "1.2.0"
 ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.43", default-features = false }
+chalk-solve = { version = "0.45", default-features = false }
-chalk-ir = "0.43"
+chalk-ir = "0.45"
-chalk-recursive = "0.43"
+chalk-recursive = "0.45"
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 2cdce2cef..f2fc69b2f 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -143,7 +143,7 @@ impl<'a> InferenceContext<'a> {
                    self.breakables.push(BreakableContext {
                        may_break: false,
                        break_ty: break_ty.clone(),
-                        label: label.clone(),
+                        label: label.map(|label| self.body[label].name.clone()),
                    });
                    let ty = self.infer_block(statements, *tail, &Expectation::has_type(break_ty));
                    let ctxt = self.breakables.pop().expect("breakable stack broken");
@@ -155,7 +155,7 @@ impl<'a> InferenceContext<'a> {
                }
                None => self.infer_block(statements, *tail, expected),
            },
-            Expr::Unsafe { body } => self.infer_expr(*body, expected),
+            Expr::Unsafe { body } | Expr::Const { body } => self.infer_expr(*body, expected),
            Expr::TryBlock { body } => {
                let _inner = self.infer_expr(*body, expected);
                // FIXME should be std::result::Result<{inner}, _>
@@ -172,7 +172,7 @@ impl<'a> InferenceContext<'a> {
                self.breakables.push(BreakableContext {
                    may_break: false,
                    break_ty: self.table.new_type_var(),
-                    label: label.clone(),
+                    label: label.map(|label| self.body[label].name.clone()),
                });
                self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
@@ -191,7 +191,7 @@ impl<'a> InferenceContext<'a> {
                self.breakables.push(BreakableContext {
                    may_break: false,
                    break_ty: Ty::Unknown,
-                    label: label.clone(),
+                    label: label.map(|label| self.body[label].name.clone()),
                });
                // while let is desugared to a match loop, so this is always simple while
                self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
@@ -207,7 +207,7 @@ impl<'a> InferenceContext<'a> {
                self.breakables.push(BreakableContext {
                    may_break: false,
                    break_ty: Ty::Unknown,
-                    label: label.clone(),
+                    label: label.map(|label| self.body[label].name.clone()),
                });
                let pat_ty =
                    self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item());
@@ -648,6 +648,8 @@ impl<'a> InferenceContext<'a> {
            }
            Expr::Array(array) => {
                let elem_ty = match &expected.ty {
+                    // FIXME: remove when https://github.com/rust-lang/rust/issues/80501 is fixed
+                    #[allow(unreachable_patterns)]
                    ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
                        st.as_single().clone()
                    }
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index b70ec55eb..d974f805b 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -243,6 +243,9 @@ impl<'a> InferenceContext<'a> {
                }
                None => Ty::Unknown,
            },
+            Pat::ConstBlock(expr) => {
+                self.infer_expr(*expr, &Expectation::has_type(expected.clone()))
+            }
            Pat::Missing => Ty::Unknown,
        };
        // use a new type variable if we got Ty::Unknown here
@@ -264,8 +267,9 @@ fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
        | Pat::Range { .. }
        | Pat::Slice { .. } => true,
        Pat::Or(pats) => pats.iter().all(|p| is_non_ref_pat(body, *p)),
-        // FIXME: Path/Lit might actually evaluate to ref, but inference is unimplemented.
+        // FIXME: ConstBlock/Path/Lit might actually evaluate to ref, but inference is unimplemented.
        Pat::Path(..) => true,
+        Pat::ConstBlock(..) => true,
        Pat::Lit(expr) => match body[*expr] {
            Expr::Literal(Literal::String(..)) => false,
            _ => true,
diff --git a/crates/hir_ty/src/tests/patterns.rs b/crates/hir_ty/src/tests/patterns.rs
index 5a5f48fd0..2053d8f56 100644
--- a/crates/hir_ty/src/tests/patterns.rs
+++ b/crates/hir_ty/src/tests/patterns.rs
@@ -774,3 +774,33 @@ fn foo(tuple: Tuple) {
        "#]],
    );
 }
+#[test]
+fn const_block_pattern() {
+    check_infer(
+        r#"
+struct Foo(usize);
+fn foo(foo: Foo) {
+    match foo {
+        const { Foo(15 + 32) } => {},
+        _ => {}
+    }
+}"#,
+        expect![[r#"
+            26..29 'foo': Foo
+            36..115 '{     ...   } }': ()
+            42..113 'match ...     }': ()
+            48..51 'foo': Foo
+            62..84 'const ... 32) }': Foo
+            68..84 '{ Foo(... 32) }': Foo
+            70..73 'Foo': Foo(usize) -> Foo
+            70..82 'Foo(15 + 32)': Foo
+            74..76 '15': usize
+            74..81 '15 + 32': usize
+            79..81 '32': usize
+            88..90 '{}': ()
+            100..101 '_': Foo
+            105..107 '{}': ()
+        "#]],
+    );
+}
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index a569223b4..a61282d5a 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -1894,6 +1894,7 @@ fn effects_smoke_test() {
            let x = unsafe { 92 };
            let y = async { async { () }.await };
            let z = try { () };
+            let w = const { 92 };
            let t = 'a: { 92 };
        }
@@ -1905,7 +1906,7 @@ fn effects_smoke_test() {
        }
        "#,
        expect![[r#"
-            16..136 '{     ...2 }; }': ()
+            16..162 '{     ...2 }; }': ()
            26..27 'x': i32
            30..43 'unsafe { 92 }': i32
            37..43 '{ 92 }': i32
@@ -1921,9 +1922,13 @@ fn effects_smoke_test() {
            99..109 'try { () }': {unknown}
            103..109 '{ () }': ()
            105..107 '()': ()
-            119..120 't': i32
+            119..120 'w': i32
-            127..133 '{ 92 }': i32
+            123..135 'const { 92 }': i32
-            129..131 '92': i32
+            129..135 '{ 92 }': i32
+            131..133 '92': i32
+            145..146 't': i32
+            153..159 '{ 92 }': i32
+            155..157 '92': i32
        "#]],
    )
 }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index 69eae6f79..2196af677 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -56,8 +56,13 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
    fn adt_datum(&self, struct_id: AdtId) -> Arc<StructDatum> {
        self.db.struct_datum(self.krate, struct_id)
    }
-    fn adt_repr(&self, _struct_id: AdtId) -> rust_ir::AdtRepr {
+    fn adt_repr(&self, _struct_id: AdtId) -> Arc<rust_ir::AdtRepr<Interner>> {
-        rust_ir::AdtRepr { repr_c: false, repr_packed: false }
+        // FIXME: keep track of these
+        Arc::new(rust_ir::AdtRepr { c: false, packed: false, int: None })
+    }
+    fn discriminant_type(&self, _ty: chalk_ir::Ty<Interner>) -> chalk_ir::Ty<Interner> {
+        // FIXME: keep track of this
+        chalk_ir::TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::U32)).intern(&Interner)
    }
    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
        self.db.impl_datum(self.krate, impl_id)
@@ -457,6 +462,7 @@ fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
        "fn" => WellKnownTrait::Fn,
        "unsize" => WellKnownTrait::Unsize,
        "coerce_unsized" => WellKnownTrait::CoerceUnsized,
+        "discriminant_kind" => WellKnownTrait::DiscriminantKind,
        _ => return None,
    })
 }
@@ -473,6 +479,7 @@ fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
        WellKnownTrait::Unsize => "unsize",
        WellKnownTrait::Unpin => "unpin",
        WellKnownTrait::CoerceUnsized => "coerce_unsized",
+        WellKnownTrait::DiscriminantKind => "discriminant_kind",
    }
 }
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index 4d483580d..f1544dbe0 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 either = "1.5.3"
 indexmap = "1.4.0"
-itertools = "0.9.0"
+itertools = "0.10.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 oorandom = "11.1.2"
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 049f808dc..79d126ff2 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -199,6 +199,12 @@ fn check_unnecessary_braces_in_use_statement(
 ) -> Option<()> {
    let use_tree_list = ast::UseTreeList::cast(node.clone())?;
    if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
+        // If there is a comment inside the bracketed `use`,
+        // assume it is a commented out module path and don't show diagnostic.
+        if use_tree_list.has_inner_comment() {
+            return Some(());
+        }
        let use_range = use_tree_list.syntax().text_range();
        let edit =
            text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(&single_use_tree)
@@ -248,35 +254,7 @@ mod tests {
    ///  * a diagnostic is produced
    ///  * this 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(super) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
+    pub(crate) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
-        let after = trim_indent(ra_fixture_after);
-        let (analysis, file_position) = fixture::position(ra_fixture_before);
-        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
-            .unwrap()
-            .pop()
-            .unwrap();
-        let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
-        let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
-        let actual = {
-            let mut actual = target_file_contents.to_string();
-            edit.apply(&mut actual);
-            actual
-        };
-        assert_eq_text!(&after, &actual);
-        assert!(
-            fix.fix_trigger_range.contains_inclusive(file_position.offset),
-            "diagnostic fix range {:?} does not touch cursor position {:?}",
-            fix.fix_trigger_range,
-            file_position.offset
-        );
-    }
-    /// Similar to `check_fix`, but applies all the available fixes.
-    fn check_fixes(ra_fixture_before: &str, ra_fixture_after: &str) {
        let after = trim_indent(ra_fixture_after);
        let (analysis, file_position) = fixture::position(ra_fixture_before);
@@ -286,10 +264,12 @@ mod tests {
            .pop()
            .unwrap();
        let fix = diagnostic.fix.unwrap();
-        let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
        let actual = {
-            let mut actual = target_file_contents.to_string();
+            let file_id = fix.source_change.source_file_edits.first().unwrap().file_id;
+            let mut actual = analysis.file_text(file_id).unwrap().to_string();
            // Go from the last one to the first one, so that ranges won't be affected by previous edits.
+            // FIXME: https://github.com/rust-analyzer/rust-analyzer/issues/4901#issuecomment-644675309
            for edit in fix.source_change.source_file_edits.iter().rev() {
                edit.edit.apply(&mut actual);
            }
@@ -305,29 +285,6 @@ mod tests {
        );
    }
-    /// Checks that a diagnostic applies to the file containing the `<|>` cursor marker
-    /// which has a fix that can apply to other files.
-    fn check_apply_diagnostic_fix_in_other_file(ra_fixture_before: &str, ra_fixture_after: &str) {
-        let ra_fixture_after = &trim_indent(ra_fixture_after);
-        let (analysis, file_pos) = fixture::position(ra_fixture_before);
-        let current_file_id = file_pos.file_id;
-        let diagnostic = analysis
-            .diagnostics(&DiagnosticsConfig::default(), current_file_id)
-            .unwrap()
-            .pop()
-            .unwrap();
-        let mut fix = diagnostic.fix.unwrap();
-        let edit = fix.source_change.source_file_edits.pop().unwrap();
-        let changed_file_id = edit.file_id;
-        let before = analysis.file_text(changed_file_id).unwrap();
-        let actual = {
-            let mut actual = before.to_string();
-            edit.edit.apply(&mut actual);
-            actual
-        };
-        assert_eq_text!(ra_fixture_after, &actual);
-    }
    /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
    /// apply to the file containing the cursor.
    pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
@@ -619,6 +576,7 @@ fn test_fn() {
                                                ),
                                                path: "foo.rs",
                                            },
+                                            initial_contents: "",
                                        },
                                    ],
                                    is_snippet: false,
@@ -686,6 +644,22 @@ mod a {
 }
 "#,
        );
+        check_no_diagnostics(
+            r#"
+use a;
+use a::{
+    c,
+    // d::e
+};
+mod a {
+    mod c {}
+    mod d {
+        mod e {}
+    }
+}
+"#,
+        );
        check_fix(
            r"
            mod b {}
@@ -763,25 +737,25 @@ struct Foo {
    #[test]
    fn test_add_field_in_other_file_from_usage() {
-        check_apply_diagnostic_fix_in_other_file(
+        check_fix(
-            r"
+            r#"
-            //- /main.rs
+//- /main.rs
-            mod foo;
+mod foo;
-            fn main() {
+fn main() {
-                <|>foo::Foo { bar: 3, baz: false};
+    foo::Foo { bar: 3, <|>baz: false};
-            }
+}
-            //- /foo.rs
+//- /foo.rs
-            struct Foo {
+struct Foo {
-                bar: i32
+    bar: i32
-            }
+}
-            ",
+"#,
-            r"
+            r#"
-            struct Foo {
+struct Foo {
-                bar: i32,
+    bar: i32,
-                pub(crate) baz: bool
+    pub(crate) baz: bool
-            }
+}
-            ",
+"#,
        )
    }
@@ -801,7 +775,7 @@ struct Foo {
    #[test]
    fn test_rename_incorrect_case() {
-        check_fixes(
+        check_fix(
            r#"
 pub struct test_struct<|> { one: i32 }
@@ -818,7 +792,7 @@ pub fn some_fn(val: TestStruct) -> TestStruct {
 "#,
        );
-        check_fixes(
+        check_fix(
            r#"
 pub fn some_fn(NonSnakeCase<|>: u8) -> u8 {
    NonSnakeCase
@@ -831,7 +805,7 @@ pub fn some_fn(non_snake_case: u8) -> u8 {
 "#,
        );
-        check_fixes(
+        check_fix(
            r#"
 pub fn SomeFn<|>(val: u8) -> u8 {
    if val != 0 { SomeFn(val - 1) } else { val }
@@ -844,7 +818,7 @@ pub fn some_fn(val: u8) -> u8 {
 "#,
        );
-        check_fixes(
+        check_fix(
            r#"
 fn some_fn() {
    let whatAWeird_Formatting<|> = 10;
@@ -873,7 +847,7 @@ fn foo() {
    #[test]
    fn test_rename_incorrect_case_struct_method() {
-        check_fixes(
+        check_fix(
            r#"
 pub struct TestStruct;
@@ -894,4 +868,17 @@ impl TestStruct {
 "#,
        );
    }
+    #[test]
+    fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
+        let input = r#"fn FOO<|>() {}"#;
+        let expected = r#"fn foo() {}"#;
+        let (analysis, file_position) = fixture::position(input);
+        let diagnostics =
+            analysis.diagnostics(&DiagnosticsConfig::default(), file_position.file_id).unwrap();
+        assert_eq!(diagnostics.len(), 1);
+        check_fix(input, expected);
+    }
 }
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index e8b896623..d79f5c170 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -40,6 +40,7 @@ impl DiagnosticWithFix for UnresolvedModule {
                    anchor: self.file.original_file(sema.db),
                    path: self.candidate.clone(),
                },
+                initial_contents: "".to_string(),
            }
            .into(),
            unresolved_module.syntax().text_range(),
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index cd8ec54fa..6431e7d6d 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -5,7 +5,7 @@ use std::fmt;
 use either::Either;
 use hir::{AssocItem, Documentation, FieldSource, HasAttrs, HasSource, InFile, ModuleSource};
 use ide_db::{
-    base_db::{FileId, SourceDatabase},
+    base_db::{FileId, FileRange, SourceDatabase},
    symbol_index::FileSymbolKind,
 };
 use ide_db::{defs::Definition, RootDatabase};
@@ -28,6 +28,7 @@ pub enum SymbolKind {
    ValueParam,
    SelfParam,
    Local,
+    Label,
    Function,
    Const,
    Static,
@@ -223,6 +224,7 @@ impl TryToNav for Definition {
            Definition::Local(it) => Some(it.to_nav(db)),
            Definition::TypeParam(it) => Some(it.to_nav(db)),
            Definition::LifetimeParam(it) => Some(it.to_nav(db)),
+            Definition::Label(it) => Some(it.to_nav(db)),
        }
    }
 }
@@ -421,6 +423,27 @@ impl ToNav for hir::Local {
    }
 }
+impl ToNav for hir::Label {
+    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
+        let src = self.source(db);
+        let node = src.value.syntax();
+        let FileRange { file_id, range } = src.with_value(node).original_file_range(db);
+        let focus_range =
+            src.value.lifetime().and_then(|lt| lt.lifetime_ident_token()).map(|lt| lt.text_range());
+        let name = self.name(db).to_string().into();
+        NavigationTarget {
+            file_id,
+            name,
+            kind: Some(SymbolKind::Label),
+            full_range: range,
+            focus_range,
+            container_name: None,
+            description: None,
+            docs: None,
+        }
+    }
+}
 impl ToNav for hir::TypeParam {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index b61ea0b3e..e10516f43 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -193,7 +193,8 @@ fn rewrite_intra_doc_link(
        Definition::SelfType(_)
        | Definition::Local(_)
        | Definition::TypeParam(_)
-        | Definition::LifetimeParam(_) => return None,
+        | Definition::LifetimeParam(_)
+        | Definition::Label(_) => return None,
    }?;
    let krate = resolved.module(db)?.krate();
    let canonical_path = resolved.canonical_path(db)?;
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 431da5d9c..912144f8b 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -750,6 +750,31 @@ fn test() {
    }
    #[test]
+    fn goto_through_included_file() {
+        check(
+            r#"
+//- /main.rs
+#[rustc_builtin_macro]
+macro_rules! include {}
+  include!("foo.rs");
+//^^^^^^^^^^^^^^^^^^^
+fn f() {
+    foo<|>();
+}
+mod confuse_index {
+    pub fn foo() {}
+}
+//- /foo.rs
+fn foo() {}
+        "#,
+        );
+    }
+    #[test]
    fn goto_for_type_param() {
        check(
            r#"
@@ -1105,4 +1130,19 @@ fn foo<T>() where T: for<'a> Foo<&'a<|> (u8, u16)>, {}
 "#,
        );
    }
+    #[test]
+    fn goto_label() {
+        check(
+            r#"
+fn foo<'foo>(_: &'foo ()) {
+    'foo: {
+  //^^^^
+        'bar: loop {
+            break 'foo<|>;
+        }
+    }
+}"#,
+        )
+    }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 52f993cc9..73245fbe7 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -370,7 +370,7 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
                Adt::Enum(it) => from_def_source(db, it, mod_path),
            })
        }
-        Definition::TypeParam(_) | Definition::LifetimeParam(_) => {
+        Definition::TypeParam(_) | Definition::LifetimeParam(_) | Definition::Label(_) => {
            // FIXME: Hover for generic param
            None
        }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index dbad9a84f..b3331f03f 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -79,7 +79,7 @@ pub use crate::{
        HighlightedRange,
    },
 };
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind, ResolvedAssist};
+pub use assists::{Assist, AssistConfig, AssistId, AssistKind};
 pub use completion::{
    CompletionConfig, CompletionItem, CompletionItemKind, CompletionResolveCapability,
    CompletionScore, ImportEdit, InsertTextFormat,
@@ -475,7 +475,7 @@ impl Analysis {
        config: &CompletionConfig,
        position: FilePosition,
        full_import_path: &str,
-        imported_name: &str,
+        imported_name: String,
    ) -> Cancelable<Vec<TextEdit>> {
        Ok(self
            .with_db(|db| {
@@ -490,23 +490,17 @@ impl Analysis {
            .unwrap_or_default())
    }
-    /// Computes resolved assists with source changes for the given position.
+    /// Computes assists (aka code actions aka intentions) for the given
-    pub fn resolved_assists(
+    /// position. If `resolve == false`, computes enough info to show the
-        &self,
+    /// lightbulb list in the editor, but doesn't compute actual edits, to
-        config: &AssistConfig,
+    /// improve performance.
-        frange: FileRange,
+    pub fn assists(
-    ) -> Cancelable<Vec<ResolvedAssist>> {
-        self.with_db(|db| assists::Assist::resolved(db, config, frange))
-    }
-    /// Computes unresolved assists (aka code actions aka intentions) for the given
-    /// position.
-    pub fn unresolved_assists(
        &self,
        config: &AssistConfig,
+        resolve: bool,
        frange: FileRange,
    ) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| Assist::unresolved(db, config, frange))
+        self.with_db(|db| Assist::get(db, config, resolve, frange))
    }
    /// Computes the set of diagnostics for the given file.
@@ -535,6 +529,14 @@ impl Analysis {
        self.with_db(|db| references::rename::prepare_rename(db, position))
    }
+    pub fn will_rename_file(
+        &self,
+        file_id: FileId,
+        new_name_stem: &str,
+    ) -> Cancelable<Option<SourceChange>> {
+        self.with_db(|db| references::rename::will_rename_file(db, file_id, new_name_stem))
+    }
    pub fn structural_search_replace(
        &self,
        query: &str,
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 18ea19305..21b2d7ca1 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -130,7 +130,7 @@ pub(crate) fn find_all_refs(
                kind = ReferenceKind::FieldShorthandForLocal;
            }
        }
-    } else if let Definition::LifetimeParam(_) = def {
+    } else if matches!(def, Definition::LifetimeParam(_) | Definition::Label(_)) {
        kind = ReferenceKind::Lifetime;
    };
@@ -147,20 +147,20 @@ fn find_name(
 ) -> Option<RangeInfo<Definition>> {
    if let Some(name) = opt_name {
        let def = NameClass::classify(sema, &name)?.referenced_or_defined(sema.db);
-        let range = name.syntax().text_range();
+        let FileRange { range, .. } = sema.original_range(name.syntax());
        return Some(RangeInfo::new(range, def));
    }
-    let (text_range, def) = if let Some(lifetime) =
+    let (FileRange { range, .. }, def) = if let Some(lifetime) =
        sema.find_node_at_offset_with_descend::<ast::Lifetime>(&syntax, position.offset)
    {
        if let Some(def) = NameRefClass::classify_lifetime(sema, &lifetime)
            .map(|class| NameRefClass::referenced(class, sema.db))
        {
-            (lifetime.syntax().text_range(), def)
+            (sema.original_range(lifetime.syntax()), def)
        } else {
            (
-                lifetime.syntax().text_range(),
+                sema.original_range(lifetime.syntax()),
                NameClass::classify_lifetime(sema, &lifetime)?.referenced_or_defined(sema.db),
            )
        }
@@ -168,11 +168,11 @@ fn find_name(
        let name_ref =
            sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
        (
-            name_ref.syntax().text_range(),
+            sema.original_range(name_ref.syntax()),
            NameRefClass::classify(sema, &name_ref)?.referenced(sema.db),
        )
    };
-    Some(RangeInfo::new(text_range, def))
+    Some(RangeInfo::new(range, def))
 }
 fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option<ReferenceAccess> {
@@ -1086,4 +1086,62 @@ impl<'a> Foo<'a> for &'a () {
            "#]],
        );
    }
+    #[test]
+    fn test_map_range_to_original() {
+        check(
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a<|> = "test";
+    foo!(a);
+}
+"#,
+            expect![[r#"
+                a Local FileId(0) 59..60 Other
+                FileId(0) 80..81 Other Read
+            "#]],
+        );
+    }
+    #[test]
+    fn test_map_range_to_original_ref() {
+        check(
+            r#"
+macro_rules! foo {($i:ident) => {$i} }
+fn main() {
+    let a = "test";
+    foo!(a<|>);
+}
+"#,
+            expect![[r#"
+                a Local FileId(0) 59..60 Other
+                FileId(0) 80..81 Other Read
+            "#]],
+        );
+    }
+    #[test]
+    fn test_find_labels() {
+        check(
+            r#"
+fn foo<'a>() -> &'a () {
+    'a: loop {
+        'b: loop {
+            continue 'a<|>;
+        }
+        break 'a;
+    }
+}
+"#,
+            expect![[r#"
+                'a Label FileId(0) 29..32 29..31 Lifetime
+                FileId(0) 80..82 Lifetime
+                FileId(0) 108..110 Lifetime
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index cd721b7eb..854bf194e 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -6,7 +6,7 @@ use std::{
 };
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
-use ide_db::base_db::{AnchoredPathBuf, FileRange, SourceDatabaseExt};
+use ide_db::base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt};
 use ide_db::{
    defs::{Definition, NameClass, NameRefClass},
    RootDatabase,
@@ -110,6 +110,23 @@ pub(crate) fn rename_with_semantics(
    }
 }
+pub(crate) fn will_rename_file(
+    db: &RootDatabase,
+    file_id: FileId,
+    new_name_stem: &str,
+) -> Option<SourceChange> {
+    let sema = Semantics::new(db);
+    let module = sema.to_module_def(file_id)?;
+    let decl = module.declaration_source(db)?;
+    let range = decl.value.name()?.syntax().text_range();
+    let position = FilePosition { file_id: decl.file_id.original_file(db), offset: range.start() };
+    let mut change = rename_mod(&sema, position, module, new_name_stem).ok()?.info;
+    change.file_system_edits.clear();
+    Some(change)
+}
 fn find_module_at_offset(
    sema: &Semantics<RootDatabase>,
    position: FilePosition,
@@ -1523,4 +1540,29 @@ fn main() {
 }"#,
        );
    }
+    #[test]
+    fn test_rename_label() {
+        check(
+            "'foo",
+            r#"
+fn foo<'a>() -> &'a () {
+    'a: {
+        'b: loop {
+            break 'a<|>;
+        }
+    }
+}
+"#,
+            r#"
+fn foo<'a>() -> &'a () {
+    'foo: {
+        'b: loop {
+            break 'foo;
+        }
+    }
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 2f2b99130..891183266 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -193,7 +193,7 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
                if let hir::AssocItemContainer::Impl(imp) = assoc_def.container(sema.db) {
                    if let Some(adt) = imp.target_ty(sema.db).as_adt() {
                        let name = adt.name(sema.db).to_string();
-                        let idx = path.rfind(':').unwrap_or(0);
+                        let idx = path.rfind(':').map_or(0, |idx| idx + 1);
                        let (prefix, suffix) = path.split_at(idx);
                        return format!("{}{}::{}", prefix, name, suffix);
                    }
@@ -931,4 +931,42 @@ mod test_mod {
            "#]],
        );
    }
+    #[test]
+    fn test_doc_runnables_impl_mod() {
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+//- /foo.rs
+struct Foo;<|>
+impl Foo {
+    /// ```
+    /// let x = 5;
+    /// ```
+    fn foo() {}
+}
+        "#,
+            &[&DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 27..81,
+                            name: "foo",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "foo::Foo::foo",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 00c717c7c..5ad96581b 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -560,10 +560,20 @@ fn highlight_element(
        CHAR => HighlightTag::CharLiteral.into(),
        QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow,
        LIFETIME => {
-            let h = Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam));
+            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
-            match element.parent().map(|it| it.kind()) {
-                Some(LIFETIME_PARAM) | Some(LABEL) => h | HighlightModifier::Definition,
+            match NameClass::classify_lifetime(sema, &lifetime) {
-                _ => h,
+                Some(NameClass::Definition(def)) => {
+                    highlight_def(db, def) | HighlightModifier::Definition
+                }
+                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
+                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
+                    _ => Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam)),
+                },
+                _ => {
+                    Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam))
+                        | HighlightModifier::Definition
+                }
            }
        }
        p if p.is_punct() => match p {
@@ -825,6 +835,7 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
            return h;
        }
        Definition::LifetimeParam(_) => HighlightTag::Symbol(SymbolKind::LifetimeParam),
+        Definition::Label(_) => HighlightTag::Symbol(SymbolKind::Label),
    }
    .into()
 }
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index abcc5cccc..99ba3a59d 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -64,6 +64,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 974f54fa0..2a6cc0cab 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -80,6 +80,7 @@ impl HighlightTag {
                SymbolKind::LifetimeParam => "lifetime",
                SymbolKind::Macro => "macro",
                SymbolKind::Local => "variable",
+                SymbolKind::Label => "label",
                SymbolKind::ValueParam => "value_param",
                SymbolKind::SelfParam => "self_keyword",
                SymbolKind::Impl => "self_type",
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index db6f32d33..506ebe60e 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 4e511baa9..4dd7413ba 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index 800d894c7..ed452586a 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 7f18ad297..92e7dc3e4 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index c843b5085..31dad5d42 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index d26f48516..e3a0aa317 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 588e86a34..72ff9dd40 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
@@ -194,6 +195,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="punctuation">;</span>
    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="operator">!</span><span class="bool_literal">true</span><span class="punctuation">;</span>
+    <span class="label declaration">'foo</span><span class="punctuation">:</span> <span class="keyword control">loop</span> <span class="punctuation">{</span>
+        <span class="keyword control">break</span> <span class="label">'foo</span><span class="punctuation">;</span>
+        <span class="keyword control">continue</span> <span class="label">'foo</span><span class="punctuation">;</span>
+    <span class="punctuation">}</span>
 <span class="punctuation">}</span>
 <span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
index c7589605f..8b3dfa69f 100644
--- a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
@@ -4,6 +4,7 @@ body                { margin: 0; }
 pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 .lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
 .injected           { opacity: 0.65 ; }
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index f53d2c3ba..e0df0d2b5 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -168,6 +168,11 @@ fn main() {
    let baz = -baz;
    let _ = !true;
+    'foo: loop {
+        break 'foo;
+        continue 'foo;
+    }
 }
 enum Option<T> {
diff --git a/crates/ide_db/Cargo.toml b/crates/ide_db/Cargo.toml
index 0ad6e1000..ebe53c8ee 100644
--- a/crates/ide_db/Cargo.toml
+++ b/crates/ide_db/Cargo.toml
@@ -19,7 +19,7 @@ fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 once_cell = "1.3.1"
 either = "1.6.1"
-itertools = "0.9.0"
+itertools = "0.10.0"
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 9d7dce1d4..d33a6cb86 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -6,8 +6,8 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 use hir::{
-    db::HirDatabase, Crate, Field, HasVisibility, Impl, LifetimeParam, Local, MacroDef, Module,
+    db::HirDatabase, Crate, Field, HasVisibility, Impl, Label, LifetimeParam, Local, MacroDef,
-    ModuleDef, Name, PathResolution, Semantics, TypeParam, Visibility,
+    Module, ModuleDef, Name, PathResolution, Semantics, TypeParam, Visibility,
 };
 use syntax::{
    ast::{self, AstNode},
@@ -26,7 +26,7 @@ pub enum Definition {
    Local(Local),
    TypeParam(TypeParam),
    LifetimeParam(LifetimeParam),
-    // FIXME: Label
+    Label(Label),
 }
 impl Definition {
@@ -39,6 +39,7 @@ impl Definition {
            Definition::Local(it) => Some(it.module(db)),
            Definition::TypeParam(it) => Some(it.module(db)),
            Definition::LifetimeParam(it) => Some(it.module(db)),
+            Definition::Label(it) => Some(it.module(db)),
        }
    }
@@ -51,6 +52,7 @@ impl Definition {
            Definition::Local(_) => None,
            Definition::TypeParam(_) => None,
            Definition::LifetimeParam(_) => None,
+            Definition::Label(_) => None,
        }
    }
@@ -77,6 +79,7 @@ impl Definition {
            Definition::Local(it) => it.name(db)?,
            Definition::TypeParam(it) => it.name(db),
            Definition::LifetimeParam(it) => it.name(db),
+            Definition::Label(it) => it.name(db),
        };
        Some(name)
    }
@@ -248,7 +251,10 @@ impl NameClass {
                    let def = sema.to_def(&it)?;
                    Some(NameClass::Definition(Definition::LifetimeParam(def)))
                },
-                ast::Label(_it) => None,
+                ast::Label(it) => {
+                    let def = sema.to_def(&it)?;
+                    Some(NameClass::Definition(Definition::Label(def)))
+                },
                _ => None,
            }
        }
@@ -370,6 +376,9 @@ impl NameRefClass {
        let _p = profile::span("classify_lifetime_ref").detail(|| lifetime.to_string());
        let parent = lifetime.syntax().parent()?;
        match parent.kind() {
+            SyntaxKind::BREAK_EXPR | SyntaxKind::CONTINUE_EXPR => {
+                sema.resolve_label(lifetime).map(Definition::Label).map(NameRefClass::Definition)
+            }
            SyntaxKind::LIFETIME_ARG
            | SyntaxKind::SELF_PARAM
            | SyntaxKind::TYPE_BOUND
@@ -387,7 +396,6 @@ impl NameRefClass {
                    .map(Definition::LifetimeParam)
                    .map(NameRefClass::Definition)
            }
-            SyntaxKind::BREAK_EXPR | SyntaxKind::CONTINUE_EXPR => None,
            _ => None,
        }
    }
diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs
index b2980a5d6..0f4c2ca47 100644
--- a/crates/ide_db/src/imports_locator.rs
+++ b/crates/ide_db/src/imports_locator.rs
@@ -15,19 +15,23 @@ use rustc_hash::FxHashSet;
 pub fn find_exact_imports<'a>(
    sema: &Semantics<'a, RootDatabase>,
    krate: Crate,
-    name_to_import: &str,
+    name_to_import: String,
 ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
    let _p = profile::span("find_exact_imports");
    find_imports(
        sema,
        krate,
        {
-            let mut local_query = symbol_index::Query::new(name_to_import.to_string());
+            let mut local_query = symbol_index::Query::new(name_to_import.clone());
            local_query.exact();
            local_query.limit(40);
            local_query
        },
-        import_map::Query::new(name_to_import).anchor_end().case_sensitive().limit(40),
+        import_map::Query::new(name_to_import)
+            .limit(40)
+            .name_only()
+            .search_mode(import_map::SearchMode::Equals)
+            .case_sensitive(),
    )
 }
@@ -35,17 +39,18 @@ pub fn find_similar_imports<'a>(
    sema: &Semantics<'a, RootDatabase>,
    krate: Crate,
    limit: Option<usize>,
-    name_to_import: &str,
+    fuzzy_search_string: String,
-    ignore_modules: bool,
+    name_only: bool,
 ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
    let _p = profile::span("find_similar_imports");
-    let mut external_query = import_map::Query::new(name_to_import);
+    let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
-    if ignore_modules {
+        .search_mode(import_map::SearchMode::Fuzzy);
-        external_query = external_query.exclude_import_kind(import_map::ImportKind::Module);
+    if name_only {
+        external_query = external_query.name_only();
    }
-    let mut local_query = symbol_index::Query::new(name_to_import.to_string());
+    let mut local_query = symbol_index::Query::new(fuzzy_search_string);
    if let Some(limit) = limit {
        local_query.limit(limit);
diff --git a/crates/ide_db/src/source_change.rs b/crates/ide_db/src/source_change.rs
index e87d98dad..10c0abdac 100644
--- a/crates/ide_db/src/source_change.rs
+++ b/crates/ide_db/src/source_change.rs
@@ -44,7 +44,7 @@ impl From<Vec<SourceFileEdit>> for SourceChange {
 #[derive(Debug, Clone)]
 pub enum FileSystemEdit {
-    CreateFile { dst: AnchoredPathBuf },
+    CreateFile { dst: AnchoredPathBuf, initial_contents: String },
    MoveFile { src: FileId, dst: AnchoredPathBuf },
 }
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 3ad609a00..b3472879d 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -14,10 +14,10 @@ mod tests;
 use std::fmt;
-pub use tt::{Delimiter, Punct};
+pub use tt::{Delimiter, DelimiterKind, Punct};
 use crate::{
-    parser::{parse_pattern, Op},
+    parser::{parse_pattern, parse_template, Op},
    tt_iter::TtIter,
 };
@@ -78,8 +78,24 @@ pub struct MacroRules {
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct Rule {
-    lhs: tt::Subtree,
+    lhs: MetaTemplate,
-    rhs: tt::Subtree,
+    rhs: MetaTemplate,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct MetaTemplate {
+    delimiter: Option<Delimiter>,
+    tokens: Vec<Result<Op, ExpandError>>,
+}
+impl<'a> MetaTemplate {
+    fn iter(&self) -> impl Iterator<Item = &Result<Op, ExpandError>> {
+        self.tokens.iter()
+    }
+    fn delimiter_kind(&self) -> Option<DelimiterKind> {
+        self.delimiter.map(|it| it.kind)
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -167,7 +183,7 @@ impl MacroRules {
            rules.push(rule);
            if let Err(()) = src.expect_char(';') {
                if src.len() > 0 {
-                    return Err(ParseError::Expected("expected `:`".to_string()));
+                    return Err(ParseError::Expected("expected `;`".to_string()));
                }
                break;
            }
@@ -201,23 +217,23 @@ impl MacroRules {
 impl Rule {
    fn parse(src: &mut TtIter) -> Result<Rule, ParseError> {
-        let mut lhs = src
+        let lhs = src
            .expect_subtree()
-            .map_err(|()| ParseError::Expected("expected subtree".to_string()))?
+            .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
-            .clone();
-        lhs.delimiter = None;
        src.expect_char('=').map_err(|()| ParseError::Expected("expected `=`".to_string()))?;
        src.expect_char('>').map_err(|()| ParseError::Expected("expected `>`".to_string()))?;
-        let mut rhs = src
+        let rhs = src
            .expect_subtree()
-            .map_err(|()| ParseError::Expected("expected subtree".to_string()))?
+            .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
-            .clone();
-        rhs.delimiter = None;
+        let lhs = MetaTemplate { tokens: parse_pattern(&lhs), delimiter: None };
+        let rhs = MetaTemplate { tokens: parse_template(&rhs), delimiter: None };
        Ok(crate::Rule { lhs, rhs })
    }
 }
-fn to_parse_error(e: ExpandError) -> ParseError {
+fn to_parse_error(e: &ExpandError) -> ParseError {
    let msg = match e {
        ExpandError::InvalidRepeat => "invalid repeat".to_string(),
        _ => "invalid macro definition".to_string(),
@@ -225,22 +241,22 @@ fn to_parse_error(e: ExpandError) -> ParseError {
    ParseError::Expected(msg)
 }
-fn validate(pattern: &tt::Subtree) -> Result<(), ParseError> {
+fn validate(pattern: &MetaTemplate) -> Result<(), ParseError> {
-    for op in parse_pattern(pattern) {
+    for op in pattern.iter() {
-        let op = op.map_err(to_parse_error)?;
+        let op = op.as_ref().map_err(|e| to_parse_error(&e))?;
        match op {
-            Op::TokenTree(tt::TokenTree::Subtree(subtree)) => validate(subtree)?,
+            Op::Subtree(subtree) => validate(&subtree)?,
            Op::Repeat { subtree, separator, .. } => {
                // Checks that no repetition which could match an empty token
                // https://github.com/rust-lang/rust/blob/a58b1ed44f5e06976de2bdc4d7dc81c36a96934f/src/librustc_expand/mbe/macro_rules.rs#L558
                if separator.is_none() {
-                    if parse_pattern(subtree).all(|child_op| {
+                    if subtree.iter().all(|child_op| {
-                        match child_op.map_err(to_parse_error) {
+                        match child_op.as_ref().map_err(to_parse_error) {
                            Ok(Op::Var { kind, .. }) => {
                                // vis is optional
-                                if kind.map_or(false, |it| it == "vis") {
+                                if kind.as_ref().map_or(false, |it| it == "vis") {
                                    return true;
                                }
                            }
diff --git a/crates/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index 7aeef7be5..ab5f87c48 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -2,10 +2,10 @@
 use crate::{
    mbe_expander::{Binding, Bindings, Fragment},
-    parser::{parse_pattern, Op, RepeatKind, Separator},
+    parser::{Op, RepeatKind, Separator},
    subtree_source::SubtreeTokenSource,
    tt_iter::TtIter,
-    ExpandError,
+    ExpandError, MetaTemplate,
 };
 use super::ExpandResult;
@@ -83,7 +83,7 @@ impl Match {
 // sense to try using it. Matching errors are added to the `Match`. It might
 // make sense to make pattern parsing a separate step?
-pub(super) fn match_(pattern: &tt::Subtree, src: &tt::Subtree) -> Result<Match, ExpandError> {
+pub(super) fn match_(pattern: &MetaTemplate, src: &tt::Subtree) -> Result<Match, ExpandError> {
    assert!(pattern.delimiter == None);
    let mut res = Match::default();
@@ -101,12 +101,12 @@ pub(super) fn match_(pattern: &tt::Subtree, src: &tt::Subtree) -> Result<Match,
 fn match_subtree(
    res: &mut Match,
-    pattern: &tt::Subtree,
+    pattern: &MetaTemplate,
    src: &mut TtIter,
 ) -> Result<(), ExpandError> {
-    for op in parse_pattern(pattern) {
+    for op in pattern.iter() {
-        match op? {
+        match op.as_ref().map_err(|err| err.clone())? {
-            Op::TokenTree(tt::TokenTree::Leaf(lhs)) => {
+            Op::Leaf(lhs) => {
                let rhs = match src.expect_leaf() {
                    Ok(l) => l,
                    Err(()) => {
@@ -132,7 +132,7 @@ fn match_subtree(
                    }
                }
            }
-            Op::TokenTree(tt::TokenTree::Subtree(lhs)) => {
+            Op::Subtree(lhs) => {
                let rhs = match src.expect_subtree() {
                    Ok(s) => s,
                    Err(()) => {
@@ -172,7 +172,7 @@ fn match_subtree(
                }
            }
            Op::Repeat { subtree, kind, separator } => {
-                match_repeat(res, subtree, kind, separator, src)?;
+                match_repeat(res, subtree, *kind, separator, src)?;
            }
        }
    }
@@ -240,26 +240,26 @@ impl<'a> TtIter<'a> {
                let tt3 = self.next().unwrap().clone();
                Ok(tt::Subtree { delimiter: None, token_trees: vec![tt, tt2, tt3] }.into())
            }
-            ('-', '=', None)
+            ('-', '=', _)
-            | ('-', '>', None)
+            | ('-', '>', _)
-            | (':', ':', None)
+            | (':', ':', _)
-            | ('!', '=', None)
+            | ('!', '=', _)
-            | ('.', '.', None)
+            | ('.', '.', _)
-            | ('*', '=', None)
+            | ('*', '=', _)
-            | ('/', '=', None)
+            | ('/', '=', _)
-            | ('&', '&', None)
+            | ('&', '&', _)
-            | ('&', '=', None)
+            | ('&', '=', _)
-            | ('%', '=', None)
+            | ('%', '=', _)
-            | ('^', '=', None)
+            | ('^', '=', _)
-            | ('+', '=', None)
+            | ('+', '=', _)
-            | ('<', '<', None)
+            | ('<', '<', _)
-            | ('<', '=', None)
+            | ('<', '=', _)
-            | ('=', '=', None)
+            | ('=', '=', _)
-            | ('=', '>', None)
+            | ('=', '>', _)
-            | ('>', '=', None)
+            | ('>', '=', _)
-            | ('>', '>', None)
+            | ('>', '>', _)
-            | ('|', '=', None)
+            | ('|', '=', _)
-            | ('|', '|', None) => {
+            | ('|', '|', _) => {
                let tt2 = self.next().unwrap().clone();
                Ok(tt::Subtree { delimiter: None, token_trees: vec![tt, tt2] }.into())
            }
@@ -372,9 +372,9 @@ impl<'a> TtIter<'a> {
 pub(super) fn match_repeat(
    res: &mut Match,
-    pattern: &tt::Subtree,
+    pattern: &MetaTemplate,
    kind: RepeatKind,
-    separator: Option<Separator>,
+    separator: &Option<Separator>,
    src: &mut TtIter,
 ) -> Result<(), ExpandError> {
    // Dirty hack to make macro-expansion terminate.
@@ -489,12 +489,12 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
    result.map(|tt| if kind == "expr" { tt.map(Fragment::Ast) } else { tt.map(Fragment::Tokens) })
 }
-fn collect_vars(buf: &mut Vec<SmolStr>, pattern: &tt::Subtree) -> Result<(), ExpandError> {
+fn collect_vars(buf: &mut Vec<SmolStr>, pattern: &MetaTemplate) -> Result<(), ExpandError> {
-    for op in parse_pattern(pattern) {
+    for op in pattern.iter() {
-        match op? {
+        match op.as_ref().map_err(|e| e.clone())? {
            Op::Var { name, .. } => buf.push(name.clone()),
-            Op::TokenTree(tt::TokenTree::Leaf(_)) => (),
+            Op::Leaf(_) => (),
-            Op::TokenTree(tt::TokenTree::Subtree(subtree)) => collect_vars(buf, subtree)?,
+            Op::Subtree(subtree) => collect_vars(buf, subtree)?,
            Op::Repeat { subtree, .. } => collect_vars(buf, subtree)?,
        }
    }
diff --git a/crates/mbe/src/mbe_expander/transcriber.rs b/crates/mbe/src/mbe_expander/transcriber.rs
index 57592dc92..720531237 100644
--- a/crates/mbe/src/mbe_expander/transcriber.rs
+++ b/crates/mbe/src/mbe_expander/transcriber.rs
@@ -6,8 +6,8 @@ use syntax::SmolStr;
 use super::ExpandResult;
 use crate::{
    mbe_expander::{Binding, Bindings, Fragment},
-    parser::{parse_template, Op, RepeatKind, Separator},
+    parser::{Op, RepeatKind, Separator},
-    ExpandError,
+    ExpandError, MetaTemplate,
 };
 impl Bindings {
@@ -50,7 +50,10 @@ impl Bindings {
    }
 }
-pub(super) fn transcribe(template: &tt::Subtree, bindings: &Bindings) -> ExpandResult<tt::Subtree> {
+pub(super) fn transcribe(
+    template: &MetaTemplate,
+    bindings: &Bindings,
+) -> ExpandResult<tt::Subtree> {
    assert!(template.delimiter == None);
    let mut ctx = ExpandCtx { bindings: &bindings, nesting: Vec::new() };
    let mut arena: Vec<tt::TokenTree> = Vec::new();
@@ -76,35 +79,35 @@ struct ExpandCtx<'a> {
 fn expand_subtree(
    ctx: &mut ExpandCtx,
-    template: &tt::Subtree,
+    template: &MetaTemplate,
    arena: &mut Vec<tt::TokenTree>,
 ) -> ExpandResult<tt::Subtree> {
    // remember how many elements are in the arena now - when returning, we want to drain exactly how many elements we added. This way, the recursive uses of the arena get their own "view" of the arena, but will reuse the allocation
    let start_elements = arena.len();
    let mut err = None;
-    for op in parse_template(template) {
+    for op in template.iter() {
        let op = match op {
            Ok(op) => op,
            Err(e) => {
-                err = Some(e);
+                err = Some(e.clone());
                break;
            }
        };
        match op {
-            Op::TokenTree(tt @ tt::TokenTree::Leaf(..)) => arena.push(tt.clone()),
+            Op::Leaf(tt) => arena.push(tt.clone().into()),
-            Op::TokenTree(tt::TokenTree::Subtree(tt)) => {
+            Op::Subtree(tt) => {
-                let ExpandResult { value: tt, err: e } = expand_subtree(ctx, tt, arena);
+                let ExpandResult { value: tt, err: e } = expand_subtree(ctx, &tt, arena);
                err = err.or(e);
                arena.push(tt.into());
            }
            Op::Var { name, .. } => {
-                let ExpandResult { value: fragment, err: e } = expand_var(ctx, name);
+                let ExpandResult { value: fragment, err: e } = expand_var(ctx, &name);
                err = err.or(e);
                push_fragment(arena, fragment);
            }
            Op::Repeat { subtree, kind, separator } => {
                let ExpandResult { value: fragment, err: e } =
-                    expand_repeat(ctx, subtree, kind, separator, arena);
+                    expand_repeat(ctx, subtree, *kind, separator, arena);
                err = err.or(e);
                push_fragment(arena, fragment)
            }
@@ -161,9 +164,9 @@ fn expand_var(ctx: &mut ExpandCtx, v: &SmolStr) -> ExpandResult<Fragment> {
 fn expand_repeat(
    ctx: &mut ExpandCtx,
-    template: &tt::Subtree,
+    template: &MetaTemplate,
    kind: RepeatKind,
-    separator: Option<Separator>,
+    separator: &Option<Separator>,
    arena: &mut Vec<tt::TokenTree>,
 ) -> ExpandResult<Fragment> {
    let mut buf: Vec<tt::TokenTree> = Vec::new();
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index c3fdd4040..2f3ebc831 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -4,16 +4,17 @@
 use smallvec::SmallVec;
 use syntax::SmolStr;
-use crate::{tt_iter::TtIter, ExpandError};
+use crate::{tt_iter::TtIter, ExpandError, MetaTemplate};
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum Op<'a> {
+pub(crate) enum Op {
-    Var { name: &'a SmolStr, kind: Option<&'a SmolStr> },
+    Var { name: SmolStr, kind: Option<SmolStr> },
-    Repeat { subtree: &'a tt::Subtree, kind: RepeatKind, separator: Option<Separator> },
+    Repeat { subtree: MetaTemplate, kind: RepeatKind, separator: Option<Separator> },
-    TokenTree(&'a tt::TokenTree),
+    Leaf(tt::Leaf),
+    Subtree(MetaTemplate),
 }
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub(crate) enum RepeatKind {
    ZeroOrMore,
    OneOrMore,
@@ -45,16 +46,12 @@ impl PartialEq for Separator {
    }
 }
-pub(crate) fn parse_template(
+pub(crate) fn parse_template(template: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
-    template: &tt::Subtree,
+    parse_inner(&template, Mode::Template)
-) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
-    parse_inner(template, Mode::Template)
 }
-pub(crate) fn parse_pattern(
+pub(crate) fn parse_pattern(pattern: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
-    pattern: &tt::Subtree,
+    parse_inner(&pattern, Mode::Pattern)
-) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
-    parse_inner(pattern, Mode::Pattern)
 }
 #[derive(Clone, Copy)]
@@ -63,12 +60,13 @@ enum Mode {
    Template,
 }
-fn parse_inner(src: &tt::Subtree, mode: Mode) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
+fn parse_inner(tt: &tt::Subtree, mode: Mode) -> Vec<Result<Op, ExpandError>> {
-    let mut src = TtIter::new(src);
+    let mut src = TtIter::new(&tt);
    std::iter::from_fn(move || {
        let first = src.next()?;
        Some(next_op(first, &mut src, mode))
    })
+    .collect()
 }
 macro_rules! err {
@@ -83,35 +81,41 @@ macro_rules! bail {
    };
 }
-fn next_op<'a>(
+fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Result<Op, ExpandError> {
-    first: &'a tt::TokenTree,
-    src: &mut TtIter<'a>,
-    mode: Mode,
-) -> Result<Op<'a>, ExpandError> {
    let res = match first {
-        tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: '$', .. })) => {
+        tt::TokenTree::Leaf(leaf @ tt::Leaf::Punct(tt::Punct { char: '$', .. })) => {
            // Note that the '$' itself is a valid token inside macro_rules.
            let second = match src.next() {
-                None => return Ok(Op::TokenTree(first)),
+                None => return Ok(Op::Leaf(leaf.clone())),
                Some(it) => it,
            };
            match second {
                tt::TokenTree::Subtree(subtree) => {
                    let (separator, kind) = parse_repeat(src)?;
+                    let delimiter = subtree.delimiter;
+                    let tokens = parse_inner(&subtree, mode);
+                    let subtree = MetaTemplate { tokens, delimiter };
                    Op::Repeat { subtree, separator, kind }
                }
                tt::TokenTree::Leaf(leaf) => match leaf {
-                    tt::Leaf::Punct(_) => {
+                    tt::Leaf::Punct(punct) => {
-                        return Err(ExpandError::UnexpectedToken);
+                        static UNDERSCORE: SmolStr = SmolStr::new_inline("_");
+                        if punct.char != '_' {
+                            return Err(ExpandError::UnexpectedToken);
+                        }
+                        let name = UNDERSCORE.clone();
+                        let kind = eat_fragment_kind(src, mode)?;
+                        Op::Var { name, kind }
                    }
                    tt::Leaf::Ident(ident) => {
-                        let name = &ident.text;
+                        let name = ident.text.clone();
                        let kind = eat_fragment_kind(src, mode)?;
                        Op::Var { name, kind }
                    }
                    tt::Leaf::Literal(lit) => {
-                        if is_boolean_literal(lit) {
+                        if is_boolean_literal(&lit) {
-                            let name = &lit.text;
+                            let name = lit.text.clone();
                            let kind = eat_fragment_kind(src, mode)?;
                            Op::Var { name, kind }
                        } else {
@@ -121,19 +125,22 @@ fn next_op<'a>(
                },
            }
        }
-        tt => Op::TokenTree(tt),
+        tt::TokenTree::Leaf(tt) => Op::Leaf(tt.clone()),
+        tt::TokenTree::Subtree(subtree) => {
+            let delimiter = subtree.delimiter;
+            let tokens = parse_inner(&subtree, mode);
+            let subtree = MetaTemplate { tokens, delimiter };
+            Op::Subtree(subtree)
+        }
    };
    Ok(res)
 }
-fn eat_fragment_kind<'a>(
+fn eat_fragment_kind<'a>(src: &mut TtIter<'a>, mode: Mode) -> Result<Option<SmolStr>, ExpandError> {
-    src: &mut TtIter<'a>,
-    mode: Mode,
-) -> Result<Option<&'a SmolStr>, ExpandError> {
    if let Mode::Pattern = mode {
        src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
        let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
-        return Ok(Some(&ident.text));
+        return Ok(Some(ident.text.clone()));
    };
    Ok(None)
 }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 2bec7fd49..265c0d63d 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -313,7 +313,7 @@ trait TokenConvertor {
            return;
        }
-        result.push(if k.is_punct() && k != UNDERSCORE {
+        result.push(if k.is_punct() {
            assert_eq!(range.len(), TextSize::of('.'));
            let delim = match k {
                T!['('] => Some((tt::DelimiterKind::Parenthesis, T![')'])),
@@ -378,7 +378,6 @@ trait TokenConvertor {
            let leaf: tt::Leaf = match k {
                T![true] | T![false] => make_leaf!(Ident),
                IDENT => make_leaf!(Ident),
-                UNDERSCORE => make_leaf!(Ident),
                k if k.is_keyword() => make_leaf!(Ident),
                k if k.is_literal() => make_leaf!(Literal),
                LIFETIME_IDENT => {
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index 451fa1456..1d9afb4fb 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -761,6 +761,18 @@ fn test_last_expr() {
 }
 #[test]
+fn test_expr_with_attr() {
+    parse_macro(
+        r#"
+macro_rules! m {
+    ($a:expr) => {0}
+}
+"#,
+    )
+    .assert_expand_items("m!(#[allow(a)]())", "0");
+}
+#[test]
 fn test_ty() {
    parse_macro(
        r#"
@@ -992,6 +1004,22 @@ fn test_tt_composite2() {
 }
 #[test]
+fn test_tt_with_composite_without_space() {
+    parse_macro(
+        r#"
+        macro_rules! foo {
+            ($ op:tt, $j:path) => (
+                0
+            )
+        }
+"#,
+    )
+    // Test macro input without any spaces
+    // See https://github.com/rust-analyzer/rust-analyzer/issues/6692
+    .assert_expand_items("foo!(==,Foo::Bool)", "0");
+}
+#[test]
 fn test_underscore() {
    parse_macro(
        r#"
@@ -1004,6 +1032,42 @@ fn test_underscore() {
 }
 #[test]
+fn test_underscore_not_greedily() {
+    parse_macro(
+        r#"
+macro_rules! q {
+    ($($a:ident)* _) => {0};
+}
+"#,
+    )
+    // `_` overlaps with `$a:ident` but rustc matches it under the `_` token
+    .assert_expand_items(r#"q![a b c d _]"#, r#"0"#);
+    parse_macro(
+        r#"
+macro_rules! q {
+    ($($a:expr => $b:ident)* _ => $c:expr) => {0};
+}
+"#,
+    )
+    // `_ => ou` overlaps with `$a:expr => $b:ident` but rustc matches it under `_ => $c:expr`
+    .assert_expand_items(r#"q![a => b c => d _ => ou]"#, r#"0"#);
+}
+#[test]
+fn test_underscore_as_type() {
+    parse_macro(
+        r#"
+macro_rules! q {
+    ($a:ty) => {0};
+}
+"#,
+    )
+    // Underscore is a type
+    .assert_expand_items(r#"q![_]"#, r#"0"#);
+}
+#[test]
 fn test_vertical_bar_with_pat() {
    parse_macro(
        r#"
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index f08c8bab7..63cc90027 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -59,7 +59,7 @@ pub(crate) mod fragments {
    };
    pub(crate) fn expr(p: &mut Parser) {
-        let _ = expressions::expr(p);
+        let _ = expressions::expr_with_attrs(p);
    }
    pub(crate) fn stmt(p: &mut Parser) {
diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs
index e897d5a52..c7a3556a7 100644
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -46,6 +46,7 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
        T![continue],
        T![async],
        T![try],
+        T![const],
        T![loop],
        T![for],
        LIFETIME_IDENT,
@@ -115,6 +116,14 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
            block_expr(p);
            m.complete(p, EFFECT_EXPR)
        }
+        // test const_block
+        // fn f() { const { } }
+        T![const] if la == T!['{'] => {
+            let m = p.start();
+            p.bump(T![const]);
+            block_expr(p);
+            m.complete(p, EFFECT_EXPR)
+        }
        T!['{'] => {
            // test for_range_from
            // fn foo() {
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index 8999829b4..cf4168d32 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -96,7 +96,10 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
    let mut has_mods = false;
    // modifiers
-    has_mods |= p.eat(T![const]);
+    if p.at(T![const]) && p.nth(1) != T!['{'] {
+        p.eat(T![const]);
+        has_mods = true;
+    }
    // test_err async_without_semicolon
    // fn foo() { let _ = async {} }
@@ -167,7 +170,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
            m.complete(p, TRAIT);
        }
-        T![const] => {
+        T![const] if p.nth(1) != T!['{'] => {
            consts::konst(p, m);
        }
@@ -386,10 +389,15 @@ fn macro_rules(p: &mut Parser, m: Marker) {
    }
    match p.current() {
-        T!['{'] => {
+        // test macro_rules_non_brace
+        // macro_rules! m ( ($i:ident) => {} );
+        // macro_rules! m [ ($i:ident) => {} ];
+        T!['['] | T!['('] => {
            token_tree(p);
+            p.expect(T![;]);
        }
-        _ => p.error("expected `{`"),
+        T!['{'] => token_tree(p),
+        _ => p.error("expected `{`, `[`, `(`"),
    }
    m.complete(p, MACRO_RULES);
 }
diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
index 7e7f73dee..b53d5749f 100644
--- a/crates/parser/src/grammar/patterns.rs
+++ b/crates/parser/src/grammar/patterns.rs
@@ -89,6 +89,7 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
    let m = match p.nth(0) {
        T![box] => box_pat(p),
        T![ref] | T![mut] => ident_pat(p, true),
+        T![const] => const_block_pat(p),
        IDENT => match p.nth(1) {
            // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
            // (T![x]).
@@ -386,3 +387,16 @@ fn box_pat(p: &mut Parser) -> CompletedMarker {
    pattern_single(p);
    m.complete(p, BOX_PAT)
 }
+// test const_block_pat
+// fn main() {
+//     let const { 15 } = ();
+//     let const { foo(); bar() } = ();
+// }
+fn const_block_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![const]));
+    let m = p.start();
+    p.bump(T![const]);
+    expressions::block_expr(p);
+    m.complete(p, CONST_BLOCK_PAT)
+}
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs
index 980aa5979..f69e71bdb 100644
--- a/crates/parser/src/syntax_kind/generated.rs
+++ b/crates/parser/src/syntax_kind/generated.rs
@@ -170,6 +170,7 @@ pub enum SyntaxKind {
    RANGE_PAT,
    LITERAL_PAT,
    MACRO_PAT,
+    CONST_BLOCK_PAT,
    TUPLE_EXPR,
    ARRAY_EXPR,
    PAREN_EXPR,
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
index 0d061fd53..2ea456fb0 100644
--- a/crates/proc_macro_api/src/lib.rs
+++ b/crates/proc_macro_api/src/lib.rs
@@ -16,7 +16,7 @@ use std::{
    sync::Arc,
 };
-use base_db::ProcMacro;
+use base_db::{Env, ProcMacro};
 use tt::{SmolStr, Subtree};
 use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread};
@@ -39,17 +39,19 @@ impl PartialEq for ProcMacroProcessExpander {
    }
 }
-impl tt::TokenExpander for ProcMacroProcessExpander {
+impl base_db::ProcMacroExpander for ProcMacroProcessExpander {
    fn expand(
        &self,
        subtree: &Subtree,
        attr: Option<&Subtree>,
+        env: &Env,
    ) -> Result<Subtree, tt::ExpansionError> {
        let task = ExpansionTask {
            macro_body: subtree.clone(),
            macro_name: self.name.to_string(),
            attributes: attr.cloned(),
            lib: self.dylib_path.to_path_buf(),
+            env: env.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
        };
        let result: ExpansionResult = self.process.send_task(msg::Request::ExpansionMacro(task))?;
@@ -90,7 +92,7 @@ impl ProcMacroClient {
                    ProcMacroKind::FuncLike => base_db::ProcMacroKind::FuncLike,
                    ProcMacroKind::Attr => base_db::ProcMacroKind::Attr,
                };
-                let expander: Arc<dyn tt::TokenExpander> = Arc::new(ProcMacroProcessExpander {
+                let expander = Arc::new(ProcMacroProcessExpander {
                    process: self.process.clone(),
                    name: name.clone(),
                    dylib_path: dylib_path.into(),
diff --git a/crates/proc_macro_api/src/rpc.rs b/crates/proc_macro_api/src/rpc.rs
index b85f92eea..cf830b59f 100644
--- a/crates/proc_macro_api/src/rpc.rs
+++ b/crates/proc_macro_api/src/rpc.rs
@@ -51,6 +51,9 @@ pub struct ExpansionTask {
    pub attributes: Option<Subtree>,
    pub lib: PathBuf,
+    /// Environment variables to set during macro expansion.
+    pub env: Vec<(String, String)>,
 }
 #[derive(Clone, Eq, PartialEq, Debug, Default, Serialize, Deserialize)]
@@ -251,6 +254,7 @@ mod tests {
            macro_name: Default::default(),
            attributes: None,
            lib: Default::default(),
+            env: Default::default(),
        };
        let json = serde_json::to_string(&task).unwrap();
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 1bfa6c3fc..df9a55c10 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe"] }
 libloading = "0.6.0"
 memmap = "0.7"
diff --git a/crates/proc_macro_srv/src/dylib.rs b/crates/proc_macro_srv/src/dylib.rs
index 2afb973cc..4e719f3aa 100644
--- a/crates/proc_macro_srv/src/dylib.rs
+++ b/crates/proc_macro_srv/src/dylib.rs
@@ -136,6 +136,7 @@ impl Expander {
                        &crate::proc_macro::bridge::server::SameThread,
                        crate::rustc_server::Rustc::default(),
                        parsed_body,
+                        false,
                    );
                    return res.map(|it| it.subtree);
                }
@@ -144,6 +145,7 @@ impl Expander {
                        &crate::proc_macro::bridge::server::SameThread,
                        crate::rustc_server::Rustc::default(),
                        parsed_body,
+                        false,
                    );
                    return res.map(|it| it.subtree);
                }
@@ -153,6 +155,7 @@ impl Expander {
                        crate::rustc_server::Rustc::default(),
                        parsed_attributes,
                        parsed_body,
+                        false,
                    );
                    return res.map(|it| it.subtree);
                }
diff --git a/crates/proc_macro_srv/src/lib.rs b/crates/proc_macro_srv/src/lib.rs
index 9cca96994..d4f04ee06 100644
--- a/crates/proc_macro_srv/src/lib.rs
+++ b/crates/proc_macro_srv/src/lib.rs
@@ -24,7 +24,7 @@ use proc_macro::bridge::client::TokenStream;
 use proc_macro_api::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask};
 use std::{
    collections::{hash_map::Entry, HashMap},
-    fs,
+    env, fs,
    path::{Path, PathBuf},
    time::SystemTime,
 };
@@ -37,7 +37,23 @@ pub(crate) struct ProcMacroSrv {
 impl ProcMacroSrv {
    pub fn expand(&mut self, task: &ExpansionTask) -> Result<ExpansionResult, String> {
        let expander = self.expander(&task.lib)?;
-        match expander.expand(&task.macro_name, &task.macro_body, task.attributes.as_ref()) {
+        let mut prev_env = HashMap::new();
+        for (k, v) in &task.env {
+            prev_env.insert(k.as_str(), env::var_os(k));
+            env::set_var(k, v);
+        }
+        let result = expander.expand(&task.macro_name, &task.macro_body, task.attributes.as_ref());
+        for (k, _) in &task.env {
+            match &prev_env[k.as_str()] {
+                Some(v) => env::set_var(k, v),
+                None => env::remove_var(k),
+            }
+        }
+        match result {
            Ok(expansion) => Ok(ExpansionResult { expansion }),
            Err(msg) => {
                let msg = msg.as_str().unwrap_or("<unknown error>");
diff --git a/crates/proc_macro_srv/src/proc_macro/bridge/client.rs b/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
index 55d6330cc..ca6749b9b 100644
--- a/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
+++ b/crates/proc_macro_srv/src/proc_macro/bridge/client.rs
@@ -303,17 +303,21 @@ impl BridgeState<'_> {
 impl Bridge<'_> {
    fn enter<R>(self, f: impl FnOnce() -> R) -> R {
+        let force_show_panics = self.force_show_panics;
        // Hide the default panic output within `proc_macro` expansions.
        // NB. the server can't do this because it may use a different libstd.
        static HIDE_PANICS_DURING_EXPANSION: Once = Once::new();
        HIDE_PANICS_DURING_EXPANSION.call_once(|| {
            let prev = panic::take_hook();
            panic::set_hook(Box::new(move |info| {
-                let hide = BridgeState::with(|state| match state {
+                let show = BridgeState::with(|state| match state {
-                    BridgeState::NotConnected => false,
+                    BridgeState::NotConnected => true,
-                    BridgeState::Connected(_) | BridgeState::InUse => true,
+                    // Something weird is going on, so don't suppress any backtraces
+                    BridgeState::InUse => true,
+                    BridgeState::Connected(bridge) => force_show_panics,
                });
-                if !hide {
+                if show {
                    prev(info)
                }
            }));
diff --git a/crates/proc_macro_srv/src/proc_macro/bridge/mod.rs b/crates/proc_macro_srv/src/proc_macro/bridge/mod.rs
index b97886eb9..e4006a5ab 100644
--- a/crates/proc_macro_srv/src/proc_macro/bridge/mod.rs
+++ b/crates/proc_macro_srv/src/proc_macro/bridge/mod.rs
@@ -225,6 +225,9 @@ pub struct Bridge<'a> {
    /// Server-side function that the client uses to make requests.
    dispatch: closure::Closure<'a, Buffer<u8>, Buffer<u8>>,
+    /// If 'true', always invoke the default panic hook
+    force_show_panics: bool,
 }
 // impl<'a> !Sync for Bridge<'a> {}
diff --git a/crates/proc_macro_srv/src/proc_macro/bridge/server.rs b/crates/proc_macro_srv/src/proc_macro/bridge/server.rs
index 3acb239af..88fbdc078 100644
--- a/crates/proc_macro_srv/src/proc_macro/bridge/server.rs
+++ b/crates/proc_macro_srv/src/proc_macro/bridge/server.rs
@@ -138,6 +138,7 @@ pub trait ExecutionStrategy {
        input: Buffer<u8>,
        run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
        client_data: D,
+        force_show_panics: bool,
    ) -> Buffer<u8>;
 }
@@ -150,10 +151,14 @@ impl ExecutionStrategy for SameThread {
        input: Buffer<u8>,
        run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
        client_data: D,
+        force_show_panics: bool,
    ) -> Buffer<u8> {
        let mut dispatch = |b| dispatcher.dispatch(b);
-        run_client(Bridge { cached_buffer: input, dispatch: (&mut dispatch).into() }, client_data)
+        run_client(
+            Bridge { cached_buffer: input, dispatch: (&mut dispatch).into(), force_show_panics },
+            client_data,
+        )
    }
 }
@@ -169,6 +174,7 @@ impl ExecutionStrategy for CrossThread1 {
        input: Buffer<u8>,
        run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
        client_data: D,
+        force_show_panics: bool,
    ) -> Buffer<u8> {
        use std::sync::mpsc::channel;
@@ -182,7 +188,11 @@ impl ExecutionStrategy for CrossThread1 {
            };
            run_client(
-                Bridge { cached_buffer: input, dispatch: (&mut dispatch).into() },
+                Bridge {
+                    cached_buffer: input,
+                    dispatch: (&mut dispatch).into(),
+                    force_show_panics,
+                },
                client_data,
            )
        });
@@ -204,6 +214,7 @@ impl ExecutionStrategy for CrossThread2 {
        input: Buffer<u8>,
        run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
        client_data: D,
+        force_show_panics: bool,
    ) -> Buffer<u8> {
        use std::sync::{Arc, Mutex};
@@ -229,7 +240,11 @@ impl ExecutionStrategy for CrossThread2 {
            };
            let r = run_client(
-                Bridge { cached_buffer: input, dispatch: (&mut dispatch).into() },
+                Bridge {
+                    cached_buffer: input,
+                    dispatch: (&mut dispatch).into(),
+                    force_show_panics,
+                },
                client_data,
            );
@@ -268,6 +283,7 @@ fn run_server<
    input: I,
    run_client: extern "C" fn(Bridge<'_>, D) -> Buffer<u8>,
    client_data: D,
+    force_show_panics: bool,
 ) -> Result<O, PanicMessage> {
    let mut dispatcher =
        Dispatcher { handle_store: HandleStore::new(handle_counters), server: MarkedTypes(server) };
@@ -275,7 +291,13 @@ fn run_server<
    let mut b = Buffer::new();
    input.encode(&mut b, &mut dispatcher.handle_store);
-    b = strategy.run_bridge_and_client(&mut dispatcher, b, run_client, client_data);
+    b = strategy.run_bridge_and_client(
+        &mut dispatcher,
+        b,
+        run_client,
+        client_data,
+        force_show_panics,
+    );
    Result::decode(&mut &b[..], &mut dispatcher.handle_store)
 }
@@ -286,6 +308,7 @@ impl client::Client<fn(crate::TokenStream) -> crate::TokenStream> {
        strategy: &impl ExecutionStrategy,
        server: S,
        input: S::TokenStream,
+        force_show_panics: bool,
    ) -> Result<S::TokenStream, PanicMessage> {
        let client::Client { get_handle_counters, run, f } = *self;
        run_server(
@@ -295,6 +318,7 @@ impl client::Client<fn(crate::TokenStream) -> crate::TokenStream> {
            <MarkedTypes<S> as Types>::TokenStream::mark(input),
            run,
            f,
+            force_show_panics,
        )
        .map(<MarkedTypes<S> as Types>::TokenStream::unmark)
    }
@@ -307,6 +331,7 @@ impl client::Client<fn(crate::TokenStream, crate::TokenStream) -> crate::TokenSt
        server: S,
        input: S::TokenStream,
        input2: S::TokenStream,
+        force_show_panics: bool,
    ) -> Result<S::TokenStream, PanicMessage> {
        let client::Client { get_handle_counters, run, f } = *self;
        run_server(
@@ -319,6 +344,7 @@ impl client::Client<fn(crate::TokenStream, crate::TokenStream) -> crate::TokenSt
            ),
            run,
            f,
+            force_show_panics,
        )
        .map(<MarkedTypes<S> as Types>::TokenStream::unmark)
    }
diff --git a/crates/proc_macro_srv/src/rustc_server.rs b/crates/proc_macro_srv/src/rustc_server.rs
index 503f4c101..b54aa1f3b 100644
--- a/crates/proc_macro_srv/src/rustc_server.rs
+++ b/crates/proc_macro_srv/src/rustc_server.rs
@@ -204,17 +204,18 @@ pub mod token_stream {
                let content = subtree
                    .token_trees
                    .iter()
-                    .map(|tkn| {
+                    .fold((String::new(), true), |(last, last_to_joint), tkn| {
-                        let s = to_text(tkn);
+                        let s = [last, to_text(tkn)].join(if last_to_joint { "" } else { " " });
+                        let mut is_joint = false;
                        if let tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) = tkn {
-                            if punct.spacing == tt::Spacing::Alone {
+                            if punct.spacing == tt::Spacing::Joint {
-                                return s + " ";
+                                is_joint = true;
                            }
                        }
-                        s
+                        (s, is_joint)
                    })
-                    .collect::<Vec<_>>()
+                    .0;
-                    .concat();
                let (open, close) = match subtree.delimiter.map(|it| it.kind) {
                    None => ("", ""),
                    Some(tt::DelimiterKind::Brace) => ("{", "}"),
@@ -710,4 +711,32 @@ mod tests {
        assert_eq!(srv.character('c').text, "'c'");
        assert_eq!(srv.byte_string(b"1234586\x88").text, "b\"1234586\\x88\"");
    }
+    #[test]
+    fn test_rustc_server_to_string() {
+        let s = TokenStream {
+            subtree: tt::Subtree {
+                delimiter: None,
+                token_trees: vec![
+                    tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
+                        text: "struct".into(),
+                        id: tt::TokenId::unspecified(),
+                    })),
+                    tt::TokenTree::Leaf(tt::Leaf::Ident(tt::Ident {
+                        text: "T".into(),
+                        id: tt::TokenId::unspecified(),
+                    })),
+                    tt::TokenTree::Subtree(tt::Subtree {
+                        delimiter: Some(tt::Delimiter {
+                            id: tt::TokenId::unspecified(),
+                            kind: tt::DelimiterKind::Brace,
+                        }),
+                        token_trees: vec![],
+                    }),
+                ],
+            },
+        };
+        assert_eq!(s.to_string(), "struct T {}");
+    }
 }
diff --git a/crates/project_model/Cargo.toml b/crates/project_model/Cargo.toml
index c55e85709..a65e42261 100644
--- a/crates/project_model/Cargo.toml
+++ b/crates/project_model/Cargo.toml
@@ -16,7 +16,7 @@ cargo_metadata = "=0.12.0"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 anyhow = "1.0.26"
-itertools = "0.9.0"
+itertools = "0.10.0"
 arena = { path = "../arena", version = "0.0.0" }
 cfg = { path = "../cfg", version = "0.0.0" }
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index bb3b6f2ef..b991b59a6 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 use std::{
+    convert::TryInto,
    ffi::OsStr,
    ops,
    path::{Path, PathBuf},
@@ -196,8 +197,23 @@ impl CargoWorkspace {
        if let Some(target) = target {
            meta.other_options(vec![String::from("--filter-platform"), target]);
        }
        let mut meta = meta.exec().with_context(|| {
-            format!("Failed to run `cargo metadata --manifest-path {}`", cargo_toml.display())
+            let cwd: Option<AbsPathBuf> =
+                std::env::current_dir().ok().and_then(|p| p.try_into().ok());
+            let workdir = cargo_toml
+                .parent()
+                .map(|p| p.to_path_buf())
+                .or(cwd)
+                .map(|dir| dir.to_string_lossy().to_string())
+                .unwrap_or_else(|| "<failed to get path>".into());
+            format!(
+                "Failed to run `cargo metadata --manifest-path {}` in `{}`",
+                cargo_toml.display(),
+                workdir
+            )
        })?;
        let mut out_dir_by_id = FxHashMap::default();
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 470c1d458..0a63593fb 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -19,7 +19,7 @@ anyhow = "1.0.26"
 crossbeam-channel = "0.5.0"
 dissimilar = "1.0.2"
 env_logger = { version = "0.8.1", default-features = false }
-itertools = "0.9.0"
+itertools = "0.10.0"
 jod-thread = "0.1.0"
 log = "0.4.8"
 lsp-types = { version = "0.86.0", features = ["proposed"] }
@@ -29,6 +29,7 @@ oorandom = "11.1.2"
 rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = { version = "1.0.48", features = ["preserve_order"] }
+serde_path_to_error = "0.1"
 threadpool = "1.7.1"
 rayon = "1.5"
 mimalloc = { version = "0.1.19", default-features = false, optional = true }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index de5eb93b5..80e46bf7f 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -5,12 +5,14 @@ use ide::CompletionResolveCapability;
 use lsp_types::{
    CallHierarchyServerCapability, ClientCapabilities, CodeActionKind, CodeActionOptions,
    CodeActionProviderCapability, CodeLensOptions, CompletionOptions,
-    DocumentOnTypeFormattingOptions, FoldingRangeProviderCapability, HoverProviderCapability,
+    DocumentOnTypeFormattingOptions, FileOperationFilter, FileOperationPattern,
-    ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
+    FileOperationPatternKind, FileOperationRegistrationOptions, FoldingRangeProviderCapability,
+    HoverProviderCapability, ImplementationProviderCapability, OneOf, RenameOptions, SaveOptions,
    SelectionRangeProviderCapability, SemanticTokensFullOptions, SemanticTokensLegend,
    SemanticTokensOptions, ServerCapabilities, SignatureHelpOptions, TextDocumentSyncCapability,
    TextDocumentSyncKind, TextDocumentSyncOptions, TypeDefinitionProviderCapability,
-    WorkDoneProgressOptions,
+    WorkDoneProgressOptions, WorkspaceFileOperationsServerCapabilities,
+    WorkspaceServerCapabilities,
 };
 use rustc_hash::FxHashSet;
 use serde_json::json;
@@ -68,7 +70,26 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
        document_link_provider: None,
        color_provider: None,
        execute_command_provider: None,
-        workspace: None,
+        workspace: Some(WorkspaceServerCapabilities {
+            workspace_folders: None,
+            file_operations: Some(WorkspaceFileOperationsServerCapabilities {
+                did_create: None,
+                will_create: None,
+                did_rename: None,
+                will_rename: Some(FileOperationRegistrationOptions {
+                    filters: vec![FileOperationFilter {
+                        scheme: Some(String::from("file")),
+                        pattern: FileOperationPattern {
+                            glob: String::from("**/*.rs"),
+                            matches: Some(FileOperationPatternKind::File),
+                            options: None,
+                        },
+                    }],
+                }),
+                did_delete: None,
+                will_delete: None,
+            }),
+        }),
        call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
        semantic_tokens_provider: Some(
            SemanticTokensOptions {
diff --git a/crates/rust-analyzer/src/cli/progress_report.rs b/crates/rust-analyzer/src/cli/progress_report.rs
index bdbe565e6..5a2dc39d5 100644
--- a/crates/rust-analyzer/src/cli/progress_report.rs
+++ b/crates/rust-analyzer/src/cli/progress_report.rs
@@ -1,7 +1,7 @@
 //! A simple progress bar
 //!
 //! A single thread non-optimized progress bar
-use std::io::Write;
+use std::io::{self, Write};
 /// A Simple ASCII Progress Bar
 pub(crate) struct ProgressReport {
@@ -97,8 +97,8 @@ impl ProgressReport {
            }
        }
-        let _ = std::io::stdout().write(output.as_bytes());
+        let _ = io::stdout().write(output.as_bytes());
-        let _ = std::io::stdout().flush();
+        let _ = io::stdout().flush();
        self.text = text.to_string();
    }
@@ -115,6 +115,8 @@ impl ProgressReport {
        let spaces = " ".repeat(self.text.len());
        let backspaces = "\x08".repeat(self.text.len());
        print!("{}{}{}", backspaces, spaces, backspaces);
+        let _ = io::stdout().flush();
        self.text = String::new();
    }
 }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1f4b5c24c..1db5b4e7d 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -33,7 +33,7 @@ config_data! {
        callInfo_full: bool = "true",
        /// Automatically refresh project info via `cargo metadata` on
-        /// Cargo.toml changes.
+        /// `Cargo.toml` changes.
        cargo_autoreload: bool           = "true",
        /// Activate all available features.
        cargo_allFeatures: bool          = "false",
@@ -52,7 +52,7 @@ config_data! {
        /// Run specified `cargo check` command for diagnostics on save.
        checkOnSave_enable: bool                         = "true",
        /// Check with all features (will be passed as `--all-features`).
-        /// Defaults to `rust-analyzer.cargo.allFeatures`.
+        /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
        checkOnSave_allFeatures: Option<bool>            = "null",
        /// Check all targets and tests (will be passed as `--all-targets`).
        checkOnSave_allTargets: bool                     = "true",
@@ -61,12 +61,12 @@ config_data! {
        /// Do not activate the `default` feature.
        checkOnSave_noDefaultFeatures: Option<bool>      = "null",
        /// Check for a specific target. Defaults to
-        /// `rust-analyzer.cargo.target`.
+        /// `#rust-analyzer.cargo.target#`.
        checkOnSave_target: Option<String>               = "null",
        /// Extra arguments for `cargo check`.
        checkOnSave_extraArgs: Vec<String>               = "[]",
        /// List of features to activate. Defaults to
-        /// `rust-analyzer.cargo.features`.
+        /// `#rust-analyzer.cargo.features#`.
        checkOnSave_features: Option<Vec<String>>        = "null",
        /// Advanced option, fully override the command rust-analyzer uses for
        /// checking. The command should include `--message-format=json` or
@@ -80,7 +80,7 @@ config_data! {
        /// Whether to show postfix snippets like `dbg`, `if`, `not`, etc.
        completion_postfix_enable: bool          = "true",
        /// Toggles the additional completions that automatically add imports when completed.
-        /// Note that your client have to specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
+        /// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
        completion_autoimport_enable: bool       = "true",
        /// Whether to show native rust-analyzer diagnostics.
@@ -90,13 +90,13 @@ config_data! {
        diagnostics_enableExperimental: bool    = "true",
        /// List of rust-analyzer diagnostics to disable.
        diagnostics_disabled: FxHashSet<String> = "[]",
-        /// List of warnings that should be displayed with info severity.\nThe
+        /// List of warnings that should be displayed with info severity.\n\nThe
        /// warnings will be indicated by a blue squiggly underline in code and
-        /// a blue icon in the problems panel.
+        /// a blue icon in the `Problems Panel`.
        diagnostics_warningsAsHint: Vec<String> = "[]",
-        /// List of warnings that should be displayed with hint severity.\nThe
+        /// List of warnings that should be displayed with hint severity.\n\nThe
        /// warnings will be indicated by faded text or three dots in code and
-        /// will not show up in the problems panel.
+        /// will not show up in the `Problems Panel`.
        diagnostics_warningsAsInfo: Vec<String> = "[]",
        /// Controls file watching implementation.
@@ -121,7 +121,7 @@ config_data! {
        /// Whether to show inlay type hints for method chains.
        inlayHints_chainingHints: bool      = "true",
-        /// Maximum length for inlay hints.
+        /// Maximum length for inlay hints. Default is unlimited.
        inlayHints_maxLength: Option<usize> = "null",
        /// Whether to show function parameter name inlay hints at the call
        /// site.
@@ -145,27 +145,27 @@ config_data! {
        lens_methodReferences: bool = "false",
        /// Disable project auto-discovery in favor of explicitly specified set
-        /// of projects.  \nElements must be paths pointing to Cargo.toml,
+        /// of projects.\n\nElements must be paths pointing to `Cargo.toml`,
-        /// rust-project.json, or JSON objects in rust-project.json format.
+        /// `rust-project.json`, or JSON objects in `rust-project.json` format.
        linkedProjects: Vec<ManifestOrProjectJson> = "[]",
-        /// Number of syntax trees rust-analyzer keeps in memory.
+        /// Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.
        lruCapacity: Option<usize>                 = "null",
        /// Whether to show `can't find Cargo.toml` error message.
        notifications_cargoTomlNotFound: bool      = "true",
-        /// Enable Proc macro support, cargo.loadOutDirsFromCheck must be
+        /// Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be
        /// enabled.
        procMacro_enable: bool                     = "false",
        /// Command to be executed instead of 'cargo' for runnables.
        runnables_overrideCargo: Option<String> = "null",
        /// Additional arguments to be passed to cargo for runnables such as
-        /// tests or binaries.\nFor example, it may be '--release'.
+        /// tests or binaries.\nFor example, it may be `--release`.
        runnables_cargoExtraArgs: Vec<String>   = "[]",
        /// Path to the rust compiler sources, for usage in rustc_private projects.
        rustcSource : Option<String> = "null",
-        /// Additional arguments to rustfmt.
+        /// Additional arguments to `rustfmt`.
        rustfmt_extraArgs: Vec<String>               = "[]",
        /// Advanced option, fully override the command rust-analyzer uses for
        /// formatting.
@@ -349,12 +349,12 @@ impl Config {
        res
    }
    pub fn update(&mut self, json: serde_json::Value) {
-        log::info!("Config::update({:#})", json);
+        log::info!("updating config from JSON: {:#}", json);
        if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
            return;
        }
        self.do_update(json);
-        log::info!("Config::update() = {:#?}", self);
+        log::info!("updated config: {:#?}", self);
    }
    fn do_update(&mut self, json: serde_json::Value) {
        let data = ConfigData::from_json(json);
@@ -758,7 +758,7 @@ fn field_props(field: &str, ty: &str, doc: &[&str], default: &str) -> serde_json
            ],
            "enumDescriptions": [
                "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
-                "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name",
+                "Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name.",
                "Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
            ],
        },
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index f16f97131..540759198 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -319,6 +319,10 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
                message: "original diagnostic".to_string(),
            };
            for info in &related_information {
+                // Filter out empty/non-existent messages, as they greatly confuse VS Code.
+                if info.message.is_empty() {
+                    continue;
+                }
                diagnostics.push(MappedRustDiagnostic {
                    url: info.location.uri.clone(),
                    fixes: fixes.clone(), // share fixes to make them easier to apply
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index ec37fba04..948cfc17c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -5,11 +5,13 @@
 use std::{
    io::Write as _,
    process::{self, Stdio},
+    sync::Arc,
 };
 use ide::{
-    CompletionResolveCapability, FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData,
+    AssistConfig, CompletionResolveCapability, FileId, FilePosition, FileRange, HoverAction,
-    NavigationTarget, Query, RangeInfo, Runnable, RunnableKind, SearchScope, SymbolKind, TextEdit,
+    HoverGotoTypeData, LineIndex, NavigationTarget, Query, RangeInfo, Runnable, RunnableKind,
+    SearchScope, SourceChange, SymbolKind, TextEdit,
 };
 use itertools::Itertools;
 use lsp_server::ErrorCode;
@@ -401,6 +403,45 @@ pub(crate) fn handle_workspace_symbol(
    }
 }
+pub(crate) fn handle_will_rename_files(
+    snap: GlobalStateSnapshot,
+    params: lsp_types::RenameFilesParams,
+) -> Result<Option<lsp_types::WorkspaceEdit>> {
+    let _p = profile::span("handle_will_rename_files");
+    let source_changes: Vec<SourceChange> = params
+        .files
+        .into_iter()
+        .filter_map(|file_rename| {
+            let from = Url::parse(&file_rename.old_uri).ok()?;
+            let to = Url::parse(&file_rename.new_uri).ok()?;
+            let from_path = from.to_file_path().ok()?;
+            let to_path = to.to_file_path().ok()?;
+            // Limit to single-level moves for now.
+            match (from_path.parent(), to_path.parent()) {
+                (Some(p1), Some(p2)) if p1 == p2 => {
+                    let new_name = to_path.file_stem()?;
+                    let new_name = new_name.to_str()?;
+                    Some((snap.url_to_file_id(&from).ok()?, new_name.to_string()))
+                }
+                _ => None,
+            }
+        })
+        .filter_map(|(file_id, new_name)| {
+            snap.analysis.will_rename_file(file_id, &new_name).ok()?
+        })
+        .collect();
+    // Drop file system edits since we're just renaming things on the same level
+    let edits = source_changes.into_iter().map(|it| it.source_file_edits).flatten().collect();
+    let source_change = SourceChange::from_edits(edits, Vec::new());
+    let workspace_edit = to_proto::workspace_edit(&snap, source_change)?;
+    Ok(Some(workspace_edit))
+}
 pub(crate) fn handle_goto_definition(
    snap: GlobalStateSnapshot,
    params: lsp_types::GotoDefinitionParams,
@@ -641,7 +682,7 @@ pub(crate) fn handle_completion_resolve(
            &snap.config.completion,
            FilePosition { file_id, offset },
            &resolve_data.full_import_path,
-            &resolve_data.imported_name,
+            resolve_data.imported_name,
        )?
        .into_iter()
        .flat_map(|edit| {
@@ -821,16 +862,18 @@ pub(crate) fn handle_formatting(
        }
    };
-    let mut rustfmt = rustfmt.stdin(Stdio::piped()).stdout(Stdio::piped()).spawn()?;
+    let mut rustfmt =
+        rustfmt.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn()?;
    rustfmt.stdin.as_mut().unwrap().write_all(file.as_bytes())?;
    let output = rustfmt.wait_with_output()?;
    let captured_stdout = String::from_utf8(output.stdout)?;
+    let captured_stderr = String::from_utf8(output.stderr).unwrap_or_default();
    if !output.status.success() {
        match output.status.code() {
-            Some(1) => {
+            Some(1) if !captured_stderr.contains("not installed") => {
                // While `rustfmt` doesn't have a specific exit code for parse errors this is the
                // likely cause exiting with 1. Most Language Servers swallow parse errors on
                // formatting because otherwise an error is surfaced to the user on top of the
@@ -846,8 +889,9 @@ pub(crate) fn handle_formatting(
                    format!(
                        r#"rustfmt exited with:
                           Status: {}
-                           stdout: {}"#,
+                           stdout: {}
-                        output.status, captured_stdout,
+                           stderr: {}"#,
+                        output.status, captured_stdout, captured_stderr,
                    ),
                )
                .into());
@@ -867,58 +911,8 @@ pub(crate) fn handle_formatting(
    }
 }
-fn handle_fixes(
-    snap: &GlobalStateSnapshot,
-    params: &lsp_types::CodeActionParams,
-    res: &mut Vec<lsp_ext::CodeAction>,
-) -> Result<()> {
-    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
-    let line_index = snap.analysis.file_line_index(file_id)?;
-    let range = from_proto::text_range(&line_index, params.range);
-    match &params.context.only {
-        Some(v) => {
-            if !v.iter().any(|it| {
-                it == &lsp_types::CodeActionKind::EMPTY
-                    || it == &lsp_types::CodeActionKind::QUICKFIX
-            }) {
-                return Ok(());
-            }
-        }
-        None => {}
-    };
-    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics, file_id)?;
-    for fix in diagnostics
-        .into_iter()
-        .filter_map(|d| d.fix)
-        .filter(|fix| fix.fix_trigger_range.intersect(range).is_some())
-    {
-        let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
-        let action = lsp_ext::CodeAction {
-            title: fix.label.to_string(),
-            group: None,
-            kind: Some(CodeActionKind::QUICKFIX),
-            edit: Some(edit),
-            is_preferred: Some(false),
-            data: None,
-        };
-        res.push(action);
-    }
-    for fix in snap.check_fixes.get(&file_id).into_iter().flatten() {
-        let fix_range = from_proto::text_range(&line_index, fix.range);
-        if fix_range.intersect(range).is_none() {
-            continue;
-        }
-        res.push(fix.action.clone());
-    }
-    Ok(())
-}
 pub(crate) fn handle_code_action(
-    mut snap: GlobalStateSnapshot,
+    snap: GlobalStateSnapshot,
    params: lsp_types::CodeActionParams,
 ) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
    let _p = profile::span("handle_code_action");
@@ -934,24 +928,35 @@ pub(crate) fn handle_code_action(
    let range = from_proto::text_range(&line_index, params.range);
    let frange = FileRange { file_id, range };
-    snap.config.assist.allowed = params
+    let assists_config = AssistConfig {
-        .clone()
+        allowed: params
-        .context
+            .clone()
-        .only
+            .context
-        .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
+            .only
+            .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect()),
+        ..snap.config.assist
+    };
    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
-    handle_fixes(&snap, &params, &mut res)?;
+    let include_quick_fixes = match &params.context.only {
+        Some(v) => v.iter().any(|it| {
+            it == &lsp_types::CodeActionKind::EMPTY || it == &lsp_types::CodeActionKind::QUICKFIX
+        }),
+        None => true,
+    };
+    if include_quick_fixes {
+        add_quick_fixes(&snap, frange, &line_index, &mut res)?;
+    }
    if snap.config.client_caps.code_action_resolve {
        for (index, assist) in
-            snap.analysis.unresolved_assists(&snap.config.assist, frange)?.into_iter().enumerate()
+            snap.analysis.assists(&assists_config, false, frange)?.into_iter().enumerate()
        {
            res.push(to_proto::unresolved_code_action(&snap, params.clone(), assist, index)?);
        }
    } else {
-        for assist in snap.analysis.resolved_assists(&snap.config.assist, frange)?.into_iter() {
+        for assist in snap.analysis.assists(&assists_config, true, frange)?.into_iter() {
            res.push(to_proto::resolved_code_action(&snap, assist)?);
        }
    }
@@ -959,6 +964,40 @@ pub(crate) fn handle_code_action(
    Ok(Some(res))
 }
+fn add_quick_fixes(
+    snap: &GlobalStateSnapshot,
+    frange: FileRange,
+    line_index: &Arc<LineIndex>,
+    acc: &mut Vec<lsp_ext::CodeAction>,
+) -> Result<()> {
+    let diagnostics = snap.analysis.diagnostics(&snap.config.diagnostics, frange.file_id)?;
+    for fix in diagnostics
+        .into_iter()
+        .filter_map(|d| d.fix)
+        .filter(|fix| fix.fix_trigger_range.intersect(frange.range).is_some())
+    {
+        let edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
+        let action = lsp_ext::CodeAction {
+            title: fix.label.to_string(),
+            group: None,
+            kind: Some(CodeActionKind::QUICKFIX),
+            edit: Some(edit),
+            is_preferred: Some(false),
+            data: None,
+        };
+        acc.push(action);
+    }
+    for fix in snap.check_fixes.get(&frange.file_id).into_iter().flatten() {
+        let fix_range = from_proto::text_range(&line_index, fix.range);
+        if fix_range.intersect(frange.range).is_some() {
+            acc.push(fix.action.clone());
+        }
+    }
+    Ok(())
+}
 pub(crate) fn handle_code_action_resolve(
    mut snap: GlobalStateSnapshot,
    mut code_action: lsp_ext::CodeAction,
@@ -980,11 +1019,11 @@ pub(crate) fn handle_code_action_resolve(
        .only
        .map(|it| it.into_iter().filter_map(from_proto::assist_kind).collect());
-    let assists = snap.analysis.resolved_assists(&snap.config.assist, frange)?;
+    let assists = snap.analysis.assists(&snap.config.assist, true, frange)?;
    let (id, index) = split_once(&params.id, ':').unwrap();
    let index = index.parse::<usize>().unwrap();
    let assist = &assists[index];
-    assert!(assist.assist.id.0 == id);
+    assert!(assist.id.0 == id);
    let edit = to_proto::resolved_code_action(&snap, assist.clone())?.edit;
    code_action.edit = edit;
    Ok(code_action)
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 682fa5f7f..c9494e300 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -47,7 +47,7 @@ pub type Error = Box<dyn std::error::Error + Send + Sync>;
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 pub fn from_json<T: DeserializeOwned>(what: &'static str, json: serde_json::Value) -> Result<T> {
-    let res = T::deserialize(&json)
+    let res = serde_path_to_error::deserialize(&json)
        .map_err(|e| format!("Failed to deserialize {}: {}; {}", what, e, json))?;
    Ok(res)
 }
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index ec3d5e060..5d55dc96e 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -485,6 +485,7 @@ impl GlobalState {
            .on::<lsp_types::request::SemanticTokensRangeRequest>(
                handlers::handle_semantic_tokens_range,
            )
+            .on::<lsp_types::request::WillRenameFiles>(handlers::handle_will_rename_files)
            .on::<lsp_ext::Ssr>(handlers::handle_ssr)
            .finish();
        Ok(())
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 1daad1c98..c2f6a655d 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -45,6 +45,7 @@ define_semantic_token_types![
    (FORMAT_SPECIFIER, "formatSpecifier"),
    (GENERIC, "generic"),
    (LIFETIME, "lifetime"),
+    (LABEL, "label"),
    (PUNCTUATION, "punctuation"),
    (SELF_KEYWORD, "selfKeyword"),
    (TYPE_ALIAS, "typeAlias"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index e0561b5a7..1a38e79f0 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -8,8 +8,8 @@ use ide::{
    Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag,
    HighlightedRange, Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup,
-    NavigationTarget, ReferenceAccess, ResolvedAssist, Runnable, Severity, SourceChange,
+    NavigationTarget, ReferenceAccess, Runnable, Severity, SourceChange, SourceFileEdit,
-    SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
+    SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
@@ -46,7 +46,8 @@ pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
        SymbolKind::Local
        | SymbolKind::SelfParam
        | SymbolKind::LifetimeParam
-        | SymbolKind::ValueParam => lsp_types::SymbolKind::Variable,
+        | SymbolKind::ValueParam
+        | SymbolKind::Label => lsp_types::SymbolKind::Variable,
        SymbolKind::Union => lsp_types::SymbolKind::Struct,
    }
 }
@@ -378,6 +379,7 @@ fn semantic_token_type_and_modifiers(
            SymbolKind::Field => lsp_types::SemanticTokenType::PROPERTY,
            SymbolKind::TypeParam => lsp_types::SemanticTokenType::TYPE_PARAMETER,
            SymbolKind::LifetimeParam => semantic_tokens::LIFETIME,
+            SymbolKind::Label => semantic_tokens::LABEL,
            SymbolKind::ValueParam => lsp_types::SemanticTokenType::PARAMETER,
            SymbolKind::SelfParam => semantic_tokens::SELF_KEYWORD,
            SymbolKind::Local => lsp_types::SemanticTokenType::VARIABLE,
@@ -634,30 +636,47 @@ pub(crate) fn snippet_text_document_edit(
    Ok(lsp_ext::SnippetTextDocumentEdit { text_document, edits })
 }
-pub(crate) fn resource_op(
+pub(crate) fn snippet_text_document_ops(
    snap: &GlobalStateSnapshot,
    file_system_edit: FileSystemEdit,
-) -> lsp_types::ResourceOp {
+) -> Vec<lsp_ext::SnippetDocumentChangeOperation> {
+    let mut ops = Vec::new();
    match file_system_edit {
-        FileSystemEdit::CreateFile { dst } => {
+        FileSystemEdit::CreateFile { dst, initial_contents } => {
            let uri = snap.anchored_path(&dst);
-            lsp_types::ResourceOp::Create(lsp_types::CreateFile {
+            let create_file = lsp_types::ResourceOp::Create(lsp_types::CreateFile {
-                uri,
+                uri: uri.clone(),
                options: None,
                annotation_id: None,
-            })
+            });
+            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(create_file));
+            if !initial_contents.is_empty() {
+                let text_document =
+                    lsp_types::OptionalVersionedTextDocumentIdentifier { uri, version: None };
+                let range = range(&LineIndex::new(""), TextRange::empty(TextSize::from(0)));
+                let text_edit = lsp_ext::SnippetTextEdit {
+                    range,
+                    new_text: initial_contents,
+                    insert_text_format: Some(lsp_types::InsertTextFormat::PlainText),
+                };
+                let edit_file =
+                    lsp_ext::SnippetTextDocumentEdit { text_document, edits: vec![text_edit] };
+                ops.push(lsp_ext::SnippetDocumentChangeOperation::Edit(edit_file));
+            }
        }
        FileSystemEdit::MoveFile { src, dst } => {
            let old_uri = snap.file_id_to_url(src);
            let new_uri = snap.anchored_path(&dst);
-            lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
+            let rename_file = lsp_types::ResourceOp::Rename(lsp_types::RenameFile {
                old_uri,
                new_uri,
                options: None,
                annotation_id: None,
-            })
+            });
+            ops.push(lsp_ext::SnippetDocumentChangeOperation::Op(rename_file))
        }
    }
+    ops
 }
 pub(crate) fn snippet_workspace_edit(
@@ -666,8 +685,8 @@ pub(crate) fn snippet_workspace_edit(
 ) -> Result<lsp_ext::SnippetWorkspaceEdit> {
    let mut document_changes: Vec<lsp_ext::SnippetDocumentChangeOperation> = Vec::new();
    for op in source_change.file_system_edits {
-        let op = resource_op(&snap, op);
+        let ops = snippet_text_document_ops(snap, op);
-        document_changes.push(lsp_ext::SnippetDocumentChangeOperation::Op(op));
+        document_changes.extend_from_slice(&ops);
    }
    for edit in source_change.source_file_edits {
        let edit = snippet_text_document_edit(&snap, source_change.is_snippet, edit)?;
@@ -761,6 +780,7 @@ pub(crate) fn unresolved_code_action(
    assist: Assist,
    index: usize,
 ) -> Result<lsp_ext::CodeAction> {
+    assert!(assist.source_change.is_none());
    let res = lsp_ext::CodeAction {
        title: assist.label.to_string(),
        group: assist.group.filter(|_| snap.config.client_caps.code_action_group).map(|gr| gr.0),
@@ -777,18 +797,14 @@ pub(crate) fn unresolved_code_action(
 pub(crate) fn resolved_code_action(
    snap: &GlobalStateSnapshot,
-    assist: ResolvedAssist,
+    assist: Assist,
 ) -> Result<lsp_ext::CodeAction> {
-    let change = assist.source_change;
+    let change = assist.source_change.unwrap();
    let res = lsp_ext::CodeAction {
        edit: Some(snippet_workspace_edit(snap, change)?),
-        title: assist.assist.label.to_string(),
+        title: assist.label.to_string(),
-        group: assist
+        group: assist.group.filter(|_| snap.config.client_caps.code_action_group).map(|gr| gr.0),
-            .assist
+        kind: Some(code_action_kind(assist.id.1)),
-            .group
-            .filter(|_| snap.config.client_caps.code_action_group)
-            .map(|gr| gr.0),
-        kind: Some(code_action_kind(assist.assist.id.1)),
        is_preferred: None,
        data: None,
    };
diff --git a/crates/ssr/Cargo.toml b/crates/ssr/Cargo.toml
index 98ed25fb6..339eda86a 100644
--- a/crates/ssr/Cargo.toml
+++ b/crates/ssr/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 rustc-hash = "1.1.0"
-itertools = "0.9.0"
+itertools = "0.10.0"
 text_edit = { path = "../text_edit", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/ssr/src/matching.rs b/crates/ssr/src/matching.rs
index 99b187311..6cf831431 100644
--- a/crates/ssr/src/matching.rs
+++ b/crates/ssr/src/matching.rs
@@ -473,7 +473,9 @@ impl<'db, 'sema> Matcher<'db, 'sema> {
                        }
                        SyntaxElement::Node(n) => {
                            if let Some(first_token) = n.first_token() {
-                                if Some(first_token.to_string()) == next_pattern_token {
+                                if Some(first_token.text().as_str())
+                                    == next_pattern_token.as_deref()
+                                {
                                    if let Some(SyntaxElement::Node(p)) = pattern.next() {
                                        // We have a subtree that starts with the next token in our pattern.
                                        self.attempt_match_token_tree(phase, &p, &n)?;
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index c6a6f11e1..5d8389ade 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -11,9 +11,9 @@ edition = "2018"
 doctest = false
 [dependencies]
-itertools = "0.9.0"
+itertools = "0.10.0"
 rowan = "0.10.0"
-rustc_lexer = { version = "691.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "695.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
index e4a9b945c..636ce166d 100644
--- a/crates/syntax/src/ast/expr_ext.rs
+++ b/crates/syntax/src/ast/expr_ext.rs
@@ -358,6 +358,7 @@ pub enum Effect {
    Async(SyntaxToken),
    Unsafe(SyntaxToken),
    Try(SyntaxToken),
+    Const(SyntaxToken),
    // Very much not an effect, but we stuff it into this node anyway
    Label(ast::Label),
 }
@@ -373,6 +374,9 @@ impl ast::EffectExpr {
        if let Some(token) = self.try_token() {
            return Effect::Try(token);
        }
+        if let Some(token) = self.const_token() {
+            return Effect::Const(token);
+        }
        if let Some(label) = self.label() {
            return Effect::Label(label);
        }
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 1588ba93e..c5b80bffe 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -763,6 +763,7 @@ impl EffectExpr {
    pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }
    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
+    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -1251,6 +1252,14 @@ impl TupleStructPat {
    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConstBlockPat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ConstBlockPat {
+    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
+    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordPatFieldList {
    pub(crate) syntax: SyntaxNode,
 }
@@ -1369,6 +1378,7 @@ pub enum Pat {
    SlicePat(SlicePat),
    TuplePat(TuplePat),
    TupleStructPat(TupleStructPat),
+    ConstBlockPat(ConstBlockPat),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum FieldList {
@@ -2772,6 +2782,17 @@ impl AstNode for TupleStructPat {
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for ConstBlockPat {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for RecordPatFieldList {
    fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3242,12 +3263,15 @@ impl From<TuplePat> for Pat {
 impl From<TupleStructPat> for Pat {
    fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
 }
+impl From<ConstBlockPat> for Pat {
+    fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) }
+}
 impl AstNode for Pat {
    fn can_cast(kind: SyntaxKind) -> bool {
        match kind {
            IDENT_PAT | BOX_PAT | REST_PAT | LITERAL_PAT | MACRO_PAT | OR_PAT | PAREN_PAT
            | PATH_PAT | WILDCARD_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT
-            | TUPLE_PAT | TUPLE_STRUCT_PAT => true,
+            | TUPLE_PAT | TUPLE_STRUCT_PAT | CONST_BLOCK_PAT => true,
            _ => false,
        }
    }
@@ -3268,6 +3292,7 @@ impl AstNode for Pat {
            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
+            CONST_BLOCK_PAT => Pat::ConstBlockPat(ConstBlockPat { syntax }),
            _ => return None,
        };
        Some(res)
@@ -3289,6 +3314,7 @@ impl AstNode for Pat {
            Pat::SlicePat(it) => &it.syntax,
            Pat::TuplePat(it) => &it.syntax,
            Pat::TupleStructPat(it) => &it.syntax,
+            Pat::ConstBlockPat(it) => &it.syntax,
        }
    }
 }
@@ -4137,6 +4163,11 @@ impl std::fmt::Display for TupleStructPat {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
+impl std::fmt::Display for ConstBlockPat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for RecordPatFieldList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index ba7e5d2fb..cafa4c198 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -4,6 +4,11 @@
 //! Note that all functions here intended to be stupid constructors, which just
 //! assemble a finish node from immediate children. If you want to do something
 //! smarter than that, it probably doesn't belong in this module.
+//!
+//! Keep in mind that `from_text` functions should be kept private. The public
+//! API should require to assemble every node piecewise. The trick of
+//! `parse(format!())` we use internally is an implementation detail -- long
+//! term, it will be replaced with direct tree manipulation.
 use itertools::Itertools;
 use stdx::format_to;
@@ -16,7 +21,8 @@ pub fn name(text: &str) -> ast::Name {
 pub fn name_ref(text: &str) -> ast::NameRef {
    ast_from_text(&format!("fn f() {{ {}; }}", text))
 }
+// FIXME: replace stringly-typed constructor with a family of typed ctors, a-la
+// `expr_xxx`.
 pub fn ty(text: &str) -> ast::Type {
    ast_from_text(&format!("impl {} for D {{}};", text))
 }
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index c45cb514a..2aa472fb4 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -193,6 +193,14 @@ impl ast::UseTreeList {
            .and_then(ast::UseTree::cast)
            .expect("UseTreeLists are always nested in UseTrees")
    }
+    pub fn has_inner_comment(&self) -> bool {
+        self.syntax()
+            .children_with_tokens()
+            .filter_map(|it| it.into_token())
+            .find_map(ast::Comment::cast)
+            .is_some()
+    }
 }
 impl ast::Impl {
diff --git a/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rast b/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rast
new file mode 100644
index 000000000..8ff4822c4
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rast
@@ -0,0 +1,76 @@
+[email protected]
+  [email protected]
+    [email protected] "fn"
+    [email protected] " "
+    [email protected]
+      [email protected] "main"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] "\n    "
+      [email protected]
+        [email protected] "let"
+        [email protected] " "
+        [email protected]
+          [email protected] "const"
+          [email protected] " "
+          [email protected]
+            [email protected] "{"
+            [email protected] " "
+            [email protected]
+              [email protected] "15"
+            [email protected] " "
+            [email protected] "}"
+        [email protected] " "
+        [email protected] "="
+        [email protected] " "
+        [email protected]
+          [email protected] "("
+          [email protected] ")"
+        [email protected] ";"
+      [email protected] "\n    "
+      [email protected]
+        [email protected] "let"
+        [email protected] " "
+        [email protected]
+          [email protected] "const"
+          [email protected] " "
+          [email protected]
+            [email protected] "{"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected]
+                        [email protected] "foo"
+                [email protected]
+                  [email protected] "("
+                  [email protected] ")"
+              [email protected] ";"
+            [email protected] " "
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected]
+                    [email protected]
+                      [email protected] "bar"
+              [email protected]
+                [email protected] "("
+                [email protected] ")"
+            [email protected] " "
+            [email protected] "}"
+        [email protected] " "
+        [email protected] "="
+        [email protected] " "
+        [email protected]
+          [email protected] "("
+          [email protected] ")"
+        [email protected] ";"
+      [email protected] "\n"
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rs b/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rs
new file mode 100644
index 000000000..dce9defac
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0156_const_block_pat.rs
@@ -0,0 +1,4 @@
+fn main() {
+    let const { 15 } = ();
+    let const { foo(); bar() } = ();
+}
diff --git a/crates/syntax/test_data/parser/inline/ok/0157_const_block.rast b/crates/syntax/test_data/parser/inline/ok/0157_const_block.rast
new file mode 100644
index 000000000..d5d2c8fe3
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0157_const_block.rast
@@ -0,0 +1,23 @@
+[email protected]
+  [email protected]
+    [email protected] "fn"
+    [email protected] " "
+    [email protected]
+      [email protected] "f"
+    [email protected]
+      [email protected] "("
+      [email protected] ")"
+    [email protected] " "
+    [email protected]
+      [email protected] "{"
+      [email protected] " "
+      [email protected]
+        [email protected] "const"
+        [email protected] " "
+        [email protected]
+          [email protected] "{"
+          [email protected] " "
+          [email protected] "}"
+      [email protected] " "
+      [email protected] "}"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0157_const_block.rs b/crates/syntax/test_data/parser/inline/ok/0157_const_block.rs
new file mode 100644
index 000000000..a2e3565a3
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0157_const_block.rs
@@ -0,0 +1 @@
+fn f() { const { } }
diff --git a/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rast b/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rast
new file mode 100644
index 000000000..4a1f712aa
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rast
@@ -0,0 +1,57 @@
+[email protected]
+  [email protected]
+    [email protected] "macro_rules"
+    [email protected] "!"
+    [email protected] " "
+    [email protected]
+      [email protected] "m"
+    [email protected] " "
+    [email protected]
+      [email protected] "("
+      [email protected] " "
+      [email protected]
+        [email protected] "("
+        [email protected] "$"
+        [email protected] "i"
+        [email protected] ":"
+        [email protected] "ident"
+        [email protected] ")"
+      [email protected] " "
+      [email protected] "="
+      [email protected] ">"
+      [email protected] " "
+      [email protected]
+        [email protected] "{"
+        [email protected] "}"
+      [email protected] " "
+      [email protected] ")"
+    [email protected] ";"
+  [email protected] "\n"
+  [email protected]
+    [email protected] "macro_rules"
+    [email protected] "!"
+    [email protected] " "
+    [email protected]
+      [email protected] "m"
+    [email protected] " "
+    [email protected]
+      [email protected] "["
+      [email protected] " "
+      [email protected]
+        [email protected] "("
+        [email protected] "$"
+        [email protected] "i"
+        [email protected] ":"
+        [email protected] "ident"
+        [email protected] ")"
+      [email protected] " "
+      [email protected] "="
+      [email protected] ">"
+      [email protected] " "
+      [email protected]
+        [email protected] "{"
+        [email protected] "}"
+      [email protected] " "
+      [email protected] "]"
+    [email protected] ";"
+  [email protected] "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rs b/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rs
new file mode 100644
index 000000000..6033a28cd
--- /dev/null
+++ b/crates/syntax/test_data/parser/inline/ok/0158_macro_rules_non_brace.rs
@@ -0,0 +1,2 @@
+macro_rules! m ( ($i:ident) => {} );
+macro_rules! m [ ($i:ident) => {} ];
diff --git a/crates/tt/src/lib.rs b/crates/tt/src/lib.rs
index 6c1bf8d09..8301dc28a 100644
--- a/crates/tt/src/lib.rs
+++ b/crates/tt/src/lib.rs
@@ -1,7 +1,7 @@
 //! `tt` crate defines a `TokenTree` data structure: this is the interface (both
 //! input and output) of macros. It closely mirrors `proc_macro` crate's
 //! `TokenTree`.
-use std::{fmt, panic::RefUnwindSafe};
+use std::fmt;
 use stdx::impl_from;
@@ -247,8 +247,3 @@ impl fmt::Display for ExpansionError {
        }
    }
 }
-pub trait TokenExpander: fmt::Debug + Send + Sync + RefUnwindSafe {
-    fn expand(&self, subtree: &Subtree, attrs: Option<&Subtree>)
-        -> Result<Subtree, ExpansionError>;
-}