72 files changed, 981 insertions, 438 deletions
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index 80cf9aba1..4f59d39a9 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -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)),
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/lib.rs b/crates/assists/src/lib.rs
index 6b89b2d04..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()
    }
 }
diff --git a/crates/assists/src/tests.rs b/crates/assists/src/tests.rs
index b41f4874a..21e448fb8 100644
--- a/crates/assists/src/tests.rs
+++ b/crates/assists/src/tests.rs
@@ -48,24 +48,25 @@ 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 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 source_change = assist.source_change.unwrap();
        let mut actual = before;
-        for source_file_edit in assist.source_change.source_file_edits {
+        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)
            }
@@ -90,18 +91,18 @@ 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
                && source_change.file_system_edits.len() == 0;
@@ -138,7 +139,7 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
            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!"),
@@ -155,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]
@@ -178,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]
@@ -203,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 e9093ec53..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!()
    }
 }
 "#####,
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/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 1d7e5ddd7..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);
+                }
            }
        }
@@ -1206,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/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 978c3a324..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,10 +934,16 @@ impl ExprCollector<'_> {
                let inner = self.collect_pat_opt(boxpat.pat());
                Pat::Box { inner }
            }
-            // FIXME: implement
+            ast::Pat::ConstBlockPat(const_block_pat) => {
-            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) | ast::Pat::ConstBlockPat(_) => {
+                if let Some(expr) = const_block_pat.block_expr() {
-                Pat::Missing
+                    let expr_id = self.collect_block(expr);
+                    Pat::ConstBlock(expr_id)
+                } else {
+                    Pat::Missing
+                }
            }
+            // FIXME: implement
+            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
        self.alloc_pat(pattern, Either::Left(ptr))
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/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/db.rs b/crates/hir_expand/src/db.rs
index 077de3727..06f0a3ed9 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -271,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/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..965c1780a 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -17,9 +17,9 @@ 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..70a3f3075 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());
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/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 3ad30f0c9..038273750 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -248,35 +248,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 +258,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 +279,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) {
@@ -764,25 +715,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
-            }
+}
-            ",
+"#,
        )
    }
@@ -802,7 +753,7 @@ struct Foo {
    #[test]
    fn test_rename_incorrect_case() {
-        check_fixes(
+        check_fix(
            r#"
 pub struct test_struct<|> { one: i32 }
@@ -819,7 +770,7 @@ pub fn some_fn(val: TestStruct) -> TestStruct {
 "#,
        );
-        check_fixes(
+        check_fix(
            r#"
 pub fn some_fn(NonSnakeCase<|>: u8) -> u8 {
    NonSnakeCase
@@ -832,7 +783,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 }
@@ -845,7 +796,7 @@ pub fn some_fn(val: u8) -> u8 {
 "#,
        );
-        check_fixes(
+        check_fix(
            r#"
 fn some_fn() {
    let whatAWeird_Formatting<|> = 10;
@@ -874,7 +825,7 @@ fn foo() {
    #[test]
    fn test_rename_incorrect_case_struct_method() {
-        check_fixes(
+        check_fix(
            r#"
 pub struct TestStruct;
@@ -895,4 +846,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/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 47dd85ceb..912144f8b 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1130,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..41eb139d1 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,
@@ -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 33b7358f7..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;
    };
@@ -1122,4 +1122,26 @@ fn main() {
            "#]],
        );
    }
+    #[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/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/mbe/src/mbe_expander/matcher.rs b/crates/mbe/src/mbe_expander/matcher.rs
index 7aeef7be5..44722c0f1 100644
--- a/crates/mbe/src/mbe_expander/matcher.rs
+++ b/crates/mbe/src/mbe_expander/matcher.rs
@@ -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())
            }
diff --git a/crates/mbe/src/parser.rs b/crates/mbe/src/parser.rs
index c3fdd4040..d681905f5 100644
--- a/crates/mbe/src/parser.rs
+++ b/crates/mbe/src/parser.rs
@@ -101,8 +101,15 @@ fn next_op<'a>(
                    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;
+                        let kind = eat_fragment_kind(src, mode)?;
+                        Op::Var { name, kind }
                    }
                    tt::Leaf::Ident(ident) => {
                        let name = &ident.text;
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/items.rs b/crates/parser/src/grammar/items.rs
index 72b73f891..cf4168d32 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -389,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/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/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/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 0b4d3f4eb..53e70eaf7 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -28,6 +28,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/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 66f8bee99..374fb5302 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;
@@ -400,6 +402,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,
@@ -865,58 +906,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");
@@ -932,24 +923,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)?);
        }
    }
@@ -957,6 +959,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,
@@ -978,11 +1014,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 79fe30e53..d538ad69a 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -46,7 +46,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 5a1ae96aa..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,
@@ -778,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),
@@ -794,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/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index c6a6f11e1..21015591c 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.9.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/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>;
-}