26 files changed, 632 insertions, 272 deletions

diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index da47187e4..4964ddc7d 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -8,7 +8,7 @@ use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use test_utils::mark;
 
 use crate::{
-    utils::{render_snippet, Cursor},
+    utils::{does_pat_match_variant, render_snippet, Cursor},
     AssistContext, AssistId, AssistKind, Assists,
 };
 
@@ -147,25 +147,6 @@ fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
     })
 }
 
-fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
-    let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
-
-    let pat_head = match pat {
-        Pat::IdentPat(bind_pat) => {
-            if let Some(p) = bind_pat.pat() {
-                first_node_text(&p)
-            } else {
-                return false;
-            }
-        }
-        pat => first_node_text(pat),
-    };
-
-    let var_head = first_node_text(var);
-
-    pat_head == var_head
-}
-
 fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
     sema.type_of_expr(&expr)?.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
         Some(Adt::Enum(e)) => Some(e),
@@ -291,6 +272,34 @@ mod tests {
     }
 
     #[test]
+    fn partial_fill_option() {
+        check_assist(
+            fill_match_arms,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn main() {
+    match None$0 {
+        None => {}
+    }
+}
+            "#,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn main() {
+    match None {
+        None => {}
+        Some(${0:_}) => {}
+    }
+}
+            "#,
+        );
+    }
+
+    #[test]
     fn partial_fill_or_pat() {
         check_assist(
             fill_match_arms,
diff --git a/crates/assists/src/handlers/replace_if_let_with_match.rs b/crates/assists/src/handlers/replace_if_let_with_match.rs
index aee3397ab..aee880625 100644
--- a/crates/assists/src/handlers/replace_if_let_with_match.rs
+++ b/crates/assists/src/handlers/replace_if_let_with_match.rs
@@ -10,7 +10,10 @@ use syntax::{
     AstNode,
 };
 
-use crate::{utils::unwrap_trivial_block, AssistContext, AssistId, AssistKind, Assists};
+use crate::{
+    utils::{does_pat_match_variant, unwrap_trivial_block},
+    AssistContext, AssistId, AssistKind, Assists,
+};
 
 // Assist: replace_if_let_with_match
 //
@@ -66,7 +69,13 @@ pub(crate) fn replace_if_let_with_match(acc: &mut Assists, ctx: &AssistContext)
                         .sema
                         .type_of_pat(&pat)
                         .and_then(|ty| TryEnum::from_ty(&ctx.sema, &ty))
-                        .map(|it| it.sad_pattern())
+                        .map(|it| {
+                            if does_pat_match_variant(&pat, &it.sad_pattern()) {
+                                it.happy_pattern()
+                            } else {
+                                it.sad_pattern()
+                            }
+                        })
                         .unwrap_or_else(|| make::wildcard_pat().into());
                     let else_expr = unwrap_trivial_block(else_block);
                     make::match_arm(vec![pattern], else_expr)
@@ -279,6 +288,36 @@ fn foo(x: Option<i32>) {
     }
 
     #[test]
+    fn special_case_inverted_option() {
+        check_assist(
+            replace_if_let_with_match,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn foo(x: Option<i32>) {
+    $0if let None = x {
+        println!("none")
+    } else {
+        println!("some")
+    }
+}
+           "#,
+            r#"
+enum Option<T> { Some(T), None }
+use Option::*;
+
+fn foo(x: Option<i32>) {
+    match x {
+        None => println!("none"),
+        Some(_) => println!("some"),
+    }
+}
+           "#,
+        );
+    }
+
+    #[test]
     fn special_case_result() {
         check_assist(
             replace_if_let_with_match,
@@ -309,6 +348,36 @@ fn foo(x: Result<i32, ()>) {
     }
 
     #[test]
+    fn special_case_inverted_result() {
+        check_assist(
+            replace_if_let_with_match,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
+
+fn foo(x: Result<i32, ()>) {
+    $0if let Err(x) = x {
+        println!("{}", x)
+    } else {
+        println!("ok")
+    }
+}
+           "#,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+use Result::*;
+
+fn foo(x: Result<i32, ()>) {
+    match x {
+        Err(x) => println!("{}", x),
+        Ok(_) => println!("ok"),
+    }
+}
+           "#,
+        );
+    }
+
+    #[test]
     fn nested_indent() {
         check_assist(
             replace_if_let_with_match,
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 44c35bafa..4e762e18b 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -248,3 +248,22 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
 pub(crate) fn next_prev() -> impl Iterator<Item = Direction> {
     [Direction::Next, Direction::Prev].iter().copied()
 }
+
+pub(crate) fn does_pat_match_variant(pat: &ast::Pat, var: &ast::Pat) -> bool {
+    let first_node_text = |pat: &ast::Pat| pat.syntax().first_child().map(|node| node.text());
+
+    let pat_head = match pat {
+        ast::Pat::IdentPat(bind_pat) => {
+            if let Some(p) = bind_pat.pat() {
+                first_node_text(&p)
+            } else {
+                return pat.syntax().text() == var.syntax().text();
+            }
+        }
+        pat => first_node_text(pat),
+    };
+
+    let var_head = first_node_text(var);
+
+    pat_head == var_head
+}
diff --git a/crates/completion/src/item.rs b/crates/completion/src/item.rs
index eeb952ec3..8ec4ac65e 100644
--- a/crates/completion/src/item.rs
+++ b/crates/completion/src/item.rs
@@ -10,7 +10,7 @@ use ide_db::{
     },
     SymbolKind,
 };
-use stdx::{assert_never, impl_from};
+use stdx::{impl_from, never};
 use syntax::{algo, TextRange};
 use text_edit::TextEdit;
 
@@ -404,7 +404,7 @@ impl Builder {
     pub(crate) fn set_detail(mut self, detail: Option<impl Into<String>>) -> Builder {
         self.detail = detail.map(Into::into);
         if let Some(detail) = &self.detail {
-            if assert_never!(detail.contains('\n'), "multiline detail:\n{}", detail) {
+            if never!(detail.contains('\n'), "multiline detail:\n{}", detail) {
                 self.detail = Some(detail.splitn(2, '\n').next().unwrap().to_string());
             }
         }
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index a87c80b8a..aef7e1f6c 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,9 @@
 use std::sync::Arc;
 
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
-use hir_expand::{db::AstDatabase, AstId, HirFileId};
+use hir_expand::{db::AstDatabase, HirFileId};
 use la_arena::ArenaMap;
-use syntax::{ast, SmolStr};
+use syntax::SmolStr;
 
 use crate::{
     adt::{EnumData, StructData},
@@ -16,9 +16,10 @@ use crate::{
     item_tree::ItemTree,
     lang_item::{LangItemTarget, LangItems},
     nameres::DefMap,
-    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId, StaticLoc, StructId,
-    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, VariantId,
+    AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId,
+    FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalEnumVariantId, LocalFieldId, StaticId,
+    StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId,
+    UnionLoc, VariantId,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
@@ -41,6 +42,8 @@ pub trait InternDatabase: SourceDatabase {
     fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
     #[salsa::interned]
     fn intern_impl(&self, loc: ImplLoc) -> ImplId;
+    #[salsa::interned]
+    fn intern_block(&self, loc: BlockLoc) -> BlockId;
 }
 
 #[salsa::query_group(DefDatabaseStorage)]
@@ -56,7 +59,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     fn crate_def_map_query(&self, krate: CrateId) -> Arc<DefMap>;
 
     #[salsa::invoke(DefMap::block_def_map_query)]
-    fn block_def_map(&self, krate: CrateId, block: AstId<ast::BlockExpr>) -> Arc<DefMap>;
+    fn block_def_map(&self, block: BlockId) -> Arc<DefMap>;
 
     #[salsa::invoke(StructData::struct_data_query)]
     fn struct_data(&self, id: StructId) -> Arc<StructData>;
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index cf09ebd3f..42b50b5b7 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -74,12 +74,16 @@ use stdx::impl_from;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
     krate: CrateId,
+    block: Option<BlockId>,
     pub local_id: LocalModuleId,
 }
 
 impl ModuleId {
     pub fn def_map(&self, db: &dyn db::DefDatabase) -> Arc<DefMap> {
-        db.crate_def_map(self.krate)
+        match self.block {
+            Some(block) => db.block_def_map(block),
+            None => db.crate_def_map(self.krate),
+        }
     }
 
     pub fn krate(&self) -> CrateId {
@@ -230,6 +234,15 @@ pub struct ImplId(salsa::InternId);
 type ImplLoc = ItemLoc<Impl>;
 impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct BlockId(salsa::InternId);
+#[derive(Debug, Hash, PartialEq, Eq, Clone)]
+pub struct BlockLoc {
+    ast_id: AstId<ast::BlockExpr>,
+    module: ModuleId,
+}
+impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct TypeParamId {
     pub parent: GenericDefId,
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 4fbbecb38..199771e9a 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -62,7 +62,7 @@ use la_arena::Arena;
 use profile::Count;
 use rustc_hash::FxHashMap;
 use stdx::format_to;
-use syntax::{ast, AstNode};
+use syntax::ast;
 
 use crate::{
     db::DefDatabase,
@@ -70,14 +70,14 @@ use crate::{
     nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
     path::ModPath,
     per_ns::PerNs,
-    AstId, LocalModuleId, ModuleDefId, ModuleId,
+    AstId, BlockId, BlockLoc, LocalModuleId, ModuleDefId, ModuleId,
 };
 
 /// Contains all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
 pub struct DefMap {
     _c: Count<Self>,
-    parent: Option<Arc<DefMap>>,
+    block: Option<BlockInfo>,
     root: LocalModuleId,
     modules: Arena<ModuleData>,
     krate: CrateId,
@@ -91,6 +91,13 @@ pub struct DefMap {
     diagnostics: Vec<DefDiagnostic>,
 }
 
+#[derive(Debug, PartialEq, Eq)]
+struct BlockInfo {
+    block: BlockId,
+    parent: Arc<DefMap>,
+    parent_module: LocalModuleId,
+}
+
 impl std::ops::Index<LocalModuleId> for DefMap {
     type Output = ModuleData;
     fn index(&self, id: LocalModuleId) -> &ModuleData {
@@ -190,15 +197,12 @@ impl DefMap {
         Arc::new(def_map)
     }
 
-    pub(crate) fn block_def_map_query(
-        db: &dyn DefDatabase,
-        krate: CrateId,
-        block: AstId<ast::BlockExpr>,
-    ) -> Arc<DefMap> {
-        let item_tree = db.item_tree(block.file_id);
-        let block_items = item_tree.inner_items_of_block(block.value);
+    pub(crate) fn block_def_map_query(db: &dyn DefDatabase, block_id: BlockId) -> Arc<DefMap> {
+        let block: BlockLoc = db.lookup_intern_block(block_id);
+        let item_tree = db.item_tree(block.ast_id.file_id);
+        let block_items = item_tree.inner_items_of_block(block.ast_id.value);
 
-        let parent = parent_def_map(db, krate, block);
+        let parent = block.module.def_map(db);
 
         if block_items.is_empty() {
             // If there are no inner items, nothing new is brought into scope, so we can just return
@@ -206,10 +210,13 @@ impl DefMap {
             return parent;
         }
 
-        let mut def_map = DefMap::empty(krate, parent.edition);
-        def_map.parent = Some(parent);
+        let block_info =
+            BlockInfo { block: block_id, parent, parent_module: block.module.local_id };
+
+        let mut def_map = DefMap::empty(block.module.krate, block_info.parent.edition);
+        def_map.block = Some(block_info);
 
-        let def_map = collector::collect_defs(db, def_map, Some(block.value));
+        let def_map = collector::collect_defs(db, def_map, Some(block.ast_id.value));
         Arc::new(def_map)
     }
 
@@ -218,7 +225,7 @@ impl DefMap {
         let root = modules.alloc(ModuleData::default());
         DefMap {
             _c: Count::new(),
-            parent: None,
+            block: None,
             krate,
             edition,
             extern_prelude: FxHashMap::default(),
@@ -266,7 +273,8 @@ impl DefMap {
     }
 
     pub fn module_id(&self, local_id: LocalModuleId) -> ModuleId {
-        ModuleId { krate: self.krate, local_id }
+        let block = self.block.as_ref().map(|b| b.block);
+        ModuleId { krate: self.krate, local_id, block }
     }
 
     pub(crate) fn resolve_path(
@@ -286,9 +294,9 @@ impl DefMap {
     pub fn dump(&self) -> String {
         let mut buf = String::new();
         let mut current_map = self;
-        while let Some(parent) = &current_map.parent {
+        while let Some(block) = &current_map.block {
             go(&mut buf, current_map, "block scope", current_map.root);
-            current_map = &**parent;
+            current_map = &*block.parent;
         }
         go(&mut buf, current_map, "crate", current_map.root);
         return buf;
@@ -342,35 +350,6 @@ impl ModuleData {
     }
 }
 
-fn parent_def_map(
-    db: &dyn DefDatabase,
-    krate: CrateId,
-    block: AstId<ast::BlockExpr>,
-) -> Arc<DefMap> {
-    // FIXME: store this info in the item tree instead of reparsing here
-    let ast_id_map = db.ast_id_map(block.file_id);
-    let block_ptr = ast_id_map.get(block.value);
-    let root = match db.parse_or_expand(block.file_id) {
-        Some(it) => it,
-        None => {
-            return Arc::new(DefMap::empty(krate, Edition::Edition2018));
-        }
-    };
-    let ast = block_ptr.to_node(&root);
-
-    for ancestor in ast.syntax().ancestors().skip(1) {
-        if let Some(block_expr) = ast::BlockExpr::cast(ancestor) {
-            let ancestor_id = ast_id_map.ast_id(&block_expr);
-            let ast_id = InFile::new(block.file_id, ancestor_id);
-            let parent_map = db.block_def_map(krate, ast_id);
-            return parent_map;
-        }
-    }
-
-    // No enclosing block scope, so the parent is the crate-level DefMap.
-    db.crate_def_map(krate)
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ModuleSource {
     SourceFile(ast::SourceFile),
diff --git a/crates/hir_def/src/nameres/path_resolution.rs b/crates/hir_def/src/nameres/path_resolution.rs
index c1eded5f2..419e465ed 100644
--- a/crates/hir_def/src/nameres/path_resolution.rs
+++ b/crates/hir_def/src/nameres/path_resolution.rs
@@ -10,8 +10,6 @@
 //!
 //! `ReachedFixedPoint` signals about this.
 
-use std::iter::successors;
-
 use base_db::Edition;
 use hir_expand::name;
 use hir_expand::name::Name;
@@ -131,8 +129,8 @@ impl DefMap {
             result.krate = result.krate.or(new.krate);
             result.segment_index = result.segment_index.min(new.segment_index);
 
-            match &current_map.parent {
-                Some(map) => current_map = map,
+            match &current_map.block {
+                Some(block) => current_map = &block.parent,
                 None => return result,
             }
         }
@@ -193,14 +191,35 @@ impl DefMap {
                 self.resolve_name_in_module(db, original_module, &segment, prefer_module)
             }
             PathKind::Super(lvl) => {
-                let m = successors(Some(original_module), |m| self.modules[*m].parent)
-                    .nth(lvl as usize);
-                if let Some(local_id) = m {
-                    PerNs::types(self.module_id(local_id).into(), Visibility::Public)
-                } else {
-                    log::debug!("super path in root module");
-                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                let mut module = original_module;
+                for i in 0..lvl {
+                    match self.modules[module].parent {
+                        Some(it) => module = it,
+                        None => match &self.block {
+                            Some(block) => {
+                                // Look up remaining path in parent `DefMap`
+                                let new_path = ModPath {
+                                    kind: PathKind::Super(lvl - i),
+                                    segments: path.segments.clone(),
+                                };
+                                log::debug!("`super` path: {} -> {} in parent map", path, new_path);
+                                return block.parent.resolve_path_fp_with_macro(
+                                    db,
+                                    mode,
+                                    block.parent_module,
+                                    &new_path,
+                                    shadow,
+                                );
+                            }
+                            None => {
+                                log::debug!("super path in root module");
+                                return ResolvePathResult::empty(ReachedFixedPoint::Yes);
+                            }
+                        },
+                    }
                 }
+
+                PerNs::types(self.module_id(module).into(), Visibility::Public)
             }
             PathKind::Abs => {
                 // 2018-style absolute path -- only extern prelude
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 73e3a4702..b36d0b59b 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -8,12 +8,12 @@ mod block;
 
 use std::sync::Arc;
 
-use base_db::{fixture::WithFixture, SourceDatabase};
+use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
 use expect_test::{expect, Expect};
-use hir_expand::db::AstDatabase;
+use syntax::AstNode;
 use test_utils::mark;
 
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB, Lookup};
 
 fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
     let db = TestDB::with_files(ra_fixture);
@@ -23,14 +23,58 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
 
 fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
     let (db, position) = TestDB::with_position(ra_fixture);
+
+    // FIXME: perhaps we should make this use body lowering tests instead?
+
     let module = db.module_for_file(position.file_id);
-    let ast_map = db.ast_id_map(position.file_id.into());
-    let ast = db.parse(position.file_id);
-    let block: ast::BlockExpr =
-        syntax::algo::find_node_at_offset(&ast.syntax_node(), position.offset).unwrap();
-    let block_id = ast_map.ast_id(&block);
+    let mut def_map = db.crate_def_map(module.krate);
+    while let Some(new_def_map) = descend_def_map_at_position(&db, position, def_map.clone()) {
+        def_map = new_def_map;
+    }
+
+    // FIXME: select the right module, not the root
+
+    def_map
+}
+
+fn descend_def_map_at_position(
+    db: &dyn DefDatabase,
+    position: FilePosition,
+    def_map: Arc<DefMap>,
+) -> Option<Arc<DefMap>> {
+    for (local_id, module_data) in def_map.modules() {
+        let mod_def = module_data.origin.definition_source(db);
+        let ast_map = db.ast_id_map(mod_def.file_id);
+        let item_tree = db.item_tree(mod_def.file_id);
+        let root = db.parse_or_expand(mod_def.file_id).unwrap();
+        for item in module_data.scope.declarations() {
+            match item {
+                ModuleDefId::FunctionId(it) => {
+                    // Technically blocks can be inside any type (due to arrays and const generics),
+                    // and also in const/static initializers. For tests we only really care about
+                    // functions though.
+
+                    let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
+
+                    if ast.syntax().text_range().contains(position.offset) {
+                        // Cursor inside function, descend into its body's DefMap.
+                        // Note that we don't handle block *expressions* inside function bodies.
+                        let ast_map = db.ast_id_map(position.file_id.into());
+                        let ast_id = ast_map.ast_id(&ast.body().unwrap());
+                        let block = BlockLoc {
+                            ast_id: InFile::new(position.file_id.into(), ast_id),
+                            module: def_map.module_id(local_id),
+                        };
+                        let block_id = db.intern_block(block);
+                        return Some(db.block_def_map(block_id));
+                    }
+                }
+                _ => continue,
+            }
+        }
+    }
 
-    db.block_def_map(module.krate, InFile::new(position.file_id.into(), block_id))
+    None
 }
 
 fn check(ra_fixture: &str, expect: Expect) {
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
index 01d6326a7..470ca593e 100644
--- a/crates/hir_def/src/nameres/tests/block.rs
+++ b/crates/hir_def/src/nameres/tests/block.rs
@@ -95,3 +95,29 @@ fn outer() {
         "#]],
     );
 }
+
+#[test]
+fn super_imports() {
+    check_at(
+        r#"
+mod module {
+    fn f() {
+        use super::Struct;
+        $0
+    }
+}
+
+struct Struct {}
+"#,
+        expect![[r#"
+            block scope
+            Struct: t
+            crate
+            Struct: t
+            module: t
+
+            crate::module
+            f: v
+        "#]],
+    );
+}
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index f178dd744..23d885218 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -435,13 +435,16 @@ impl TryToNav for hir::TypeParam {
     fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
         let src = self.source(db)?;
         let full_range = match &src.value {
-            Either::Left(it) => it.syntax().text_range(),
+            Either::Left(it) => it
+                .name()
+                .map_or_else(|| it.syntax().text_range(), |name| name.syntax().text_range()),
             Either::Right(it) => it.syntax().text_range(),
         };
         let focus_range = match &src.value {
-            Either::Left(_) => None,
-            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
-        };
+            Either::Left(it) => it.name(),
+            Either::Right(it) => it.name(),
+        }
+        .map(|it| it.syntax().text_range());
         Some(NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 3a4f4d80b..40d9487eb 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -1098,4 +1098,20 @@ fn foo<const FOO$0: usize>() -> usize {
             "#]],
         );
     }
+
+    #[test]
+    fn test_find_self_ty_in_trait_def() {
+        check(
+            r#"
+trait Foo {
+    fn f() -> Self$0;
+}
+"#,
+            expect![[r#"
+                Self TypeParam FileId(0) 6..9 6..9 Other
+
+                FileId(0) 26..30 Other
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index c25bcce50..99a558532 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -9,7 +9,7 @@ use ide_db::{
     search::FileReference,
     RootDatabase,
 };
-use stdx::assert_never;
+use stdx::never;
 use syntax::{
     ast::{self, NameOwner},
     lex_single_syntax_kind, AstNode, SyntaxKind, SyntaxNode, T,
@@ -285,7 +285,7 @@ fn rename_mod(
 }
 
 fn rename_to_self(sema: &Semantics<RootDatabase>, local: hir::Local) -> RenameResult<SourceChange> {
-    if assert_never!(local.is_self(sema.db)) {
+    if never!(local.is_self(sema.db)) {
         bail!("rename_to_self invoked on self");
     }
 
@@ -388,7 +388,7 @@ fn rename_self_to_param(
     let (file_id, self_param) = match local.source(sema.db) {
         InFile { file_id, value: Either::Right(self_param) } => (file_id, self_param),
         _ => {
-            assert_never!(true, "rename_self_to_param invoked on a non-self local");
+            never!(true, "rename_self_to_param invoked on a non-self local");
             bail!("rename_self_to_param invoked on a non-self local");
         }
     };
diff --git a/crates/ide_db/src/source_change.rs b/crates/ide_db/src/source_change.rs
index b1f87731b..f76bac151 100644
--- a/crates/ide_db/src/source_change.rs
+++ b/crates/ide_db/src/source_change.rs
@@ -10,7 +10,7 @@ use std::{
 
 use base_db::{AnchoredPathBuf, FileId};
 use rustc_hash::FxHashMap;
-use stdx::assert_never;
+use stdx::never;
 use text_edit::TextEdit;
 
 #[derive(Default, Debug, Clone)]
@@ -40,10 +40,7 @@ impl SourceChange {
     pub fn insert_source_edit(&mut self, file_id: FileId, edit: TextEdit) {
         match self.source_file_edits.entry(file_id) {
             Entry::Occupied(mut entry) => {
-                assert_never!(
-                    entry.get_mut().union(edit).is_err(),
-                    "overlapping edits for same file"
-                );
+                never!(entry.get_mut().union(edit).is_err(), "overlapping edits for same file");
             }
             Entry::Vacant(entry) => {
                 entry.insert(edit);
diff --git a/crates/ide_db/src/ty_filter.rs b/crates/ide_db/src/ty_filter.rs
index 63a945282..f8406851b 100644
--- a/crates/ide_db/src/ty_filter.rs
+++ b/crates/ide_db/src/ty_filter.rs
@@ -49,6 +49,21 @@ impl TryEnum {
         }
     }
 
+    pub fn happy_pattern(self) -> ast::Pat {
+        match self {
+            TryEnum::Result => make::tuple_struct_pat(
+                make::path_unqualified(make::path_segment(make::name_ref("Ok"))),
+                iter::once(make::wildcard_pat().into()),
+            )
+            .into(),
+            TryEnum::Option => make::tuple_struct_pat(
+                make::path_unqualified(make::path_segment(make::name_ref("Some"))),
+                iter::once(make::wildcard_pat().into()),
+            )
+            .into(),
+        }
+    }
+
     fn type_name(self) -> &'static str {
         match self {
             TryEnum::Result => "Result",
diff --git a/crates/mbe/Cargo.toml b/crates/mbe/Cargo.toml
index af80e2be3..43bc10490 100644
--- a/crates/mbe/Cargo.toml
+++ b/crates/mbe/Cargo.toml
@@ -17,6 +17,5 @@ log = "0.4.8"
 syntax = { path = "../syntax", version = "0.0.0" }
 parser = { path = "../parser", version = "0.0.0" }
 tt = { path = "../tt", version = "0.0.0" }
-
-[dev-dependencies]
 test_utils = { path = "../test_utils" }
+
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 19543d777..35cde5f10 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -14,6 +14,7 @@ mod tests;
 
 use std::fmt;
 
+use test_utils::mark;
 pub use tt::{Delimiter, DelimiterKind, Punct};
 
 use crate::{
@@ -76,6 +77,14 @@ pub struct MacroRules {
     shift: Shift,
 }
 
+/// For Macro 2.0
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct MacroDef {
+    rules: Vec<Rule>,
+    /// Highest id of the token we have in TokenMap
+    shift: Shift,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct Rule {
     lhs: MetaTemplate,
@@ -179,7 +188,7 @@ impl MacroRules {
         let mut src = TtIter::new(tt);
         let mut rules = Vec::new();
         while src.len() > 0 {
-            let rule = Rule::parse(&mut src)?;
+            let rule = Rule::parse(&mut src, true)?;
             rules.push(rule);
             if let Err(()) = src.expect_char(';') {
                 if src.len() > 0 {
@@ -200,7 +209,58 @@ impl MacroRules {
         // apply shift
         let mut tt = tt.clone();
         self.shift.shift_all(&mut tt);
-        mbe_expander::expand(self, &tt)
+        mbe_expander::expand_rules(&self.rules, &tt)
+    }
+
+    pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
+        self.shift.shift(id)
+    }
+
+    pub fn map_id_up(&self, id: tt::TokenId) -> (tt::TokenId, Origin) {
+        match self.shift.unshift(id) {
+            Some(id) => (id, Origin::Call),
+            None => (id, Origin::Def),
+        }
+    }
+}
+
+impl MacroDef {
+    pub fn parse(tt: &tt::Subtree) -> Result<MacroDef, ParseError> {
+        let mut src = TtIter::new(tt);
+        let mut rules = Vec::new();
+
+        if Some(tt::DelimiterKind::Brace) == tt.delimiter_kind() {
+            mark::hit!(parse_macro_def_rules);
+            while src.len() > 0 {
+                let rule = Rule::parse(&mut src, true)?;
+                rules.push(rule);
+                if let Err(()) = src.expect_char(';') {
+                    if src.len() > 0 {
+                        return Err(ParseError::Expected("expected `;`".to_string()));
+                    }
+                    break;
+                }
+            }
+        } else {
+            mark::hit!(parse_macro_def_simple);
+            let rule = Rule::parse(&mut src, false)?;
+            if src.len() != 0 {
+                return Err(ParseError::Expected("remain tokens in macro def".to_string()));
+            }
+            rules.push(rule);
+        }
+        for rule in rules.iter() {
+            validate(&rule.lhs)?;
+        }
+
+        Ok(MacroDef { rules, shift: Shift::new(tt) })
+    }
+
+    pub fn expand(&self, tt: &tt::Subtree) -> ExpandResult<tt::Subtree> {
+        // apply shift
+        let mut tt = tt.clone();
+        self.shift.shift_all(&mut tt);
+        mbe_expander::expand_rules(&self.rules, &tt)
     }
 
     pub fn map_id_down(&self, id: tt::TokenId) -> tt::TokenId {
@@ -216,12 +276,14 @@ impl MacroRules {
 }
 
 impl Rule {
-    fn parse(src: &mut TtIter) -> Result<Rule, ParseError> {
+    fn parse(src: &mut TtIter, expect_arrow: bool) -> Result<Rule, ParseError> {
         let lhs = src
             .expect_subtree()
             .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
-        src.expect_char('=').map_err(|()| ParseError::Expected("expected `=`".to_string()))?;
-        src.expect_char('>').map_err(|()| ParseError::Expected("expected `>`".to_string()))?;
+        if expect_arrow {
+            src.expect_char('=').map_err(|()| ParseError::Expected("expected `=`".to_string()))?;
+            src.expect_char('>').map_err(|()| ParseError::Expected("expected `>`".to_string()))?;
+        }
         let rhs = src
             .expect_subtree()
             .map_err(|()| ParseError::Expected("expected subtree".to_string()))?;
diff --git a/crates/mbe/src/mbe_expander.rs b/crates/mbe/src/mbe_expander.rs
index a80b73db4..802c8fb0f 100644
--- a/crates/mbe/src/mbe_expander.rs
+++ b/crates/mbe/src/mbe_expander.rs
@@ -10,11 +10,10 @@ use syntax::SmolStr;
 
 use crate::{ExpandError, ExpandResult};
 
-pub(crate) fn expand(rules: &crate::MacroRules, input: &tt::Subtree) -> ExpandResult<tt::Subtree> {
-    expand_rules(&rules.rules, input)
-}
-
-fn expand_rules(rules: &[crate::Rule], input: &tt::Subtree) -> ExpandResult<tt::Subtree> {
+pub(crate) fn expand_rules(
+    rules: &[crate::Rule],
+    input: &tt::Subtree,
+) -> ExpandResult<tt::Subtree> {
     let mut match_: Option<(matcher::Match, &crate::Rule)> = None;
     for rule in rules {
         let new_match = match matcher::match_(&rule.lhs, input) {
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index bd2977ebd..8d978163d 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -6,7 +6,7 @@ use syntax::{
     SyntaxKind::{ERROR, IDENT},
     SyntaxNode, WalkEvent, T,
 };
-use test_utils::assert_eq_text;
+use test_utils::{assert_eq_text, mark};
 
 use super::*;
 
@@ -675,6 +675,36 @@ fn test_match_literal() {
     .assert_expand_items("foo! ['('];", "fn foo () {}");
 }
 
+#[test]
+fn test_parse_macro_def_simple() {
+    mark::check!(parse_macro_def_simple);
+
+    parse_macro2(
+        r#"
+macro foo($id:ident) {
+    fn $id() {}
+}
+"#,
+    )
+    .assert_expand_items("foo!(bar);", "fn bar () {}");
+}
+
+#[test]
+fn test_parse_macro_def_rules() {
+    mark::check!(parse_macro_def_rules);
+
+    parse_macro2(
+        r#"
+macro foo {
+    ($id:ident) => {
+        fn $id() {}
+    }
+}
+"#,
+    )
+    .assert_expand_items("foo!(bar);", "fn bar () {}");
+}
+
 // The following tests are port from intellij-rust directly
 // https://github.com/intellij-rust/intellij-rust/blob/c4e9feee4ad46e7953b1948c112533360b6087bb/src/test/kotlin/org/rust/lang/core/macros/RsMacroExpansionTest.kt
 
@@ -1699,95 +1729,122 @@ pub(crate) struct MacroFixture {
     rules: MacroRules,
 }
 
-impl MacroFixture {
-    pub(crate) fn expand_tt(&self, invocation: &str) -> tt::Subtree {
-        self.try_expand_tt(invocation).unwrap()
-    }
-
-    fn try_expand_tt(&self, invocation: &str) -> Result<tt::Subtree, ExpandError> {
-        let source_file = ast::SourceFile::parse(invocation).tree();
-        let macro_invocation =
-            source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
-
-        let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap())
-            .ok_or_else(|| ExpandError::ConversionError)?;
+pub(crate) struct MacroFixture2 {
+    rules: MacroDef,
+}
 
-        self.rules.expand(&invocation_tt).result()
-    }
+macro_rules! impl_fixture {
+    ($name:ident) => {
+        impl $name {
+            pub(crate) fn expand_tt(&self, invocation: &str) -> tt::Subtree {
+                self.try_expand_tt(invocation).unwrap()
+            }
 
-    fn assert_expand_err(&self, invocation: &str, err: &ExpandError) {
-        assert_eq!(self.try_expand_tt(invocation).as_ref(), Err(err));
-    }
+            fn try_expand_tt(&self, invocation: &str) -> Result<tt::Subtree, ExpandError> {
+                let source_file = ast::SourceFile::parse(invocation).tree();
+                let macro_invocation =
+                    source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
 
-    fn expand_items(&self, invocation: &str) -> SyntaxNode {
-        let expanded = self.expand_tt(invocation);
-        token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap().0.syntax_node()
-    }
+                let (invocation_tt, _) = ast_to_token_tree(&macro_invocation.token_tree().unwrap())
+                    .ok_or_else(|| ExpandError::ConversionError)?;
 
-    fn expand_statements(&self, invocation: &str) -> SyntaxNode {
-        let expanded = self.expand_tt(invocation);
-        token_tree_to_syntax_node(&expanded, FragmentKind::Statements).unwrap().0.syntax_node()
-    }
+                self.rules.expand(&invocation_tt).result()
+            }
 
-    fn expand_expr(&self, invocation: &str) -> SyntaxNode {
-        let expanded = self.expand_tt(invocation);
-        token_tree_to_syntax_node(&expanded, FragmentKind::Expr).unwrap().0.syntax_node()
-    }
+            #[allow(unused)]
+            fn assert_expand_err(&self, invocation: &str, err: &ExpandError) {
+                assert_eq!(self.try_expand_tt(invocation).as_ref(), Err(err));
+            }
 
-    fn assert_expand_tt(&self, invocation: &str, expected: &str) {
-        let expansion = self.expand_tt(invocation);
-        assert_eq!(expansion.to_string(), expected);
-    }
+            #[allow(unused)]
+            fn expand_items(&self, invocation: &str) -> SyntaxNode {
+                let expanded = self.expand_tt(invocation);
+                token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap().0.syntax_node()
+            }
 
-    fn assert_expand(&self, invocation: &str, expected: &str) {
-        let expansion = self.expand_tt(invocation);
-        let actual = format!("{:?}", expansion);
-        test_utils::assert_eq_text!(&expected.trim(), &actual.trim());
-    }
+            #[allow(unused)]
+            fn expand_statements(&self, invocation: &str) -> SyntaxNode {
+                let expanded = self.expand_tt(invocation);
+                token_tree_to_syntax_node(&expanded, FragmentKind::Statements)
+                    .unwrap()
+                    .0
+                    .syntax_node()
+            }
 
-    fn assert_expand_items(&self, invocation: &str, expected: &str) -> &MacroFixture {
-        self.assert_expansion(FragmentKind::Items, invocation, expected);
-        self
-    }
+            #[allow(unused)]
+            fn expand_expr(&self, invocation: &str) -> SyntaxNode {
+                let expanded = self.expand_tt(invocation);
+                token_tree_to_syntax_node(&expanded, FragmentKind::Expr).unwrap().0.syntax_node()
+            }
 
-    fn assert_expand_statements(&self, invocation: &str, expected: &str) -> &MacroFixture {
-        self.assert_expansion(FragmentKind::Statements, invocation, expected);
-        self
-    }
+            #[allow(unused)]
+            fn assert_expand_tt(&self, invocation: &str, expected: &str) {
+                let expansion = self.expand_tt(invocation);
+                assert_eq!(expansion.to_string(), expected);
+            }
 
-    fn assert_expansion(&self, kind: FragmentKind, invocation: &str, expected: &str) {
-        let expanded = self.expand_tt(invocation);
-        assert_eq!(expanded.to_string(), expected);
-
-        let expected = expected.replace("$crate", "C_C__C");
-
-        // wrap the given text to a macro call
-        let expected = {
-            let wrapped = format!("wrap_macro!( {} )", expected);
-            let wrapped = ast::SourceFile::parse(&wrapped);
-            let wrapped =
-                wrapped.tree().syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-            let mut wrapped = ast_to_token_tree(&wrapped).unwrap().0;
-            wrapped.delimiter = None;
-            wrapped
-        };
+            #[allow(unused)]
+            fn assert_expand(&self, invocation: &str, expected: &str) {
+                let expansion = self.expand_tt(invocation);
+                let actual = format!("{:?}", expansion);
+                test_utils::assert_eq_text!(&expected.trim(), &actual.trim());
+            }
 
-        let expanded_tree = token_tree_to_syntax_node(&expanded, kind).unwrap().0.syntax_node();
-        let expanded_tree = debug_dump_ignore_spaces(&expanded_tree).trim().to_string();
+            fn assert_expand_items(&self, invocation: &str, expected: &str) -> &$name {
+                self.assert_expansion(FragmentKind::Items, invocation, expected);
+                self
+            }
 
-        let expected_tree = token_tree_to_syntax_node(&expected, kind).unwrap().0.syntax_node();
-        let expected_tree = debug_dump_ignore_spaces(&expected_tree).trim().to_string();
+            #[allow(unused)]
+            fn assert_expand_statements(&self, invocation: &str, expected: &str) -> &$name {
+                self.assert_expansion(FragmentKind::Statements, invocation, expected);
+                self
+            }
 
-        let expected_tree = expected_tree.replace("C_C__C", "$crate");
-        assert_eq!(
-            expanded_tree, expected_tree,
-            "\nleft:\n{}\nright:\n{}",
-            expanded_tree, expected_tree,
-        );
-    }
+            fn assert_expansion(&self, kind: FragmentKind, invocation: &str, expected: &str) {
+                let expanded = self.expand_tt(invocation);
+                assert_eq!(expanded.to_string(), expected);
+
+                let expected = expected.replace("$crate", "C_C__C");
+
+                // wrap the given text to a macro call
+                let expected = {
+                    let wrapped = format!("wrap_macro!( {} )", expected);
+                    let wrapped = ast::SourceFile::parse(&wrapped);
+                    let wrapped = wrapped
+                        .tree()
+                        .syntax()
+                        .descendants()
+                        .find_map(ast::TokenTree::cast)
+                        .unwrap();
+                    let mut wrapped = ast_to_token_tree(&wrapped).unwrap().0;
+                    wrapped.delimiter = None;
+                    wrapped
+                };
+
+                let expanded_tree =
+                    token_tree_to_syntax_node(&expanded, kind).unwrap().0.syntax_node();
+                let expanded_tree = debug_dump_ignore_spaces(&expanded_tree).trim().to_string();
+
+                let expected_tree =
+                    token_tree_to_syntax_node(&expected, kind).unwrap().0.syntax_node();
+                let expected_tree = debug_dump_ignore_spaces(&expected_tree).trim().to_string();
+
+                let expected_tree = expected_tree.replace("C_C__C", "$crate");
+                assert_eq!(
+                    expanded_tree, expected_tree,
+                    "\nleft:\n{}\nright:\n{}",
+                    expanded_tree, expected_tree,
+                );
+            }
+        }
+    };
 }
 
-fn parse_macro_to_tt(ra_fixture: &str) -> tt::Subtree {
+impl_fixture!(MacroFixture);
+impl_fixture!(MacroFixture2);
+
+fn parse_macro_rules_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::MacroRules::cast).unwrap();
@@ -1804,14 +1861,36 @@ fn parse_macro_to_tt(ra_fixture: &str) -> tt::Subtree {
     definition_tt
 }
 
+fn parse_macro_def_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::MacroDef::cast).unwrap();
+
+    let (definition_tt, _) = ast_to_token_tree(&macro_definition.body().unwrap()).unwrap();
+
+    let parsed =
+        parse_to_token_tree(&ra_fixture[macro_definition.body().unwrap().syntax().text_range()])
+            .unwrap()
+            .0;
+    assert_eq!(definition_tt, parsed);
+
+    definition_tt
+}
+
 pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
-    let definition_tt = parse_macro_to_tt(ra_fixture);
+    let definition_tt = parse_macro_rules_to_tt(ra_fixture);
     let rules = MacroRules::parse(&definition_tt).unwrap();
     MacroFixture { rules }
 }
 
+pub(crate) fn parse_macro2(ra_fixture: &str) -> MacroFixture2 {
+    let definition_tt = parse_macro_def_to_tt(ra_fixture);
+    let rules = MacroDef::parse(&definition_tt).unwrap();
+    MacroFixture2 { rules }
+}
+
 pub(crate) fn parse_macro_error(ra_fixture: &str) -> ParseError {
-    let definition_tt = parse_macro_to_tt(ra_fixture);
+    let definition_tt = parse_macro_rules_to_tt(ra_fixture);
 
     match MacroRules::parse(&definition_tt) {
         Ok(_) => panic!("Expect error"),
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index 1b259682d..22011cb33 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -6,6 +6,7 @@ use std::{
     path::{Component, Path, PathBuf},
 };
 
+/// Wrapper around an absolute [`PathBuf`].
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct AbsPathBuf(PathBuf);
 
@@ -58,18 +59,33 @@ impl PartialEq<AbsPath> for AbsPathBuf {
 }
 
 impl AbsPathBuf {
+    /// Wrap the given absolute path in `AbsPathBuf`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `path` is not absolute.
     pub fn assert(path: PathBuf) -> AbsPathBuf {
         AbsPathBuf::try_from(path)
             .unwrap_or_else(|path| panic!("expected absolute path, got {}", path.display()))
     }
+
+    /// Coerces to a `AbsPath` slice.
+    ///
+    /// Equivalent of [`PathBuf::as_path`] for `AbsPathBuf`.
     pub fn as_path(&self) -> &AbsPath {
         AbsPath::assert(self.0.as_path())
     }
+
+    /// Equivalent of [`PathBuf::pop`] for `AbsPathBuf`.
+    ///
+    /// Note that this won't remove the root component, so `self` will still be
+    /// absolute.
     pub fn pop(&mut self) -> bool {
         self.0.pop()
     }
 }
 
+/// Wrapper around an absolute [`Path`].
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
 #[repr(transparent)]
 pub struct AbsPath(Path);
@@ -98,28 +114,56 @@ impl<'a> TryFrom<&'a Path> for &'a AbsPath {
 }
 
 impl AbsPath {
+    /// Wrap the given absolute path in `AbsPath`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `path` is not absolute.
     pub fn assert(path: &Path) -> &AbsPath {
         assert!(path.is_absolute());
         unsafe { &*(path as *const Path as *const AbsPath) }
     }
 
+    /// Equivalent of [`Path::parent`] for `AbsPath`.
     pub fn parent(&self) -> Option<&AbsPath> {
         self.0.parent().map(AbsPath::assert)
     }
+
+    /// Equivalent of [`Path::join`] for `AbsPath`.
     pub fn join(&self, path: impl AsRef<Path>) -> AbsPathBuf {
         self.as_ref().join(path).try_into().unwrap()
     }
+
+    /// Normalize the given path:
+    /// - Removes repeated separators: `/a//b` becomes `/a/b`
+    /// - Removes occurrences of `.` and resolves `..`.
+    /// - Removes trailing slashes: `/a/b/` becomes `/a/b`.
+    ///
+    /// # Example
+    /// ```
+    /// # use paths::AbsPathBuf;
+    /// let abs_path_buf = AbsPathBuf::assert("/a/../../b/.//c//".into());
+    /// let normalized = abs_path_buf.normalize();
+    /// assert_eq!(normalized, AbsPathBuf::assert("/b/c".into()));
+    /// ```
     pub fn normalize(&self) -> AbsPathBuf {
         AbsPathBuf(normalize_path(&self.0))
     }
+
+    /// Equivalent of [`Path::to_path_buf`] for `AbsPath`.
     pub fn to_path_buf(&self) -> AbsPathBuf {
         AbsPathBuf::try_from(self.0.to_path_buf()).unwrap()
     }
+
+    /// Equivalent of [`Path::strip_prefix`] for `AbsPath`.
+    ///
+    /// Returns a relative path.
     pub fn strip_prefix(&self, base: &AbsPath) -> Option<&RelPath> {
         self.0.strip_prefix(base).ok().map(RelPath::new_unchecked)
     }
 }
 
+/// Wrapper around a relative [`PathBuf`].
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct RelPathBuf(PathBuf);
 
@@ -160,11 +204,15 @@ impl TryFrom<&str> for RelPathBuf {
 }
 
 impl RelPathBuf {
+    /// Coerces to a `RelPath` slice.
+    ///
+    /// Equivalent of [`PathBuf::as_path`] for `RelPathBuf`.
     pub fn as_path(&self) -> &RelPath {
         RelPath::new_unchecked(self.0.as_path())
     }
 }
 
+/// Wrapper around a relative [`Path`].
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
 #[repr(transparent)]
 pub struct RelPath(Path);
@@ -183,12 +231,13 @@ impl AsRef<Path> for RelPath {
 }
 
 impl RelPath {
+    /// Creates a new `RelPath` from `path`, without checking if it is relative.
     pub fn new_unchecked(path: &Path) -> &RelPath {
         unsafe { &*(path as *const Path as *const RelPath) }
     }
 }
 
-// https://github.com/rust-lang/cargo/blob/79c769c3d7b4c2cf6a93781575b7f592ef974255/src/cargo/util/paths.rs#L60-L85
+/// Taken from https://github.com/rust-lang/cargo/blob/79c769c3d7b4c2cf6a93781575b7f592ef974255/src/cargo/util/paths.rs#L60-L85
 fn normalize_path(path: &Path) -> PathBuf {
     let mut components = path.components().peekable();
     let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 268c00942..82ea76666 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -37,6 +37,7 @@ lsp-server = "0.5.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.2", default-features = false, features = ["env-filter", "registry"] }
 tracing-tree = { version = "0.1.4" }
+always-assert = "0.1"
 
 stdx = { path = "../stdx", version = "0.0.0" }
 flycheck = { path = "../flycheck", version = "0.0.0" }
@@ -72,3 +73,4 @@ tt = { path = "../tt" }
 
 [features]
 jemalloc = ["jemallocator", "profile/jemalloc"]
+force-always-assert = ["always-assert/force"]
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 1789d6a73..088b17b03 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -86,15 +86,6 @@ fn setup_logging(log_file: Option<PathBuf>, no_buffering: bool) -> Result<()> {
 
     profile::init();
 
-    if !cfg!(debug_assertions) {
-        stdx::set_assert_hook(|loc, args| {
-            if env::var("RA_PROFILE").is_ok() {
-                panic!("assertion failed at {}: {}", loc, args)
-            }
-            log::error!("assertion failed at {}: {}", loc, args)
-        });
-    }
-
     Ok(())
 }
 
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 247bfe71e..071fde64d 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -39,7 +39,7 @@ config_data! {
         /// Automatically refresh project info via `cargo metadata` on
         /// `Cargo.toml` changes.
         cargo_autoreload: bool           = "true",
-        /// Activate all available features.
+        /// Activate all available features (`--all-features`).
         cargo_allFeatures: bool          = "false",
         /// List of features to activate.
         cargo_features: Vec<String>      = "[]",
@@ -55,10 +55,10 @@ config_data! {
 
         /// Run specified `cargo check` command for diagnostics on save.
         checkOnSave_enable: bool                         = "true",
-        /// Check with all features (will be passed as `--all-features`).
+        /// Check with all features (`--all-features`).
         /// Defaults to `#rust-analyzer.cargo.allFeatures#`.
         checkOnSave_allFeatures: Option<bool>            = "null",
-        /// Check all targets and tests (will be passed as `--all-targets`).
+        /// Check all targets and tests (`--all-targets`).
         checkOnSave_allTargets: bool                     = "true",
         /// Cargo command to use for `cargo check`.
         checkOnSave_command: String                      = "\"check\"",
@@ -156,7 +156,7 @@ config_data! {
         /// `rust-project.json`, or JSON objects in `rust-project.json` format.
         linkedProjects: Vec<ManifestOrProjectJson> = "[]",
 
-        /// Number of syntax trees rust-analyzer keeps in memory.  Defaults to 128.
+        /// Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
         lruCapacity: Option<usize>                 = "null",
 
         /// Whether to show `can't find Cargo.toml` error message.
@@ -844,15 +844,32 @@ mod tests {
     fn schema_in_sync_with_package_json() {
         let s = Config::json_schema();
         let schema = format!("{:#}", s);
-        let schema = schema.trim_start_matches('{').trim_end_matches('}');
-
-        let package_json = project_dir().join("editors/code/package.json");
-        let package_json = fs::read_to_string(&package_json).unwrap();
-
-        let p = remove_ws(&package_json);
+        let mut schema = schema
+            .trim_start_matches('{')
+            .trim_end_matches('}')
+            .replace("  ", "    ")
+            .replace("\n", "\n            ")
+            .trim_start_matches('\n')
+            .trim_end()
+            .to_string();
+        schema.push_str(",\n");
+
+        let package_json_path = project_dir().join("editors/code/package.json");
+        let mut package_json = fs::read_to_string(&package_json_path).unwrap();
+
+        let start_marker = "                \"$generated-start\": false,\n";
+        let end_marker = "                \"$generated-end\": false\n";
+
+        let start = package_json.find(start_marker).unwrap() + start_marker.len();
+        let end = package_json.find(end_marker).unwrap();
+        let p = remove_ws(&package_json[start..end]);
         let s = remove_ws(&schema);
 
-        assert!(p.contains(&s), "update config in package.json. New config:\n{:#}", schema);
+        if !p.contains(&s) {
+            package_json.replace_range(start..end, &schema);
+            fs::write(&package_json_path, &mut package_json).unwrap();
+            panic!("new config, updating package.json")
+        }
     }
 
     #[test]
diff --git a/crates/stdx/Cargo.toml b/crates/stdx/Cargo.toml
index c47e8d0a8..5866c0a28 100644
--- a/crates/stdx/Cargo.toml
+++ b/crates/stdx/Cargo.toml
@@ -11,6 +11,7 @@ doctest = false
 
 [dependencies]
 backtrace = { version = "0.3.44", optional = true }
+always-assert = { version = "0.1.1", features = ["log"] }
 # Think twice before adding anything here
 
 [features]
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index d42817078..d26be4853 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -4,7 +4,7 @@ use std::{cmp::Ordering, ops, process, time::Instant};
 mod macros;
 pub mod panic_context;
 
-pub use crate::macros::{on_assert_failure, set_assert_hook};
+pub use always_assert::{always, never};
 
 #[inline(always)]
 pub fn is_ci() -> bool {
diff --git a/crates/stdx/src/macros.rs b/crates/stdx/src/macros.rs
index 4f5c6100d..d91fc690c 100644
--- a/crates/stdx/src/macros.rs
+++ b/crates/stdx/src/macros.rs
@@ -1,9 +1,5 @@
 //! Convenience macros.
 
-use std::{
-    fmt, mem, panic,
-    sync::atomic::{AtomicUsize, Ordering::SeqCst},
-};
 #[macro_export]
 macro_rules! eprintln {
     ($($tt:tt)*) => {{
@@ -49,50 +45,3 @@ macro_rules! impl_from {
         )*
     }
 }
-
-/// A version of `assert!` macro which allows to handle an assertion failure.
-///
-/// In release mode, it returns the condition and logs an error.
-///
-/// ```
-/// if assert_never!(impossible) {
-///     // Heh, this shouldn't have happened, but lets try to soldier on...
-///     return None;
-/// }
-/// ```
-///
-/// Rust analyzer is a long-running process, and crashing really isn't an option.
-///
-/// Shamelessly stolen from: https://www.sqlite.org/assert.html
-#[macro_export]
-macro_rules! assert_never {
-    ($cond:expr) => { $crate::assert_never!($cond, "") };
-    ($cond:expr, $($fmt:tt)*) => {{
-        let value = $cond;
-        if value {
-            $crate::on_assert_failure(
-                format_args!($($fmt)*)
-            );
-        }
-        value
-    }};
-}
-
-type AssertHook = fn(&panic::Location<'_>, fmt::Arguments<'_>);
-static HOOK: AtomicUsize = AtomicUsize::new(0);
-
-pub fn set_assert_hook(hook: AssertHook) {
-    HOOK.store(hook as usize, SeqCst);
-}
-
-#[cold]
-#[track_caller]
-pub fn on_assert_failure(args: fmt::Arguments) {
-    let hook: usize = HOOK.load(SeqCst);
-    if hook == 0 {
-        panic!("\n  assertion failed: {}\n", args);
-    }
-
-    let hook: AssertHook = unsafe { mem::transmute::<usize, AssertHook>(hook) };
-    hook(panic::Location::caller(), args)
-}