52 files changed, 861 insertions, 492 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 8cb5fd7ad..ff2c33f45 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -89,7 +89,7 @@ dependencies = [
 "cfg-if 1.0.0",
 "libc",
 "miniz_oxide",
- "object",
+ "object 0.22.0",
 "rustc-demangle",
 ]
@@ -500,17 +500,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6503fe142514ca4799d4c26297c4248239fe8838d827db6bd6065c6ed29a6ce"
 [[package]]
-name = "goblin"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20fd25aa456527ce4f544271ae4fea65d2eda4a6561ea56f39fb3ee4f7e3884"
-dependencies = [
- "log",
- "plain",
- "scroll",
-]
-[[package]]
 name = "hashbrown"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1055,6 +1044,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397"
 [[package]]
+name = "object"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a7ab5d64814df0fe4a4b5ead45ed6c5f181ee3ff04ba344313a6c80446c5d4"
+[[package]]
 name = "once_cell"
 version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1159,12 +1154,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b063f57ec186e6140e2b8b6921e5f1bd89c7356dda5b33acc5401203ca6131c"
 [[package]]
-name = "plain"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
-[[package]]
 name = "proc-macro2"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1192,10 +1181,10 @@ version = "0.0.0"
 dependencies = [
 "cargo_metadata",
 "difference",
- "goblin",
 "libloading",
 "mbe",
 "memmap",
+ "object 0.23.0",
 "proc_macro_api",
 "proc_macro_test",
 "serde_derive",
@@ -1472,26 +1461,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 [[package]]
-name = "scroll"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fda28d4b4830b807a8b43f7b0e6b5df875311b3e7621d84577188c175b6ec1ec"
-dependencies = [
- "scroll_derive",
-]
-[[package]]
-name = "scroll_derive"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b12bd20b94c7cdfda8c7ba9b92ad0d9a56e3fa018c25fca83b51aa664c9b4c0d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-[[package]]
 name = "semver"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1858,9 +1827,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 [[package]]
 name = "ungrammar"
-version = "1.1.4"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df0cd89993af555540e2436fc6adb8479b0dbe386339a136397952e9c89e17a9"
+checksum = "873186a460627379e7e28880a0d33b729c205634f6f021321f50b323235e62d7"
 [[package]]
 name = "unicase"
diff --git a/Cargo.toml b/Cargo.toml
index e30ef0e2f..59d36fbc1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,3 +25,5 @@ debug = 0 # Set this to 1 or 2 to get more useful backtraces in debugger.
 # chalk-solve = { path = "../chalk/chalk-solve" }
 # chalk-ir = { path = "../chalk/chalk-ir" }
 # chalk-recursive = { path = "../chalk/chalk-recursive" }
+# ungrammar = { path = "../ungrammar" }
diff --git a/crates/assists/src/handlers/reorder_fields.rs b/crates/assists/src/handlers/reorder_fields.rs
index 7c0f0f44e..fe5574242 100644
--- a/crates/assists/src/handlers/reorder_fields.rs
+++ b/crates/assists/src/handlers/reorder_fields.rs
@@ -4,6 +4,7 @@ use rustc_hash::FxHashMap;
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
 use ide_db::RootDatabase;
 use syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
+use test_utils::mark;
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -38,6 +39,7 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    });
    if sorted_fields == fields {
+        mark::hit!(reorder_sorted_fields);
        return None;
    }
@@ -107,22 +109,25 @@ fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
 #[cfg(test)]
 mod tests {
+    use test_utils::mark;
    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
    #[test]
-    fn not_applicable_if_sorted() {
+    fn reorder_sorted_fields() {
+        mark::check!(reorder_sorted_fields);
        check_assist_not_applicable(
            reorder_fields,
            r#"
-        struct Foo {
+struct Foo {
-            foo: i32,
+    foo: i32,
-            bar: i32,
+    bar: i32,
-        }
+}
-        const test: Foo = <|>Foo { foo: 0, bar: 0 };
+const test: Foo = <|>Foo { foo: 0, bar: 0 };
-        "#,
+"#,
        )
    }
@@ -131,9 +136,9 @@ mod tests {
        check_assist_not_applicable(
            reorder_fields,
            r#"
-        struct Foo {};
+struct Foo {};
-        const test: Foo = <|>Foo {}
+const test: Foo = <|>Foo {}
-        "#,
+"#,
        )
    }
@@ -142,13 +147,13 @@ mod tests {
        check_assist(
            reorder_fields,
            r#"
-        struct Foo {foo: i32, bar: i32};
+struct Foo {foo: i32, bar: i32};
-        const test: Foo = <|>Foo {bar: 0, foo: 1}
+const test: Foo = <|>Foo {bar: 0, foo: 1}
-        "#,
+"#,
            r#"
-        struct Foo {foo: i32, bar: i32};
+struct Foo {foo: i32, bar: i32};
-        const test: Foo = Foo {foo: 1, bar: 0}
+const test: Foo = Foo {foo: 1, bar: 0}
-        "#,
+"#,
        )
    }
@@ -157,25 +162,25 @@ mod tests {
        check_assist(
            reorder_fields,
            r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
-        fn f(f: Foo) -> {
+fn f(f: Foo) -> {
-            match f {
+    match f {
-                <|>Foo { baz: 0, ref mut bar, .. } => (),
+        <|>Foo { baz: 0, ref mut bar, .. } => (),
-                _ => ()
+        _ => ()
-            }
+    }
-        }
+}
-        "#,
+"#,
            r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
-        fn f(f: Foo) -> {
+fn f(f: Foo) -> {
-            match f {
+    match f {
-                Foo { ref mut bar, baz: 0, .. } => (),
+        Foo { ref mut bar, baz: 0, .. } => (),
-                _ => ()
+        _ => ()
-            }
+    }
-        }
+}
-        "#,
+"#,
        )
    }
@@ -184,39 +189,39 @@ mod tests {
        check_assist(
            reorder_fields,
            r#"
-            struct Foo {
+struct Foo {
-                foo: String,
+    foo: String,
-                bar: String,
+    bar: String,
-            }
+}
-            impl Foo {
+impl Foo {
-                fn new() -> Foo {
+    fn new() -> Foo {
-                    let foo = String::new();
+        let foo = String::new();
-                    <|>Foo {
+        <|>Foo {
-                        bar: foo.clone(),
+            bar: foo.clone(),
-                        extra: "Extra field",
+            extra: "Extra field",
-                        foo,
+            foo,
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
            r#"
-            struct Foo {
+struct Foo {
-                foo: String,
+    foo: String,
-                bar: String,
+    bar: String,
-            }
+}
-            impl Foo {
+impl Foo {
-                fn new() -> Foo {
+    fn new() -> Foo {
-                    let foo = String::new();
+        let foo = String::new();
-                    Foo {
+        Foo {
-                        foo,
+            foo,
-                        bar: foo.clone(),
+            bar: foo.clone(),
-                        extra: "Extra field",
+            extra: "Extra field",
-                    }
+        }
-                }
+    }
-            }
+}
-            "#,
+"#,
        )
    }
 }
diff --git a/crates/completion/src/render/macro_.rs b/crates/completion/src/render/macro_.rs
index eb3209bee..6cfbd6c9b 100644
--- a/crates/completion/src/render/macro_.rs
+++ b/crates/completion/src/render/macro_.rs
@@ -144,7 +144,7 @@ mod tests {
 use foo::<|>;
 //- /foo/lib.rs crate:foo
 #[macro_export]
-macro_rules frobnicate { () => () }
+macro_rules! frobnicate { () => () }
 "#,
            r#"
 use foo::frobnicate;
@@ -154,11 +154,11 @@ use foo::frobnicate;
        check_edit(
            "frobnicate!",
            r#"
-macro_rules frobnicate { () => () }
+macro_rules! frobnicate { () => () }
 fn main() { frob<|>!(); }
 "#,
            r#"
-macro_rules frobnicate { () => () }
+macro_rules! frobnicate { () => () }
 fn main() { frobnicate!(); }
 "#,
        );
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index fcc42c6bb..42dc35b76 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1250,6 +1250,14 @@ impl LifetimeParam {
        let params = db.generic_params(self.id.parent);
        params.lifetimes[self.id.local_id].name.clone()
    }
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        self.id.parent.module(db.upcast()).into()
+    }
+    pub fn parent(self, _db: &dyn HirDatabase) -> GenericDef {
+        self.id.parent.into()
+    }
 }
 // FIXME: rename from `ImplDef` to `Impl`
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 265ef6d1f..dd3fcfe4a 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -41,6 +41,7 @@ from_id![
    (hir_def::FunctionId, crate::Function),
    (hir_def::ImplId, crate::ImplDef),
    (hir_def::TypeParamId, crate::TypeParam),
+    (hir_def::LifetimeParamId, crate::LifetimeParam),
    (hir_expand::MacroDefId, crate::MacroDef)
 ];
@@ -154,6 +155,22 @@ impl From<GenericDef> for GenericDefId {
    }
 }
+impl From<GenericDefId> for GenericDef {
+    fn from(def: GenericDefId) -> Self {
+        match def {
+            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
+            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
+            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
+            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
+            GenericDefId::ImplId(it) => GenericDef::ImplDef(it.into()),
+            GenericDefId::EnumVariantId(it) => {
+                GenericDef::EnumVariant(EnumVariant { parent: it.parent.into(), id: it.local_id })
+            }
+            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
+        }
+    }
+}
 impl From<Adt> for GenericDefId {
    fn from(id: Adt) -> Self {
        match id {
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index c77494152..04845037f 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -10,8 +10,8 @@ use hir_expand::InFile;
 use syntax::ast;
 use crate::{
-    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef, MacroDef,
+    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef,
-    Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
+    LifetimeParam, MacroDef, Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
 };
 pub trait HasSource {
@@ -110,8 +110,8 @@ impl HasSource for TypeAlias {
    }
 }
 impl HasSource for MacroDef {
-    type Ast = ast::MacroCall;
+    type Ast = ast::MacroRules;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::MacroCall> {
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::MacroRules> {
        InFile {
            file_id: self.id.ast_id.expect("MacroDef without ast_id").file_id,
            value: self.id.ast_id.expect("MacroDef without ast_id").to_node(db.upcast()),
@@ -132,3 +132,11 @@ impl HasSource for TypeParam {
        child_source.map(|it| it[self.id.local_id].clone())
    }
 }
+impl HasSource for LifetimeParam {
+    type Ast = ast::LifetimeParam;
+    fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
+        let child_source = self.id.parent.child_source(db.upcast());
+        child_source.map(|it| it[self.id.local_id].clone())
+    }
+}
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 4bd22ed27..5959ac4ca 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -13,7 +13,11 @@ use hir_expand::{hygiene::Hygiene, name::AsName, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
-use syntax::{algo::find_node_at_offset, ast, AstNode, SyntaxNode, SyntaxToken, TextSize};
+use syntax::{
+    algo::find_node_at_offset,
+    ast::{self, GenericParamsOwner},
+    match_ast, AstNode, SyntaxNode, SyntaxToken, TextSize,
+};
 use crate::{
    code_model::Access,
@@ -21,8 +25,9 @@ use crate::{
    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, SourceAnalyzer},
-    AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef,
+    AssocItem, Callable, Crate, Field, Function, HirFileId, ImplDef, InFile, LifetimeParam, Local,
-    Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
+    MacroDef, Module, ModuleDef, Name, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
+    VariantDef,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -173,6 +178,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
    }
+    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    pub fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        self.imp.resolve_lifetime_param(lifetime_token)
+    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.imp.type_of_expr(expr)
    }
@@ -392,16 +402,44 @@ impl<'db> SemanticsImpl<'db> {
            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
    }
+    // FIXME: Replace the SyntaxToken with a typed ast Node/Token
+    fn resolve_lifetime_param(&self, lifetime_token: &SyntaxToken) -> Option<LifetimeParam> {
+        if lifetime_token.kind() != syntax::SyntaxKind::LIFETIME {
+            return None;
+        }
+        let lifetime_text = lifetime_token.text();
+        let lifetime_param = lifetime_token.parent().ancestors().find_map(|syn| {
+            let gpl = match_ast! {
+                match syn {
+                    ast::Fn(it) => it.generic_param_list()?,
+                    ast::TypeAlias(it) => it.generic_param_list()?,
+                    ast::Struct(it) => it.generic_param_list()?,
+                    ast::Enum(it) => it.generic_param_list()?,
+                    ast::Union(it) => it.generic_param_list()?,
+                    ast::Trait(it) => it.generic_param_list()?,
+                    ast::Impl(it) => it.generic_param_list()?,
+                    ast::WherePred(it) => it.generic_param_list()?,
+                    ast::ForType(it) => it.generic_param_list()?,
+                    _ => return None,
+                }
+            };
+            gpl.lifetime_params()
+                .find(|tp| tp.lifetime_token().as_ref().map(|lt| lt.text()) == Some(lifetime_text))
+        })?;
+        let src = self.find_file(lifetime_param.syntax().clone()).with_value(lifetime_param);
+        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)
+        self.analyze(expr.syntax()).type_of_expr(self.db, expr)
    }
    fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
-        self.analyze(pat.syntax()).type_of_pat(self.db, &pat)
+        self.analyze(pat.syntax()).type_of_pat(self.db, pat)
    }
    fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
-        self.analyze(param.syntax()).type_of_self(self.db, &param)
+        self.analyze(param.syntax()).type_of_self(self.db, param)
    }
    fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<FunctionId> {
@@ -684,7 +722,8 @@ to_def_impls![
    (crate::Field, ast::TupleField, tuple_field_to_def),
    (crate::EnumVariant, ast::Variant, enum_variant_to_def),
    (crate::TypeParam, ast::TypeParam, type_param_to_def),
-    (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
+    (crate::LifetimeParam, ast::LifetimeParam, lifetime_param_to_def),
+    (crate::MacroDef, ast::MacroRules, macro_rules_to_def),
    (crate::Local, ast::IdentPat, bind_pat_to_def),
 ];
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 66fc11611..a333d7aea 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -7,7 +7,8 @@ use hir_def::{
    expr::PatId,
    keys::{self, Key},
    ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId,
-    ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
+    LifetimeParamId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefKind};
 use rustc_hash::FxHashMap;
@@ -128,15 +129,30 @@ impl SourceToDefCtx<'_, '_> {
    pub(super) fn type_param_to_def(&mut self, src: InFile<ast::TypeParam>) -> Option<TypeParamId> {
        let container: ChildContainer =
-            self.find_type_param_container(src.as_ref().map(|it| it.syntax()))?.into();
+            self.find_generic_param_container(src.as_ref().map(|it| it.syntax()))?.into();
        let db = self.db;
        let dyn_map =
            &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
        dyn_map[keys::TYPE_PARAM].get(&src).copied()
    }
+    pub(super) fn lifetime_param_to_def(
+        &mut self,
+        src: InFile<ast::LifetimeParam>,
+    ) -> Option<LifetimeParamId> {
+        let container: ChildContainer =
+            self.find_generic_param_container(src.as_ref().map(|it| it.syntax()))?.into();
+        let db = self.db;
+        let dyn_map =
+            &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
+        dyn_map[keys::LIFETIME_PARAM].get(&src).copied()
+    }
    // FIXME: use DynMap as well?
-    pub(super) fn macro_call_to_def(&mut self, src: InFile<ast::MacroCall>) -> Option<MacroDefId> {
+    pub(super) fn macro_rules_to_def(
+        &mut self,
+        src: InFile<ast::MacroRules>,
+    ) -> Option<MacroDefId> {
        let kind = MacroDefKind::Declarative;
        let file_id = src.file_id.original_file(self.db.upcast());
        let krate = self.file_to_def(file_id)?.krate;
@@ -203,7 +219,7 @@ impl SourceToDefCtx<'_, '_> {
        Some(def.into())
    }
-    fn find_type_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<GenericDefId> {
+    fn find_generic_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<GenericDefId> {
        for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
            let res: GenericDefId = match_ast! {
                match (container.value) {
@@ -247,7 +263,7 @@ pub(crate) enum ChildContainer {
    VariantId(VariantId),
    TypeAliasId(TypeAliasId),
    /// XXX: this might be the same def as, for example an `EnumId`. However,
-    /// here the children generic parameters, and not, eg enum variants.
+    /// here the children are generic parameters, and not, eg enum variants.
    GenericDefId(GenericDefId),
 }
 impl_from! {
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index 6539959c3..eafa3abb6 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -145,10 +145,12 @@ impl EnumData {
    }
 }
-impl HasChildSource for EnumId {
+impl HasChildSource<LocalEnumVariantId> for EnumId {
-    type ChildId = LocalEnumVariantId;
    type Value = ast::Variant;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+    fn child_source(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalEnumVariantId, Self::Value>> {
        let src = self.lookup(db).source(db);
        let mut trace = Trace::new_for_map();
        lower_enum(db, &mut trace, &src, self.lookup(db).container.module(db));
@@ -212,11 +214,10 @@ impl VariantData {
    }
 }
-impl HasChildSource for VariantId {
+impl HasChildSource<LocalFieldId> for VariantId {
-    type ChildId = LocalFieldId;
    type Value = Either<ast::TupleField, ast::RecordField>;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<LocalFieldId, Self::Value>> {
        let (src, module_id) = match self {
            VariantId::EnumVariantId(it) => {
                // I don't really like the fact that we call into parent source
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 689a3274c..bdba4c33e 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -548,63 +548,70 @@ impl ExprCollector<'_> {
                }
            }
            ast::Expr::MacroCall(e) => {
-                if let Some(name) = e.is_macro_rules().map(|it| it.as_name()) {
+                let mut ids = vec![];
-                    let mac = MacroDefId {
+                self.collect_macro_call(e, syntax_ptr.clone(), |this, expansion| {
-                        krate: Some(self.expander.module.krate),
+                    ids.push(match expansion {
-                        ast_id: Some(self.expander.ast_id(&e)),
+                        Some(it) => this.collect_expr(it),
-                        kind: MacroDefKind::Declarative,
+                        None => this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
-                        local_inner: false,
+                    })
-                    };
+                });
-                    self.body.item_scope.define_legacy_macro(name, mac);
+                ids[0]
+            }
+        }
+    }
-                    // FIXME: do we still need to allocate this as missing ?
+    fn collect_macro_call<F: FnMut(&mut Self, Option<T>), T: ast::AstNode>(
-                    self.alloc_expr(Expr::Missing, syntax_ptr)
+        &mut self,
+        e: ast::MacroCall,
+        syntax_ptr: AstPtr<ast::Expr>,
+        mut collector: F,
+    ) {
+        // File containing the macro call. Expansion errors will be attached here.
+        let outer_file = self.expander.current_file_id;
+        let macro_call = self.expander.to_source(AstPtr::new(&e));
+        let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
+        match &res.err {
+            Some(ExpandError::UnresolvedProcMacro) => {
+                self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro(
+                    UnresolvedProcMacro {
+                        file: outer_file,
+                        node: syntax_ptr.into(),
+                        precise_location: None,
+                        macro_name: None,
+                    },
+                ));
+            }
+            Some(err) => {
+                self.source_map.diagnostics.push(BodyDiagnostic::MacroError(MacroError {
+                    file: outer_file,
+                    node: syntax_ptr.into(),
+                    message: err.to_string(),
+                }));
+            }
+            None => {}
+        }
+        match res.value {
+            Some((mark, expansion)) => {
+                // FIXME: Statements are too complicated to recover from error for now.
+                // It is because we don't have any hygenine for local variable expansion right now.
+                if T::can_cast(syntax::SyntaxKind::MACRO_STMTS) && res.err.is_some() {
+                    self.expander.exit(self.db, mark);
+                    collector(self, None);
                } else {
-                    // File containing the macro call. Expansion errors will be attached here.
+                    self.source_map.expansions.insert(macro_call, self.expander.current_file_id);
-                    let outer_file = self.expander.current_file_id;
-                    let macro_call = self.expander.to_source(AstPtr::new(&e));
-                    let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
-                    match res.err {
-                        Some(ExpandError::UnresolvedProcMacro) => {
-                            self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro(
-                                UnresolvedProcMacro {
-                                    file: outer_file,
-                                    node: syntax_ptr.clone().into(),
-                                    precise_location: None,
-                                    macro_name: None,
-                                },
-                            ));
-                        }
-                        Some(err) => {
-                            self.source_map.diagnostics.push(BodyDiagnostic::MacroError(
-                                MacroError {
-                                    file: outer_file,
-                                    node: syntax_ptr.clone().into(),
-                                    message: err.to_string(),
-                                },
-                            ));
-                        }
-                        None => {}
-                    }
-                    match res.value {
+                    let item_tree = self.db.item_tree(self.expander.current_file_id);
-                        Some((mark, expansion)) => {
+                    self.item_trees.insert(self.expander.current_file_id, item_tree);
-                            self.source_map
-                                .expansions
+                    let id = collector(self, Some(expansion));
-                                .insert(macro_call, self.expander.current_file_id);
+                    self.expander.exit(self.db, mark);
+                    id
-                            let item_tree = self.db.item_tree(self.expander.current_file_id);
-                            self.item_trees.insert(self.expander.current_file_id, item_tree);
-                            let id = self.collect_expr(expansion);
-                            self.expander.exit(self.db, mark);
-                            id
-                        }
-                        None => self.alloc_expr(Expr::Missing, syntax_ptr),
-                    }
                }
            }
+            None => collector(self, None),
        }
    }
@@ -642,44 +649,75 @@ impl ExprCollector<'_> {
        }
    }
-    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
+    fn collect_stmt(&mut self, s: ast::Stmt) -> Option<Vec<Statement>> {
-        let syntax_node_ptr = AstPtr::new(&block.clone().into());
+        let stmt =
-        self.collect_block_items(&block);
+            match s {
-        let statements = block
+                ast::Stmt::LetStmt(stmt) => {
-            .statements()
+                    self.check_cfg(&stmt)?;
-            .filter_map(|s| {
-                let stmt = match s {
-                    ast::Stmt::LetStmt(stmt) => {
-                        self.check_cfg(&stmt)?;
-                        let pat = self.collect_pat_opt(stmt.pat());
-                        let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
-                        let initializer = stmt.initializer().map(|e| self.collect_expr(e));
-                        Statement::Let { pat, type_ref, initializer }
-                    }
-                    ast::Stmt::ExprStmt(stmt) => {
-                        self.check_cfg(&stmt)?;
-                        Statement::Expr(self.collect_expr_opt(stmt.expr()))
+                    let pat = self.collect_pat_opt(stmt.pat());
-                    }
+                    let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
-                    ast::Stmt::Item(item) => {
+                    let initializer = stmt.initializer().map(|e| self.collect_expr(e));
-                        self.check_cfg(&item)?;
+                    vec![Statement::Let { pat, type_ref, initializer }]
+                }
+                ast::Stmt::ExprStmt(stmt) => {
+                    self.check_cfg(&stmt)?;
+                    // Note that macro could be expended to multiple statements
+                    if let Some(ast::Expr::MacroCall(m)) = stmt.expr() {
+                        let syntax_ptr = AstPtr::new(&stmt.expr().unwrap());
+                        let mut stmts = vec![];
+                        self.collect_macro_call(m, syntax_ptr.clone(), |this, expansion| {
+                            match expansion {
+                                Some(expansion) => {
+                                    let statements: ast::MacroStmts = expansion;
+                                    this.collect_stmts_items(statements.statements());
-                        return None;
+                                    statements.statements().for_each(|stmt| {
+                                        if let Some(mut r) = this.collect_stmt(stmt) {
+                                            stmts.append(&mut r);
+                                        }
+                                    });
+                                    if let Some(expr) = statements.expr() {
+                                        stmts.push(Statement::Expr(this.collect_expr(expr)));
+                                    }
+                                }
+                                None => {
+                                    stmts.push(Statement::Expr(
+                                        this.alloc_expr(Expr::Missing, syntax_ptr.clone()),
+                                    ));
+                                }
+                            }
+                        });
+                        stmts
+                    } else {
+                        vec![Statement::Expr(self.collect_expr_opt(stmt.expr()))]
                    }
-                };
+                }
-                Some(stmt)
+                ast::Stmt::Item(item) => {
-            })
+                    self.check_cfg(&item)?;
-            .collect();
+                    return None;
+                }
+            };
+        Some(stmt)
+    }
+    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
+        self.collect_stmts_items(block.statements());
+        let statements =
+            block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
        let tail = block.expr().map(|e| self.collect_expr(e));
        self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
    }
-    fn collect_block_items(&mut self, block: &ast::BlockExpr) {
+    fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
        let container = ContainerId::DefWithBodyId(self.def);
-        let items = block
+        let items = stmts
-            .statements()
            .filter_map(|stmt| match stmt {
                ast::Stmt::Item(it) => Some(it),
                ast::Stmt::LetStmt(_) | ast::Stmt::ExprStmt(_) => None,
@@ -733,26 +771,44 @@ impl ExprCollector<'_> {
                    | ast::Item::ExternCrate(_)
                    | ast::Item::Module(_)
                    | ast::Item::MacroCall(_) => return None,
+                    ast::Item::MacroRules(def) => {
+                        return Some(Either::Right(def));
+                    }
                };
-                Some((def, name))
+                Some(Either::Left((def, name)))
            })
            .collect::<Vec<_>>();
-        for (def, name) in items {
+        for either in items {
-            self.body.item_scope.define_def(def);
+            match either {
-            if let Some(name) = name {
+                Either::Left((def, name)) => {
-                let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
+                    self.body.item_scope.define_def(def);
-                let has_constructor = match def {
+                    if let Some(name) = name {
-                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                        let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
-                        self.db.struct_data(s).variant_data.kind() != StructKind::Record
+                        let has_constructor = match def {
+                            ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                                self.db.struct_data(s).variant_data.kind() != StructKind::Record
+                            }
+                            _ => true,
+                        };
+                        self.body.item_scope.push_res(
+                            name.as_name(),
+                            crate::per_ns::PerNs::from_def(def, vis, has_constructor),
+                        );
                    }
-                    _ => true,
+                }
-                };
+                Either::Right(e) => {
-                self.body.item_scope.push_res(
+                    let mac = MacroDefId {
-                    name.as_name(),
+                        krate: Some(self.expander.module.krate),
-                    crate::per_ns::PerNs::from_def(def, vis, has_constructor),
+                        ast_id: Some(self.expander.ast_id(&e)),
-                );
+                        kind: MacroDefKind::Declarative,
+                        local_inner: false,
+                    };
+                    if let Some(name) = e.name() {
+                        self.body.item_scope.define_legacy_macro(name.as_name(), mac);
+                    }
+                }
            }
        }
    }
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index 5189c7e9f..924046435 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -19,10 +19,10 @@ use crate::{
    db::DefDatabase,
    dyn_map::DynMap,
    keys,
-    src::HasChildSource,
+    src::{HasChildSource, HasSource},
-    src::HasSource,
    type_ref::{LifetimeRef, TypeBound, TypeRef},
-    AdtId, GenericDefId, LocalTypeParamId, Lookup, TypeParamId,
+    AdtId, GenericDefId, LifetimeParamId, LocalLifetimeParamId, LocalTypeParamId, Lookup,
+    TypeParamId,
 };
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -72,7 +72,11 @@ pub enum WherePredicateTypeTarget {
    // FIXME: ForLifetime(Vec<LifetimeParamId>, TypeRef)
 }
-type SourceMap = ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>;
+#[derive(Default)]
+pub(crate) struct SourceMap {
+    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
+    lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
+}
 impl GenericParams {
    pub(crate) fn generic_params_query(
@@ -131,7 +135,7 @@ impl GenericParams {
    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
        let mut generics = GenericParams::default();
-        let mut sm = ArenaMap::default();
+        let mut sm = SourceMap::default();
        // FIXME: add `: Sized` bound for everything except for `Self` in traits
        let file_id = match def {
@@ -174,7 +178,7 @@ impl GenericParams {
                    default: None,
                    provenance: TypeParamProvenance::TraitSelf,
                });
-                sm.insert(self_param_id, Either::Left(src.value.clone()));
+                sm.type_params.insert(self_param_id, Either::Left(src.value.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                let self_param = TypeRef::Path(name![Self].into());
@@ -250,7 +254,7 @@ impl GenericParams {
                provenance: TypeParamProvenance::TypeParamList,
            };
            let param_id = self.types.alloc(param);
-            sm.insert(param_id, Either::Right(type_param.clone()));
+            sm.type_params.insert(param_id, Either::Right(type_param.clone()));
            let type_ref = TypeRef::Path(name.into());
            self.fill_bounds(&lower_ctx, &type_param, Either::Left(type_ref));
@@ -260,7 +264,8 @@ impl GenericParams {
                .lifetime_token()
                .map_or_else(Name::missing, |tok| Name::new_lifetime(&tok));
            let param = LifetimeParamData { name: name.clone() };
-            let _param_id = self.lifetimes.alloc(param);
+            let param_id = self.lifetimes.alloc(param);
+            sm.lifetime_params.insert(param_id, lifetime_param.clone());
            let lifetime_ref = LifetimeRef::new_name(name);
            self.fill_bounds(&lower_ctx, &lifetime_param, Either::Right(lifetime_ref));
        }
@@ -341,26 +346,42 @@ impl GenericParams {
    }
 }
-impl HasChildSource for GenericDefId {
+impl HasChildSource<LocalTypeParamId> for GenericDefId {
-    type ChildId = LocalTypeParamId;
    type Value = Either<ast::Trait, ast::TypeParam>;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMap> {
+    fn child_source(
-        let (_, sm) = GenericParams::new(db, *self);
+        &self,
-        sm
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalTypeParamId, Self::Value>> {
+        GenericParams::new(db, *self).1.map(|source_maps| source_maps.type_params)
+    }
+}
+impl HasChildSource<LocalLifetimeParamId> for GenericDefId {
+    type Value = ast::LifetimeParam;
+    fn child_source(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalLifetimeParamId, Self::Value>> {
+        GenericParams::new(db, *self).1.map(|source_maps| source_maps.lifetime_params)
    }
 }
 impl ChildBySource for GenericDefId {
    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
        let mut res = DynMap::default();
-        let arena_map = self.child_source(db);
+        let (_, sm) = GenericParams::new(db, *self);
-        let arena_map = arena_map.as_ref();
-        for (local_id, src) in arena_map.value.iter() {
+        let sm = sm.as_ref();
+        for (local_id, src) in sm.value.type_params.iter() {
            let id = TypeParamId { parent: *self, local_id };
            if let Either::Right(type_param) = src {
-                res[keys::TYPE_PARAM].insert(arena_map.with_value(type_param.clone()), id)
+                res[keys::TYPE_PARAM].insert(sm.with_value(type_param.clone()), id)
            }
        }
+        for (local_id, src) in sm.value.lifetime_params.iter() {
+            let id = LifetimeParamId { parent: *self, local_id };
+            res[keys::LIFETIME_PARAM].insert(sm.with_value(src.clone()), id);
+        }
        res
    }
 }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index b08167281..1c9babf37 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -94,6 +94,9 @@ impl ItemTree {
                ast::MacroItems(items) => {
                    ctx.lower_module_items(&items)
                },
+                ast::MacroStmts(stmts) => {
+                    ctx.lower_inner_items(stmts.syntax())
+                },
                // Macros can expand to expressions. We return an empty item tree in this case, but
                // still need to collect inner items.
                ast::Expr(e) => {
@@ -139,6 +142,7 @@ impl ItemTree {
                type_aliases,
                mods,
                macro_calls,
+                macro_rules,
                exprs,
                vis,
                generics,
@@ -159,6 +163,7 @@ impl ItemTree {
            type_aliases.shrink_to_fit();
            mods.shrink_to_fit();
            macro_calls.shrink_to_fit();
+            macro_rules.shrink_to_fit();
            exprs.shrink_to_fit();
            vis.arena.shrink_to_fit();
@@ -277,6 +282,7 @@ struct ItemTreeData {
    type_aliases: Arena<TypeAlias>,
    mods: Arena<Mod>,
    macro_calls: Arena<MacroCall>,
+    macro_rules: Arena<MacroRules>,
    exprs: Arena<Expr>,
    vis: ItemVisibilities,
@@ -424,6 +430,7 @@ mod_items! {
    TypeAlias in type_aliases -> ast::TypeAlias,
    Mod in mods -> ast::Module,
    MacroCall in macro_calls -> ast::MacroCall,
+    MacroRules in macro_rules -> ast::MacroRules,
 }
 macro_rules! impl_index {
@@ -626,17 +633,22 @@ pub enum ModKind {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MacroCall {
-    /// For `macro_rules!` declarations, this is the name of the declared macro.
-    pub name: Option<Name>,
    /// Path to the called macro.
    pub path: ModPath,
+    pub ast_id: FileAstId<ast::MacroCall>,
+}
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct MacroRules {
+    /// For `macro_rules!` declarations, this is the name of the declared macro.
+    pub name: Name,
    /// Has `#[macro_export]`.
    pub is_export: bool,
    /// Has `#[macro_export(local_inner_macros)]`.
    pub is_local_inner: bool,
    /// Has `#[rustc_builtin_macro]`.
    pub is_builtin: bool,
-    pub ast_id: FileAstId<ast::MacroCall>,
+    pub ast_id: FileAstId<ast::MacroRules>,
 }
 // NB: There's no `FileAstId` for `Expr`. The only case where this would be useful is for array
@@ -667,7 +679,8 @@ impl ModItem {
            | ModItem::Static(_)
            | ModItem::Trait(_)
            | ModItem::Impl(_)
-            | ModItem::Mod(_) => None,
+            | ModItem::Mod(_)
+            | ModItem::MacroRules(_) => None,
            ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)),
            ModItem::Const(konst) => Some(AssocItem::Const(*konst)),
            ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)),
@@ -694,6 +707,7 @@ impl ModItem {
            ModItem::TypeAlias(it) => tree[it.index].ast_id().upcast(),
            ModItem::Mod(it) => tree[it.index].ast_id().upcast(),
            ModItem::MacroCall(it) => tree[it.index].ast_id().upcast(),
+            ModItem::MacroRules(it) => tree[it.index].ast_id().upcast(),
        }
    }
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index f7ce2e26d..b39d7fb7a 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -2,7 +2,6 @@
 use std::{collections::hash_map::Entry, mem, sync::Arc};
-use arena::map::ArenaMap;
 use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId};
 use smallvec::SmallVec;
 use syntax::{
@@ -85,8 +84,7 @@ impl Ctx {
            | ast::Item::Fn(_)
            | ast::Item::TypeAlias(_)
            | ast::Item::Const(_)
-            | ast::Item::Static(_)
+            | ast::Item::Static(_) => {
-            | ast::Item::MacroCall(_) => {
                // Skip this if we're already collecting inner items. We'll descend into all nodes
                // already.
                if !inner {
@@ -99,7 +97,11 @@ impl Ctx {
            ast::Item::Trait(_) | ast::Item::Impl(_) | ast::Item::ExternBlock(_) => {}
            // These don't have inner items.
-            ast::Item::Module(_) | ast::Item::ExternCrate(_) | ast::Item::Use(_) => {}
+            ast::Item::Module(_)
+            | ast::Item::ExternCrate(_)
+            | ast::Item::Use(_)
+            | ast::Item::MacroCall(_)
+            | ast::Item::MacroRules(_) => {}
        };
        let attrs = Attrs::new(item, &self.hygiene);
@@ -119,6 +121,7 @@ impl Ctx {
            )),
            ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into),
            ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+            ast::Item::MacroRules(ast) => self.lower_macro_rules(ast).map(Into::into),
            ast::Item::ExternBlock(ast) => {
                Some(ModItems(self.lower_extern_block(ast).into_iter().collect::<SmallVec<_>>()))
            }
@@ -526,9 +529,15 @@ impl Ctx {
    }
    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
-        let name = m.name().map(|it| it.as_name());
-        let attrs = Attrs::new(m, &self.hygiene);
        let path = ModPath::from_src(m.path()?, &self.hygiene)?;
+        let ast_id = self.source_ast_id_map.ast_id(m);
+        let res = MacroCall { path, ast_id };
+        Some(id(self.data().macro_calls.alloc(res)))
+    }
+    fn lower_macro_rules(&mut self, m: &ast::MacroRules) -> Option<FileItemTreeId<MacroRules>> {
+        let name = m.name().map(|it| it.as_name())?;
+        let attrs = Attrs::new(m, &self.hygiene);
        let ast_id = self.source_ast_id_map.ast_id(m);
@@ -548,8 +557,8 @@ impl Ctx {
        };
        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
-        let res = MacroCall { name, path, is_export, is_builtin, is_local_inner, ast_id };
+        let res = MacroRules { name, is_export, is_builtin, is_local_inner, ast_id };
-        Some(id(self.data().macro_calls.alloc(res)))
+        Some(id(self.data().macro_rules.alloc(res)))
    }
    fn lower_extern_block(&mut self, block: &ast::ExternBlock) -> Vec<ModItem> {
@@ -607,7 +616,7 @@ impl Ctx {
        owner: GenericsOwner<'_>,
        node: &impl ast::GenericParamsOwner,
    ) -> GenericParamsId {
-        let mut sm = &mut ArenaMap::default();
+        let mut sm = &mut Default::default();
        let mut generics = GenericParams::default();
        match owner {
            GenericsOwner::Function(func) => {
@@ -630,7 +639,7 @@ impl Ctx {
                    default: None,
                    provenance: TypeParamProvenance::TraitSelf,
                });
-                sm.insert(self_param_id, Either::Left(trait_def.clone()));
+                sm.type_params.insert(self_param_id, Either::Left(trait_def.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
                let self_param = TypeRef::Path(name![Self].into());
diff --git a/crates/hir_def/src/keys.rs b/crates/hir_def/src/keys.rs
index 40a5d92b5..9c585de2c 100644
--- a/crates/hir_def/src/keys.rs
+++ b/crates/hir_def/src/keys.rs
@@ -8,8 +8,8 @@ use syntax::{ast, AstNode, AstPtr};
 use crate::{
    dyn_map::{DynMap, Policy},
-    ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, StaticId, StructId, TraitId,
+    ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, LifetimeParamId, StaticId,
-    TypeAliasId, TypeParamId, UnionId,
+    StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 pub type Key<K, V> = crate::dyn_map::Key<InFile<K>, V, AstPtrPolicy<K, V>>;
@@ -28,6 +28,7 @@ pub const VARIANT: Key<ast::Variant, EnumVariantId> = Key::new();
 pub const TUPLE_FIELD: Key<ast::TupleField, FieldId> = Key::new();
 pub const RECORD_FIELD: Key<ast::RecordField, FieldId> = Key::new();
 pub const TYPE_PARAM: Key<ast::TypeParam, TypeParamId> = Key::new();
+pub const LIFETIME_PARAM: Key<ast::LifetimeParam, LifetimeParamId> = Key::new();
 pub const MACRO: Key<ast::MacroCall, MacroDefId> = Key::new();
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 19cd713ba..85cc342c4 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -11,7 +11,7 @@ use hir_expand::{
    ast_id_map::FileAstId,
    builtin_derive::find_builtin_derive,
    builtin_macro::find_builtin_macro,
-    name::{name, AsName, Name},
+    name::{AsName, Name},
    proc_macro::ProcMacroExpander,
    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
@@ -25,7 +25,9 @@ use crate::{
    attr::Attrs,
    db::DefDatabase,
    item_scope::{ImportType, PerNsGlobImports},
-    item_tree::{self, ItemTree, ItemTreeId, MacroCall, Mod, ModItem, ModKind, StructDefKind},
+    item_tree::{
+        self, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind, StructDefKind,
+    },
    nameres::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
        BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, ResolveMode,
@@ -972,7 +974,8 @@ impl ModCollector<'_, '_> {
                        status: PartialResolvedImport::Unresolved,
                    })
                }
-                ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
+                ModItem::MacroCall(mac) => self.collect_macro_call(&self.item_tree[mac]),
+                ModItem::MacroRules(mac) => self.collect_macro_rules(&self.item_tree[mac]),
                ModItem::Impl(imp) => {
                    let module = ModuleId {
                        krate: self.def_collector.def_map.krate,
@@ -1276,45 +1279,37 @@ impl ModCollector<'_, '_> {
        self.def_collector.resolve_proc_macro(&macro_name);
    }
-    fn collect_macro(&mut self, mac: &MacroCall) {
+    fn collect_macro_rules(&mut self, mac: &MacroRules) {
-        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
+        let ast_id = InFile::new(self.file_id, mac.ast_id);
-        // Case 0: builtin macros
+        // Case 1: builtin macros
        if mac.is_builtin {
-            if let Some(name) = &mac.name {
+            let krate = self.def_collector.def_map.krate;
-                let krate = self.def_collector.def_map.krate;
+            if let Some(macro_id) = find_builtin_macro(&mac.name, krate, ast_id) {
-                if let Some(macro_id) = find_builtin_macro(name, krate, ast_id.ast_id) {
-                    self.def_collector.define_macro(
-                        self.module_id,
-                        name.clone(),
-                        macro_id,
-                        mac.is_export,
-                    );
-                    return;
-                }
-            }
-        }
-        // Case 1: macro rules, define a macro in crate-global mutable scope
-        if is_macro_rules(&mac.path) {
-            if let Some(name) = &mac.name {
-                let macro_id = MacroDefId {
-                    ast_id: Some(ast_id.ast_id),
-                    krate: Some(self.def_collector.def_map.krate),
-                    kind: MacroDefKind::Declarative,
-                    local_inner: mac.is_local_inner,
-                };
                self.def_collector.define_macro(
                    self.module_id,
-                    name.clone(),
+                    mac.name.clone(),
                    macro_id,
                    mac.is_export,
                );
+                return;
            }
-            return;
        }
-        // Case 2: try to resolve in legacy scope and expand macro_rules
+        // Case 2: normal `macro_rules!` macro
+        let macro_id = MacroDefId {
+            ast_id: Some(ast_id),
+            krate: Some(self.def_collector.def_map.krate),
+            kind: MacroDefKind::Declarative,
+            local_inner: mac.is_local_inner,
+        };
+        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, mac.is_export);
+    }
+    fn collect_macro_call(&mut self, mac: &MacroCall) {
+        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
+        // Case 1: try to resolve in legacy scope and expand macro_rules
        if let Some(macro_call_id) =
            ast_id.as_call_id(self.def_collector.db, self.def_collector.def_map.krate, |path| {
                path.as_ident().and_then(|name| {
@@ -1332,7 +1327,7 @@ impl ModCollector<'_, '_> {
            return;
        }
-        // Case 3: resolve in module scope, expand during name resolution.
+        // Case 2: resolve in module scope, expand during name resolution.
        // We rewrite simple path `macro_name` to `self::macro_name` to force resolve in module scope only.
        if ast_id.path.is_ident() {
            ast_id.path.kind = PathKind::Super(0);
@@ -1370,10 +1365,6 @@ impl ModCollector<'_, '_> {
    }
 }
-fn is_macro_rules(path: &ModPath) -> bool {
-    path.as_ident() == Some(&name![macro_rules])
-}
 #[cfg(test)]
 mod tests {
    use crate::{db::DefDatabase, test_db::TestDB};
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index 60fa7646b..609925012 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -122,11 +122,9 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
    // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
    // We follow what it did anyway :)
    if segments.len() == 1 && kind == PathKind::Plain {
-        if let Some(macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
+        if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
-            if macro_call.is_bang() {
+            if let Some(crate_id) = hygiene.local_inner_macros() {
-                if let Some(crate_id) = hygiene.local_inner_macros() {
+                kind = PathKind::DollarCrate(crate_id);
-                    kind = PathKind::DollarCrate(crate_id);
-                }
            }
        }
    }
diff --git a/crates/hir_def/src/src.rs b/crates/hir_def/src/src.rs
index 7a79b0314..f67244b46 100644
--- a/crates/hir_def/src/src.rs
+++ b/crates/hir_def/src/src.rs
@@ -36,8 +36,7 @@ impl<N: ItemTreeNode> HasSource for ItemLoc<N> {
    }
 }
-pub trait HasChildSource {
+pub trait HasChildSource<ChildId> {
-    type ChildId;
    type Value;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>>;
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<ChildId, Self::Value>>;
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 477192a09..bd9223825 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -63,7 +63,7 @@ macro_rules! register_builtin {
 pub fn find_builtin_macro(
    ident: &name::Name,
    krate: CrateId,
-    ast_id: AstId<ast::MacroCall>,
+    ast_id: AstId<ast::MacroRules>,
 ) -> Option<MacroDefId> {
    let kind = find_by_name(ident)?;
@@ -88,12 +88,15 @@ register_builtin! {
    (column, Column) => column_expand,
    (file, File) => file_expand,
    (line, Line) => line_expand,
+    (module_path, ModulePath) => module_path_expand,
    (assert, Assert) => assert_expand,
    (stringify, Stringify) => stringify_expand,
    (format_args, FormatArgs) => format_args_expand,
    // format_args_nl only differs in that it adds a newline in the end,
    // so we use the same stub expansion for now
    (format_args_nl, FormatArgsNl) => format_args_expand,
+    (llvm_asm, LlvmAsm) => asm_expand,
+    (asm, Asm) => asm_expand,
    EAGER:
    (compile_error, CompileError) => compile_error_expand,
@@ -105,6 +108,15 @@ register_builtin! {
    (option_env, OptionEnv) => option_env_expand
 }
+fn module_path_expand(
+    _db: &dyn AstDatabase,
+    _id: LazyMacroId,
+    _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    // Just return a dummy result.
+    ExpandResult::ok(quote! { "module::path" })
+}
 fn line_expand(
    _db: &dyn AstDatabase,
    _id: LazyMacroId,
@@ -261,6 +273,19 @@ fn format_args_expand(
    ExpandResult::ok(expanded)
 }
+fn asm_expand(
+    _db: &dyn AstDatabase,
+    _id: LazyMacroId,
+    _tt: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
+    // both asm and llvm_asm don't return anything, so we can expand them to nothing,
+    // for now
+    let expanded = quote! {
+        ()
+    };
+    ExpandResult::ok(expanded)
+}
 fn unquote_str(lit: &tt::Literal) -> Option<String> {
    let lit = ast::make::tokens::literal(&lit.to_string());
    let token = ast::String::cast(lit)?;
@@ -490,12 +515,16 @@ mod tests {
    fn expand_builtin_macro(ra_fixture: &str) -> String {
        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
        let parsed = db.parse(file_id);
+        let macro_rules: Vec<_> =
+            parsed.syntax_node().descendants().filter_map(ast::MacroRules::cast).collect();
        let macro_calls: Vec<_> =
            parsed.syntax_node().descendants().filter_map(ast::MacroCall::cast).collect();
        let ast_id_map = db.ast_id_map(file_id.into());
-        let expander = find_by_name(&macro_calls[0].name().unwrap().as_name()).unwrap();
+        assert_eq!(macro_rules.len(), 1, "test must contain exactly 1 `macro_rules!`");
+        assert_eq!(macro_calls.len(), 1, "test must contain exactly 1 macro call");
+        let expander = find_by_name(&macro_rules[0].name().unwrap().as_name()).unwrap();
        let krate = CrateId(0);
        let file_id = match expander {
@@ -503,7 +532,7 @@ mod tests {
                // the first one should be a macro_rules
                let def = MacroDefId {
                    krate: Some(CrateId(0)),
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules[0]))),
                    kind: MacroDefKind::BuiltIn(expander),
                    local_inner: false,
                };
@@ -513,7 +542,7 @@ mod tests {
                    krate,
                    kind: MacroCallKind::FnLike(AstId::new(
                        file_id.into(),
-                        ast_id_map.ast_id(&macro_calls[1]),
+                        ast_id_map.ast_id(&macro_calls[0]),
                    )),
                };
@@ -524,12 +553,12 @@ mod tests {
                // the first one should be a macro_rules
                let def = MacroDefId {
                    krate: Some(krate),
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules[0]))),
                    kind: MacroDefKind::BuiltInEager(expander),
                    local_inner: false,
                };
-                let args = macro_calls[1].token_tree().unwrap();
+                let args = macro_calls[0].token_tree().unwrap();
                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
                let arg_id = db.intern_eager_expansion({
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ffb70f723..11b5b98c8 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -394,8 +394,8 @@ fn to_fragment_kind(db: &dyn AstDatabase, id: MacroCallId) -> FragmentKind {
            // FIXME: Handle Pattern
            FragmentKind::Expr
        }
-        // FIXME: Expand to statements in appropriate positions; HIR lowering needs to handle that
+        EXPR_STMT => FragmentKind::Statements,
-        EXPR_STMT | BLOCK_EXPR => FragmentKind::Expr,
+        BLOCK_EXPR => FragmentKind::Expr,
        ARG_LIST => FragmentKind::Expr,
        TRY_EXPR => FragmentKind::Expr,
        TUPLE_EXPR => FragmentKind::Expr,
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 1a9428514..ae3086a95 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -228,7 +228,7 @@ pub struct MacroDefId {
    // (which will probably require touching this code), we can instead use
    // that (and also remove the hacks for resolving built-in derives).
    pub krate: Option<CrateId>,
-    pub ast_id: Option<AstId<ast::MacroCall>>,
+    pub ast_id: Option<AstId<ast::MacroRules>>,
    pub kind: MacroDefKind,
    pub local_inner: bool,
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 583ed6142..69d8e6803 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -188,6 +188,7 @@ pub mod known {
        column,
        compile_error,
        line,
+        module_path,
        assert,
        stringify,
        concat,
@@ -198,6 +199,8 @@ pub mod known {
        format_args_nl,
        env,
        option_env,
+        llvm_asm,
+        asm,
        // Builtin derives
        Copy,
        Clone,
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 597a195d0..de97ec3c2 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -413,7 +413,6 @@ fn infer_local_macro() {
        expect![[r#"
            !0..6 '1usize': usize
            10..89 '{     ...!(); }': ()
-            16..65 'macro_...     }': {unknown}
            74..76 '_a': usize
        "#]],
    );
diff --git a/crates/hir_ty/src/tests/regression.rs b/crates/hir_ty/src/tests/regression.rs
index da8170417..307a257b1 100644
--- a/crates/hir_ty/src/tests/regression.rs
+++ b/crates/hir_ty/src/tests/regression.rs
@@ -593,6 +593,30 @@ fn issue_4465_dollar_crate_at_type() {
 }
 #[test]
+fn issue_6811() {
+    check_infer(
+        r#"
+        macro_rules! profile_function {
+            () => {
+                let _a = 1;
+                let _b = 1;
+            };
+        }
+        fn main() {
+            profile_function!();
+        }
+        "#,
+        expect![[r#"
+            !3..5 '_a': i32
+            !6..7 '1': i32
+            !11..13 '_b': i32
+            !14..15 '1': i32
+            103..131 '{     ...!(); }': ()
+        "#]],
+    );
+}
+#[test]
 fn issue_4053_diesel_where_clauses() {
    check_infer(
        r#"
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index 415795e8c..c51531391 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -150,13 +150,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                };
                Some(node)
            },
-            ast::MacroCall(it) => {
+            ast::MacroRules(it) => decl(it),
-                match it.path().and_then(|it| it.segment()).and_then(|it| it.name_ref()) {
-                    Some(path_segment) if path_segment.text() == "macro_rules"
-                    => decl(it),
-                    _ => None,
-                }
-            },
            _ => None,
        }
    }
@@ -380,7 +374,7 @@ fn very_obsolete() {}
                        label: "mc",
                        navigation_range: 284..286,
                        node_range: 271..303,
-                        kind: MACRO_CALL,
+                        kind: MACRO_RULES,
                        detail: None,
                        deprecated: false,
                    },
@@ -389,7 +383,7 @@ fn very_obsolete() {}
                        label: "mcexp",
                        navigation_range: 334..339,
                        node_range: 305..356,
-                        kind: MACRO_CALL,
+                        kind: MACRO_RULES,
                        detail: None,
                        deprecated: false,
                    },
@@ -398,7 +392,7 @@ fn very_obsolete() {}
                        label: "mcexp",
                        navigation_range: 387..392,
                        node_range: 358..409,
-                        kind: MACRO_CALL,
+                        kind: MACRO_RULES,
                        detail: None,
                        deprecated: false,
                    },
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 7395b81bd..675957fff 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -97,6 +97,9 @@ pub(crate) fn find_all_refs(
        get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
    {
        (Some(name), ReferenceKind::StructLiteral)
+    } else if let Some(name) = get_enum_def_name_for_struct_literal_search(&sema, &syntax, position)
+    {
+        (Some(name), ReferenceKind::EnumLiteral)
    } else {
        (
            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, position.offset),
@@ -198,6 +201,33 @@ fn get_struct_def_name_for_struct_literal_search(
    None
 }
+fn get_enum_def_name_for_struct_literal_search(
+    sema: &Semantics<RootDatabase>,
+    syntax: &SyntaxNode,
+    position: FilePosition,
+) -> Option<ast::Name> {
+    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
+        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+            return None;
+        }
+        if let Some(name) =
+            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, left.text_range().start())
+        {
+            return name.syntax().ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
+        }
+        if sema
+            .find_node_at_offset_with_descend::<ast::GenericParamList>(
+                &syntax,
+                left.text_range().start(),
+            )
+            .is_some()
+        {
+            return left.ancestors().find_map(ast::Enum::cast).and_then(|l| l.name());
+        }
+    }
+    None
+}
 fn try_find_self_references(
    syntax: &SyntaxNode,
    position: FilePosition,
@@ -357,6 +387,91 @@ fn main() {
    }
    #[test]
+    fn test_enum_after_space() {
+        check(
+            r#"
+enum Foo <|>{
+    A,
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A;
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..26 5..8 Other
+                FileId(0) 63..66 EnumLiteral
+            "#]],
+        );
+    }
+    #[test]
+    fn test_enum_before_space() {
+        check(
+            r#"
+enum Foo<|> {
+    A,
+    B,
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A;
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..26 5..8 Other
+                FileId(0) 50..53 Other
+                FileId(0) 63..66 EnumLiteral
+            "#]],
+        );
+    }
+    #[test]
+    fn test_enum_with_generic_type() {
+        check(
+            r#"
+enum Foo<T> <|>{
+    A(T),
+    B,
+}
+fn main() {
+    let f: Foo<i8>;
+    f = Foo::A(1);
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..32 5..8 Other
+                FileId(0) 73..76 EnumLiteral
+            "#]],
+        );
+    }
+    #[test]
+    fn test_enum_for_tuple() {
+        check(
+            r#"
+enum Foo<|>{
+    A(i8),
+    B(i8),
+}
+fn main() {
+    let f: Foo;
+    f = Foo::A(1);
+}
+"#,
+            expect![[r#"
+                Foo ENUM FileId(0) 0..33 5..8 Other
+                FileId(0) 70..73 EnumLiteral
+            "#]],
+        );
+    }
+    #[test]
    fn test_find_all_refs_for_local() {
        check(
            r#"
@@ -655,7 +770,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                m1 MACRO_CALL FileId(0) 0..46 29..31 Other
+                m1 MACRO_RULES FileId(0) 0..46 29..31 Other
                FileId(0) 63..65 StructLiteral
                FileId(0) 73..75 StructLiteral
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index f5c6eabef..990b0f7d9 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -74,6 +74,7 @@ pub(crate) fn highlight(
    let mut stack = HighlightedRangeStack::new();
    let mut current_macro_call: Option<ast::MacroCall> = None;
+    let mut current_macro_rules: Option<ast::MacroRules> = None;
    let mut format_string_highlighter = FormatStringHighlighter::default();
    let mut macro_rules_highlighter = MacroRulesHighlighter::default();
    let mut inside_attribute = false;
@@ -106,28 +107,26 @@ pub(crate) fn highlight(
                        binding_hash: None,
                    });
                }
-                if let Some(name) = mc.is_macro_rules() {
-                    macro_rules_highlighter.init();
-                    if let Some((highlight, binding_hash)) = highlight_element(
-                        &sema,
-                        &mut bindings_shadow_count,
-                        syntactic_name_ref_highlighting,
-                        name.syntax().clone().into(),
-                    ) {
-                        stack.add(HighlightedRange {
-                            range: name.syntax().text_range(),
-                            highlight,
-                            binding_hash,
-                        });
-                    }
-                }
                current_macro_call = Some(mc.clone());
                continue;
            }
            WalkEvent::Leave(Some(mc)) => {
-                assert!(current_macro_call == Some(mc));
+                assert_eq!(current_macro_call, Some(mc));
                current_macro_call = None;
                format_string_highlighter = FormatStringHighlighter::default();
+            }
+            _ => (),
+        }
+        match event.clone().map(|it| it.into_node().and_then(ast::MacroRules::cast)) {
+            WalkEvent::Enter(Some(mac)) => {
+                macro_rules_highlighter.init();
+                current_macro_rules = Some(mac);
+                continue;
+            }
+            WalkEvent::Leave(Some(mac)) => {
+                assert_eq!(current_macro_rules, Some(mac));
+                current_macro_rules = None;
                macro_rules_highlighter = MacroRulesHighlighter::default();
            }
            _ => (),
@@ -163,6 +162,12 @@ pub(crate) fn highlight(
        let range = element.text_range();
+        if current_macro_rules.is_some() {
+            if let Some(tok) = element.as_token() {
+                macro_rules_highlighter.advance(tok);
+            }
+        }
        let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
            // Inside a macro -- expand it first
            let token = match element.clone().into_token() {
@@ -173,9 +178,6 @@ pub(crate) fn highlight(
            let parent = token.parent();
            format_string_highlighter.check_for_format_string(&parent);
-            if let Some(tok) = element.as_token() {
-                macro_rules_highlighter.advance(tok);
-            }
            // We only care Name and Name_ref
            match (token.kind(), parent.kind()) {
@@ -386,10 +388,14 @@ impl HighlightedRangeStack {
        let mut res = self.stack.pop().unwrap();
        res.sort_by_key(|range| range.range.start());
        // Check that ranges are sorted and disjoint
-        assert!(res
+        for (left, right) in res.iter().zip(res.iter().skip(1)) {
-            .iter()
+            assert!(
-            .zip(res.iter().skip(1))
+                left.range.end() <= right.range.start(),
-            .all(|(left, right)| left.range.end() <= right.range.start()));
+                "left: {:#?}, right: {:#?}",
+                left,
+                right
+            );
+        }
        res
    }
 }
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 396fd46fb..920956b51 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -95,7 +95,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="comment documentation">/// ```</span>
 <span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="punctuation injected">(</span><span class="numeric_literal injected">1</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
 </span><span class="comment documentation">/// ```</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
        <span class="punctuation">$</span>expr
    <span class="punctuation">}</span>
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 d398e1ec8..c843b5085 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -35,13 +35,13 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> <span class="punctuation">{</span>
+<pre><code><span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">println</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">:</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">(</span><span class="punctuation">{</span>
        <span class="punctuation">$</span>crate<span class="punctuation">:</span><span class="punctuation">:</span>io<span class="punctuation">:</span><span class="punctuation">:</span>_print<span class="punctuation">(</span><span class="punctuation">$</span>crate<span class="punctuation">:</span><span class="punctuation">:</span>format_args_nl<span class="punctuation">!</span><span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="punctuation">}</span><span class="punctuation">)</span>
 <span class="punctuation">}</span>
-#[rustc_builtin_macro]
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">rustc_builtin_macro</span><span class="attribute attribute">]</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">format_args_nl</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">format_args_nl</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">{</span> <span class="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">,</span> <span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>args<span class="punctuation">:</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">{</span> <span class="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index a3b4f20e8..0569cf1e5 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -125,7 +125,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">let</span> <span class="variable declaration">bar</span> <span class="operator">=</span> <span class="function">foobar</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">def_fn</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">:</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
@@ -135,13 +135,13 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="punctuation">}</span>
 <span class="punctuation">}</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
        <span class="punctuation">$</span>expr
    <span class="punctuation">}</span>
 <span class="punctuation">}</span>
-<span class="macro">macro_rules!</span> <span class="macro declaration">keyword_frag</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">keyword_frag</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span>type<span class="punctuation">:</span>ty<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">(</span><span class="punctuation">$</span>type<span class="punctuation">)</span>
 <span class="punctuation">}</span>
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index 5d2cd30d1..d4a774261 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -217,7 +217,7 @@ impl NameClass {
                    let def: hir::TypeAlias = sema.to_def(&it)?;
                    Some(NameClass::Definition(Definition::ModuleDef(def.into())))
                },
-                ast::MacroCall(it) => {
+                ast::MacroRules(it) => {
                    let def = sema.to_def(&it)?;
                    Some(NameClass::Definition(Definition::Macro(def)))
                },
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index 607185ca9..3936c7390 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -32,6 +32,7 @@ pub enum ReferenceKind {
    StructLiteral,
    RecordFieldExprOrPat,
    SelfKw,
+    EnumLiteral,
    Other,
 }
@@ -284,6 +285,8 @@ impl<'a> FindUsages<'a> {
                    ReferenceKind::RecordFieldExprOrPat
                } else if is_record_lit_name_ref(&name_ref) || is_call_expr_name_ref(&name_ref) {
                    ReferenceKind::StructLiteral
+                } else if is_enum_lit_name_ref(&name_ref) {
+                    ReferenceKind::EnumLiteral
                } else {
                    ReferenceKind::Other
                };
@@ -402,3 +405,15 @@ fn is_record_field_expr_or_pat(name_ref: &ast::NameRef) -> bool {
        false
    }
 }
+fn is_enum_lit_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::PathExpr::cast)
+        .and_then(|p| p.path())
+        .and_then(|p| p.qualifier())
+        .and_then(|p| p.segment())
+        .map(|p| p.name_ref().as_ref() == Some(name_ref))
+        .unwrap_or(false)
+}
diff --git a/crates/ide_db/src/symbol_index.rs b/crates/ide_db/src/symbol_index.rs
index 654df898e..121063aea 100644
--- a/crates/ide_db/src/symbol_index.rs
+++ b/crates/ide_db/src/symbol_index.rs
@@ -404,13 +404,7 @@ fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, SyntaxNodePtr, TextRange)> {
            ast::TypeAlias(it) => decl(it),
            ast::Const(it) => decl(it),
            ast::Static(it) => decl(it),
-            ast::MacroCall(it) => {
+            ast::MacroRules(it) => decl(it),
-                if it.is_macro_rules().is_some() {
-                    decl(it)
-                } else {
-                    None
-                }
-            },
            _ => None,
        }
    }
diff --git a/crates/mbe/src/mbe_expander.rs b/crates/mbe/src/mbe_expander.rs
index 97bce0536..a80b73db4 100644
--- a/crates/mbe/src/mbe_expander.rs
+++ b/crates/mbe/src/mbe_expander.rs
@@ -163,7 +163,7 @@ mod tests {
    fn create_rules(macro_definition: &str) -> crate::MacroRules {
        let source_file = ast::SourceFile::parse(macro_definition).ok().unwrap();
        let macro_definition =
-            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+            source_file.syntax().descendants().find_map(ast::MacroRules::cast).unwrap();
        let (definition_tt, _) =
            ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index 843054fe8..dff6e98c2 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -48,7 +48,7 @@ mod rule_parsing {
        let macro_definition = format!(" macro_rules! m {{ {} }} ", arm_definition);
        let source_file = ast::SourceFile::parse(&macro_definition).ok().unwrap();
        let macro_definition =
-            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+            source_file.syntax().descendants().find_map(ast::MacroRules::cast).unwrap();
        let (definition_tt, _) =
            ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
@@ -1668,7 +1668,7 @@ impl MacroFixture {
 fn parse_macro_to_tt(ra_fixture: &str) -> tt::Subtree {
    let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
    let macro_definition =
-        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+        source_file.syntax().descendants().find_map(ast::MacroRules::cast).unwrap();
    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index ad29b82f7..8999829b4 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -232,6 +232,9 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
        T![macro] => {
            macro_def(p, m);
        }
+        IDENT if p.at_contextual_kw("macro_rules") && p.nth(1) == BANG => {
+            macro_rules(p, m);
+        }
        IDENT if p.at_contextual_kw("union") && p.nth(1) == IDENT => {
            // test union_items
            // union Foo {}
@@ -363,6 +366,34 @@ pub(crate) fn item_list(p: &mut Parser) {
    m.complete(p, ITEM_LIST);
 }
+fn macro_rules(p: &mut Parser, m: Marker) {
+    assert!(p.at_contextual_kw("macro_rules"));
+    p.bump_remap(T![macro_rules]);
+    p.expect(T![!]);
+    if p.at(IDENT) {
+        name(p);
+    }
+    // Special-case `macro_rules! try`.
+    // This is a hack until we do proper edition support
+    // test try_macro_rules
+    // macro_rules! try { () => {} }
+    if p.at(T![try]) {
+        let m = p.start();
+        p.bump_remap(IDENT);
+        m.complete(p, NAME);
+    }
+    match p.current() {
+        T!['{'] => {
+            token_tree(p);
+        }
+        _ => p.error("expected `{`"),
+    }
+    m.complete(p, MACRO_RULES);
+}
 // test macro_def
 // macro m { ($i:ident) => {} }
 // macro m($i:ident) {}
@@ -394,19 +425,6 @@ fn macro_call(p: &mut Parser) -> BlockLike {
 pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
    p.expect(T![!]);
-    if p.at(IDENT) {
-        name(p);
-    }
-    // Special-case `macro_rules! try`.
-    // This is a hack until we do proper edition support
-    // test try_macro_rules
-    // macro_rules! try { () => {} }
-    if p.at(T![try]) {
-        let m = p.start();
-        p.bump_remap(IDENT);
-        m.complete(p, NAME);
-    }
    match p.current() {
        T!['{'] => {
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs
index 8bc6688f3..5d6ec17a4 100644
--- a/crates/parser/src/syntax_kind/generated.rs
+++ b/crates/parser/src/syntax_kind/generated.rs
@@ -106,6 +106,7 @@ pub enum SyntaxKind {
    EXISTENTIAL_KW,
    UNION_KW,
    RAW_KW,
+    MACRO_RULES_KW,
    INT_NUMBER,
    FLOAT_NUMBER,
    CHAR,
@@ -135,6 +136,8 @@ pub enum SyntaxKind {
    IMPL,
    TYPE_ALIAS,
    MACRO_CALL,
+    MACRO_RULES,
+    MACRO_ARM,
    TOKEN_TREE,
    MACRO_DEF,
    PAREN_TYPE,
@@ -258,7 +261,7 @@ impl SyntaxKind {
            | IMPL_KW | IN_KW | LET_KW | LOOP_KW | MACRO_KW | MATCH_KW | MOD_KW | MOVE_KW
            | MUT_KW | PUB_KW | REF_KW | RETURN_KW | SELF_KW | STATIC_KW | STRUCT_KW | SUPER_KW
            | TRAIT_KW | TRUE_KW | TRY_KW | TYPE_KW | UNSAFE_KW | USE_KW | WHERE_KW | WHILE_KW
-            | AUTO_KW | DEFAULT_KW | EXISTENTIAL_KW | UNION_KW | RAW_KW => true,
+            | AUTO_KW | DEFAULT_KW | EXISTENTIAL_KW | UNION_KW | RAW_KW | MACRO_RULES_KW => true,
            _ => false,
        }
    }
@@ -361,4 +364,4 @@ impl SyntaxKind {
    }
 }
 #[macro_export]
-macro_rules ! T { [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [existential] => { $ crate :: SyntaxKind :: EXISTENTIAL_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [lifetime] => { $ crate :: SyntaxKind :: LIFETIME } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; }
+macro_rules ! T { [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [existential] => { $ crate :: SyntaxKind :: EXISTENTIAL_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [lifetime] => { $ crate :: SyntaxKind :: LIFETIME } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; }
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 729372968..1bfa6c3fc 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-goblin = "0.2.1"
+object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
 libloading = "0.6.0"
 memmap = "0.7"
diff --git a/crates/proc_macro_srv/src/dylib.rs b/crates/proc_macro_srv/src/dylib.rs
index f8f705da8..2afb973cc 100644
--- a/crates/proc_macro_srv/src/dylib.rs
+++ b/crates/proc_macro_srv/src/dylib.rs
@@ -1,14 +1,17 @@
 //! Handles dynamic library loading for proc macro
-use crate::{proc_macro::bridge, rustc_server::TokenStream};
+use std::{
-use std::fs::File;
+    fs::File,
-use std::path::{Path, PathBuf};
+    io,
+    path::{Path, PathBuf},
+};
-use goblin::{mach::Mach, Object};
 use libloading::Library;
 use memmap::Mmap;
+use object::Object;
 use proc_macro_api::ProcMacroKind;
-use std::io;
+use crate::{proc_macro::bridge, rustc_server::TokenStream};
 const NEW_REGISTRAR_SYMBOL: &str = "_rustc_proc_macro_decls_";
@@ -23,40 +26,26 @@ fn is_derive_registrar_symbol(symbol: &str) -> bool {
 fn find_registrar_symbol(file: &Path) -> io::Result<Option<String>> {
    let file = File::open(file)?;
    let buffer = unsafe { Mmap::map(&file)? };
-    let object = Object::parse(&buffer).map_err(invalid_data_err)?;
-    let name = match object {
+    Ok(object::File::parse(&buffer)
-        Object::Elf(elf) => {
+        .map_err(invalid_data_err)?
-            let symbols = elf.dynstrtab.to_vec().map_err(invalid_data_err)?;
+        .exports()
-            symbols.into_iter().find(|s| is_derive_registrar_symbol(s)).map(&str::to_owned)
+        .map_err(invalid_data_err)?
-        }
+        .into_iter()
-        Object::PE(pe) => pe
+        .map(|export| export.name())
-            .exports
+        .filter_map(|sym| String::from_utf8(sym.into()).ok())
-            .iter()
+        .find(|sym| is_derive_registrar_symbol(sym))
-            .flat_map(|s| s.name)
+        .map(|sym| {
-            .find(|s| is_derive_registrar_symbol(s))
+            // From MacOS docs:
-            .map(&str::to_owned),
+            // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
-        Object::Mach(Mach::Binary(binary)) => {
+            // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
-            let exports = binary.exports().map_err(invalid_data_err)?;
+            // prepended with an underscore.
-            exports
+            if cfg!(target_os = "macos") && sym.starts_with('_') {
-                .iter()
+                sym[1..].to_owned()
-                .map(|s| {
+            } else {
-                    // In macos doc:
+                sym
-                    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
+            }
-                    // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
+        }))
-                    // prepended with an underscore.
-                    if s.name.starts_with('_') {
-                        &s.name[1..]
-                    } else {
-                        &s.name
-                    }
-                })
-                .find(|s| is_derive_registrar_symbol(s))
-                .map(&str::to_owned)
-        }
-        _ => return Ok(None),
-    };
-    return Ok(name);
 }
 /// Loads dynamic library in platform dependent manner.
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 30d11b146..0ad75214f 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -128,7 +128,6 @@ pub struct MacroCall {
    pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for MacroCall {}
-impl ast::NameOwner for MacroCall {}
 impl MacroCall {
    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
@@ -273,6 +272,20 @@ impl Impl {
    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroRules {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for MacroRules {}
+impl ast::NameOwner for MacroRules {}
+impl ast::VisibilityOwner for MacroRules {}
+impl MacroRules {
+    pub fn macro_rules_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![macro_rules])
+    }
+    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Module {
    pub(crate) syntax: SyntaxNode,
 }
@@ -1318,6 +1331,7 @@ pub enum Item {
    Fn(Fn),
    Impl(Impl),
    MacroCall(MacroCall),
+    MacroRules(MacroRules),
    Module(Module),
    Static(Static),
    Struct(Struct),
@@ -1374,7 +1388,6 @@ pub enum AssocItem {
    TypeAlias(TypeAlias),
 }
 impl ast::AttrsOwner for AssocItem {}
-impl ast::NameOwner for AssocItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ExternItem {
    Fn(Fn),
@@ -1383,7 +1396,6 @@ pub enum ExternItem {
    TypeAlias(TypeAlias),
 }
 impl ast::AttrsOwner for ExternItem {}
-impl ast::NameOwner for ExternItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum GenericParam {
    ConstParam(ConstParam),
@@ -1666,6 +1678,17 @@ impl AstNode for Impl {
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for MacroRules {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for Module {
    fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE }
    fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -3060,6 +3083,9 @@ impl From<Impl> for Item {
 impl From<MacroCall> for Item {
    fn from(node: MacroCall) -> Item { Item::MacroCall(node) }
 }
+impl From<MacroRules> for Item {
+    fn from(node: MacroRules) -> Item { Item::MacroRules(node) }
+}
 impl From<Module> for Item {
    fn from(node: Module) -> Item { Item::Module(node) }
 }
@@ -3084,8 +3110,8 @@ impl From<Use> for Item {
 impl AstNode for Item {
    fn can_cast(kind: SyntaxKind) -> bool {
        match kind {
-            CONST | ENUM | EXTERN_BLOCK | EXTERN_CRATE | FN | IMPL | MACRO_CALL | MODULE
+            CONST | ENUM | EXTERN_BLOCK | EXTERN_CRATE | FN | IMPL | MACRO_CALL | MACRO_RULES
-            | STATIC | STRUCT | TRAIT | TYPE_ALIAS | UNION | USE => true,
+            | MODULE | STATIC | STRUCT | TRAIT | TYPE_ALIAS | UNION | USE => true,
            _ => false,
        }
    }
@@ -3098,6 +3124,7 @@ impl AstNode for Item {
            FN => Item::Fn(Fn { syntax }),
            IMPL => Item::Impl(Impl { syntax }),
            MACRO_CALL => Item::MacroCall(MacroCall { syntax }),
+            MACRO_RULES => Item::MacroRules(MacroRules { syntax }),
            MODULE => Item::Module(Module { syntax }),
            STATIC => Item::Static(Static { syntax }),
            STRUCT => Item::Struct(Struct { syntax }),
@@ -3118,6 +3145,7 @@ impl AstNode for Item {
            Item::Fn(it) => &it.syntax,
            Item::Impl(it) => &it.syntax,
            Item::MacroCall(it) => &it.syntax,
+            Item::MacroRules(it) => &it.syntax,
            Item::Module(it) => &it.syntax,
            Item::Static(it) => &it.syntax,
            Item::Struct(it) => &it.syntax,
@@ -3582,6 +3610,11 @@ impl std::fmt::Display for Impl {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
+impl std::fmt::Display for MacroRules {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for Module {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 820af2d20..c59a29eab 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -382,21 +382,6 @@ impl ast::Visibility {
    }
 }
-impl ast::MacroCall {
-    pub fn is_macro_rules(&self) -> Option<ast::Name> {
-        let name_ref = self.path()?.segment()?.name_ref()?;
-        if name_ref.text() == "macro_rules" {
-            self.name()
-        } else {
-            None
-        }
-    }
-    pub fn is_bang(&self) -> bool {
-        self.is_macro_rules().is_none()
-    }
-}
 impl ast::LifetimeParam {
    pub fn lifetime_bounds(&self) -> impl Iterator<Item = SyntaxToken> {
        self.syntax()
@@ -476,5 +461,5 @@ impl ast::DocCommentsOwner for ast::Static {}
 impl ast::DocCommentsOwner for ast::Const {}
 impl ast::DocCommentsOwner for ast::TypeAlias {}
 impl ast::DocCommentsOwner for ast::Impl {}
-impl ast::DocCommentsOwner for ast::MacroCall {}
+impl ast::DocCommentsOwner for ast::MacroRules {}
 impl ast::DocCommentsOwner for ast::Use {}
diff --git a/crates/syntax/src/display.rs b/crates/syntax/src/display.rs
index 8d2c7eae4..d33bde30c 100644
--- a/crates/syntax/src/display.rs
+++ b/crates/syntax/src/display.rs
@@ -76,7 +76,7 @@ pub fn type_label(node: &ast::TypeAlias) -> String {
    label.trim().to_owned()
 }
-pub fn macro_label(node: &ast::MacroCall) -> String {
+pub fn macro_label(node: &ast::MacroRules) -> String {
    let name = node.name().map(|name| name.syntax().text().to_string()).unwrap_or_default();
    let vis = if node.has_atom_attr("macro_export") { "#[macro_export]\n" } else { "" };
    format!("{}macro_rules! {}", vis, name)
diff --git a/crates/syntax/src/parsing/text_tree_sink.rs b/crates/syntax/src/parsing/text_tree_sink.rs
index 49842177a..ce27c3dd9 100644
--- a/crates/syntax/src/parsing/text_tree_sink.rs
+++ b/crates/syntax/src/parsing/text_tree_sink.rs
@@ -147,8 +147,8 @@ fn n_attached_trivias<'a>(
    trivias: impl Iterator<Item = (SyntaxKind, &'a str)>,
 ) -> usize {
    match kind {
-        MACRO_CALL | CONST | TYPE_ALIAS | STRUCT | ENUM | VARIANT | FN | TRAIT | MODULE
+        MACRO_CALL | MACRO_RULES | CONST | TYPE_ALIAS | STRUCT | ENUM | VARIANT | FN | TRAIT
-        | RECORD_FIELD | STATIC | USE => {
+        | MODULE | RECORD_FIELD | STATIC | USE => {
            let mut res = 0;
            let mut trivias = trivias.enumerate().peekable();
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 6f45149bf..2ddaeb176 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -3,7 +3,9 @@
 mod block;
 use crate::{
-    algo, ast, match_ast, AstNode, SyntaxError,
+    algo,
+    ast::{self, VisibilityOwner},
+    match_ast, AstNode, SyntaxError,
    SyntaxKind::{CONST, FN, INT_NUMBER, TYPE_ALIAS},
    SyntaxNode, SyntaxToken, TextSize, T,
 };
@@ -99,6 +101,7 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
                ast::RefType(it) => validate_trait_object_ref_ty(it, &mut errors),
                ast::PtrType(it) => validate_trait_object_ptr_ty(it, &mut errors),
                ast::FnPtrType(it) => validate_trait_object_fn_ptr_ret_ty(it, &mut errors),
+                ast::MacroRules(it) => validate_macro_rules(it, &mut errors),
                _ => (),
            }
        }
@@ -350,3 +353,12 @@ fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
    }
    None
 }
+fn validate_macro_rules(mac: ast::MacroRules, errors: &mut Vec<SyntaxError>) {
+    if let Some(vis) = mac.visibility() {
+        errors.push(SyntaxError::new(
+            "visibilities are not allowed on `macro_rules!` items",
+            vis.syntax().text_range(),
+        ));
+    }
+}
diff --git a/crates/syntax/test_data/parser/err/0002_duplicate_shebang.rast b/crates/syntax/test_data/parser/err/0002_duplicate_shebang.rast
index 4cfd1bce4..9ad5b12b8 100644
--- a/crates/syntax/test_data/parser/err/0002_duplicate_shebang.rast
+++ b/crates/syntax/test_data/parser/err/0002_duplicate_shebang.rast
@@ -17,14 +17,17 @@ [email protected]
          [email protected] "bin"
  [email protected]
    [email protected] "/"
-  MACRO_CALL@32..41
+  MACRO_CALL@32..35
    [email protected]
      [email protected]
        [email protected]
          [email protected] "env"
-    [email protected] " "
+  [email protected] " "
-    [email protected]
+  [email protected]
-      [email protected] "rusti"
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected] "rusti"
  [email protected] "\n"
 error 23..23: expected `[`
 error 23..23: expected an item
@@ -35,5 +38,8 @@ error 31..31: expected `{`, `[`, `(`
 error 31..31: expected SEMICOLON
 error 31..31: expected an item
 error 35..35: expected BANG
+error 35..35: expected `{`, `[`, `(`
+error 35..35: expected SEMICOLON
+error 41..41: expected BANG
 error 41..41: expected `{`, `[`, `(`
 error 41..41: expected SEMICOLON
diff --git a/crates/syntax/test_data/parser/inline/ok/0062_mod_contents.rast b/crates/syntax/test_data/parser/inline/ok/0062_mod_contents.rast
index de8217064..e4fb32de1 100644
--- a/crates/syntax/test_data/parser/inline/ok/0062_mod_contents.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0062_mod_contents.rast
@@ -12,11 +12,8 @@ [email protected]
      [email protected] "{"
      [email protected] "}"
  [email protected] "\n"
-  [email protected]
+  [email protected]
-    [email protected]
+    [email protected] "macro_rules"
-      [email protected]
-        [email protected]
-          [email protected] "macro_rules"
    [email protected] "!"
    [email protected] " "
    [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast b/crates/syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast
index e757249f0..e84b9164f 100644
--- a/crates/syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0096_no_semi_after_block.rast
@@ -82,32 +82,28 @@ [email protected]
          [email protected] "{"
          [email protected] "}"
      [email protected] "\n    "
-      [email protected]
+      [email protected]
-        [email protected]
+        [email protected] "macro_rules"
-          [email protected]
+        [email protected] "!"
-            [email protected]
+        [email protected] " "
-              [email protected]
+        [email protected]
-                [email protected] "macro_rules"
+          [email protected] "test"
-          [email protected] "!"
+        [email protected] " "
-          [email protected] " "
+        [email protected]
-          [email protected]
+          [email protected] "{"
-            [email protected] "test"
+          [email protected] "\n         "
-          [email protected] " "
+          [email protected]
-          [email protected]
+            [email protected] "("
-            [email protected] "{"
+            [email protected] ")"
-            [email protected] "\n         "
+          [email protected] " "
-            [email protected]
+          [email protected] "="
-              [email protected] "("
+          [email protected] ">"
-              [email protected] ")"
+          [email protected] " "
-            [email protected] " "
+          [email protected]
-            [email protected] "="
+            [email protected] "{"
-            [email protected] ">"
+            [email protected] "}"
-            [email protected] " "
+          [email protected] "\n    "
-            [email protected]
+          [email protected] "}"
-              [email protected] "{"
-              [email protected] "}"
-            [email protected] "\n    "
-            [email protected] "}"
      [email protected] "\n    "
      [email protected]
        [email protected]
diff --git a/crates/syntax/test_data/parser/inline/ok/0160_try_macro_rules.rast b/crates/syntax/test_data/parser/inline/ok/0160_try_macro_rules.rast
index 05b89d1c3..d1c22947b 100644
--- a/crates/syntax/test_data/parser/inline/ok/0160_try_macro_rules.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0160_try_macro_rules.rast
@@ -1,9 +1,6 @@
 [email protected]
-  [email protected]
+  [email protected]
-    [email protected]
+    [email protected] "macro_rules"
-      [email protected]
-        [email protected]
-          [email protected] "macro_rules"
    [email protected] "!"
    [email protected] " "
    [email protected]
diff --git a/crates/syntax/test_data/parser/ok/0053_outer_attribute_on_macro_rules.rast b/crates/syntax/test_data/parser/ok/0053_outer_attribute_on_macro_rules.rast
index be60f7a8e..87d8ebcba 100644
--- a/crates/syntax/test_data/parser/ok/0053_outer_attribute_on_macro_rules.rast
+++ b/crates/syntax/test_data/parser/ok/0053_outer_attribute_on_macro_rules.rast
@@ -1,5 +1,5 @@
 [email protected]
-  MACRO_CALL@0..64
+  MACRO_RULES@0..64
    [email protected] "/// Some docs"
    [email protected] "\n"
    [email protected]
@@ -11,10 +11,7 @@ [email protected]
            [email protected] "macro_export"
      [email protected] "]"
    [email protected] "\n"
-    [email protected]
+    [email protected] "macro_rules"
-      [email protected]
-        [email protected]
-          [email protected] "macro_rules"
    [email protected] "!"
    [email protected] " "
    [email protected]
diff --git a/docs/dev/style.md b/docs/dev/style.md
index c8d943142..13c6a2a16 100644
--- a/docs/dev/style.md
+++ b/docs/dev/style.md
@@ -96,19 +96,19 @@ When using multiline fixtures, use unindented raw string literals:
    fn inline_field_shorthand() {
        check_assist(
            inline_local_variable,
-            r"
+            r#"
 struct S { foo: i32}
 fn main() {
    let <|>foo = 92;
    S { foo }
 }
-",
+"#,
-            r"
+            r#"
 struct S { foo: i32}
 fn main() {
    S { foo: 92 }
 }
-",
+"#,
        );
    }
 ```
diff --git a/editors/code/.vscodeignore b/editors/code/.vscodeignore
index 7149ab799..5096ce4da 100644
--- a/editors/code/.vscodeignore
+++ b/editors/code/.vscodeignore
@@ -1,4 +1,5 @@
 **
+!language-configuration.json
 !out/src/main.js
 !package.json
 !package-lock.json
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
index 8ceaaf60e..72a4c10f5 100644
--- a/xtask/src/ast_src.rs
+++ b/xtask/src/ast_src.rs
@@ -70,7 +70,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
        "match", "mod", "move", "mut", "pub", "ref", "return", "self", "static", "struct", "super",
        "trait", "true", "try", "type", "unsafe", "use", "where", "while",
    ],
-    contextual_keywords: &["auto", "default", "existential", "union", "raw"],
+    contextual_keywords: &["auto", "default", "existential", "union", "raw", "macro_rules"],
    literals: &["INT_NUMBER", "FLOAT_NUMBER", "CHAR", "BYTE", "STRING", "BYTE_STRING"],
    tokens: &[
        "ERROR",
@@ -98,6 +98,8 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
        "IMPL",
        "TYPE_ALIAS",
        "MACRO_CALL",
+        "MACRO_RULES",
+        "MACRO_ARM",
        "TOKEN_TREE",
        "MACRO_DEF",
        "PAREN_TYPE",