14 files changed, 237 insertions, 121 deletions

diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index af8a11d03..b0b0d31b4 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,6 +1,6 @@
 use std::iter;
 
-use hir::AsName;
+use hir::{AsAssocItem, AsName};
 use ide_db::helpers::{import_assets::ImportCandidate, mod_path_to_ast};
 use ide_db::RootDatabase;
 use syntax::{
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 2dd8fbe67..b5f7e4200 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -178,7 +178,7 @@ pub struct CrateData {
     pub root_file_id: FileId,
     pub edition: Edition,
     /// A name used in the package's project declaration: for Cargo projects,
-    /// it's [package].name, can be different for other project types or even
+    /// its `[package].name` can be different for other project types or even
     /// absent (a dummy crate for the code snippet, for example).
     ///
     /// For purposes of analysis, crates are anonymous (only names in
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
index 47e797ac8..dc0b38a16 100644
--- a/crates/completion/src/completions/flyimport.rs
+++ b/crates/completion/src/completions/flyimport.rs
@@ -48,7 +48,7 @@
 //! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
 //! capability enabled.
 
-use hir::{ModPath, ScopeDef};
+use hir::{AsAssocItem, ModPath, ScopeDef};
 use ide_db::helpers::{
     import_assets::{ImportAssets, ImportCandidate},
     insert_use::ImportScope,
@@ -601,11 +601,12 @@ fn main() {
     }
 
     #[test]
-    fn zero_input_assoc_item_completion() {
+    fn zero_input_deprecated_assoc_item_completion() {
         check(
             r#"
 //- /lib.rs crate:dep
 pub mod test_mod {
+    #[deprecated]
     pub trait TestTrait {
         const SPECIAL_CONST: u8;
         type HumbleType;
@@ -628,7 +629,7 @@ fn main() {
 }
         "#,
             expect![[r#"
-                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self)
+                        me random_method() (dep::test_mod::TestTrait) fn random_method(&self) DEPRECATED
                 "#]],
         );
 
@@ -636,6 +637,7 @@ fn main() {
             r#"
 //- /lib.rs crate:dep
 pub mod test_mod {
+    #[deprecated]
     pub trait TestTrait {
         const SPECIAL_CONST: u8;
         type HumbleType;
@@ -657,8 +659,8 @@ fn main() {
 }
 "#,
             expect![[r#"
-                ct SPECIAL_CONST (dep::test_mod::TestTrait)
-                fn weird_function() (dep::test_mod::TestTrait) fn weird_function()
+                ct SPECIAL_CONST (dep::test_mod::TestTrait) DEPRECATED
+                fn weird_function() (dep::test_mod::TestTrait) fn weird_function() DEPRECATED
         "#]],
         );
     }
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index 4b3c9702a..4f622d28a 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -10,7 +10,9 @@ pub(crate) mod type_alias;
 
 mod builder_ext;
 
-use hir::{Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type};
+use hir::{
+    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
+};
 use ide_db::{helpers::SnippetCap, RootDatabase};
 use syntax::TextRange;
 use test_utils::mark;
@@ -87,7 +89,24 @@ impl<'a> RenderContext<'a> {
     }
 
     fn is_deprecated(&self, node: impl HasAttrs) -> bool {
-        node.attrs(self.db()).by_key("deprecated").exists()
+        let attrs = node.attrs(self.db());
+        attrs.by_key("deprecated").exists() || attrs.by_key("rustc_deprecated").exists()
+    }
+
+    fn is_deprecated_assoc_item(&self, as_assoc_item: impl AsAssocItem) -> bool {
+        let db = self.db();
+        let assoc = match as_assoc_item.as_assoc_item(db) {
+            Some(assoc) => assoc,
+            None => return false,
+        };
+
+        let is_assoc_deprecated = match assoc {
+            hir::AssocItem::Function(it) => self.is_deprecated(it),
+            hir::AssocItem::Const(it) => self.is_deprecated(it),
+            hir::AssocItem::TypeAlias(it) => self.is_deprecated(it),
+        };
+        is_assoc_deprecated
+            || assoc.containing_trait(db).map(|trait_| self.is_deprecated(trait_)).unwrap_or(false)
     }
 
     fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
@@ -206,8 +225,6 @@ impl<'a> Render<'a> {
             }
         };
 
-        let docs = self.docs(resolution);
-
         let mut item =
             CompletionItem::new(completion_kind, self.ctx.source_range(), local_name.clone());
         if let ScopeDef::Local(local) = resolution {
@@ -253,13 +270,14 @@ impl<'a> Render<'a> {
             }
         }
 
-        let item = item
-            .kind(kind)
-            .add_import(import_to_add)
-            .set_documentation(docs)
-            .set_ref_match(ref_match)
-            .build();
-        Some(item)
+        Some(
+            item.kind(kind)
+                .add_import(import_to_add)
+                .set_ref_match(ref_match)
+                .set_documentation(self.docs(resolution))
+                .set_deprecated(self.is_deprecated(resolution))
+                .build(),
+        )
     }
 
     fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -275,6 +293,16 @@ impl<'a> Render<'a> {
             _ => None,
         }
     }
+
+    fn is_deprecated(&self, resolution: &ScopeDef) -> bool {
+        match resolution {
+            ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it),
+            ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it),
+            ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it),
+            _ => false,
+        }
+    }
 }
 
 fn compute_score_from_active(
@@ -485,7 +513,7 @@ fn main() { let _: m::Spam = S$0 }
             r#"
 #[deprecated]
 fn something_deprecated() {}
-#[deprecated(since = "1.0.0")]
+#[rustc_deprecated(since = "1.0.0")]
 fn something_else_deprecated() {}
 
 fn main() { som$0 }
@@ -494,8 +522,8 @@ fn main() { som$0 }
                 [
                     CompletionItem {
                         label: "main()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "main()$0",
                         kind: Function,
                         lookup: "main",
@@ -503,8 +531,8 @@ fn main() { som$0 }
                     },
                     CompletionItem {
                         label: "something_deprecated()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "something_deprecated()$0",
                         kind: Function,
                         lookup: "something_deprecated",
@@ -513,8 +541,8 @@ fn main() { som$0 }
                     },
                     CompletionItem {
                         label: "something_else_deprecated()",
-                        source_range: 121..124,
-                        delete: 121..124,
+                        source_range: 127..130,
+                        delete: 127..130,
                         insert: "something_else_deprecated()$0",
                         kind: Function,
                         lookup: "something_else_deprecated",
diff --git a/crates/completion/src/render/const_.rs b/crates/completion/src/render/const_.rs
index ce924f309..e46452d4e 100644
--- a/crates/completion/src/render/const_.rs
+++ b/crates/completion/src/render/const_.rs
@@ -38,7 +38,10 @@ impl<'a> ConstRender<'a> {
         let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
             .kind(CompletionItemKind::Const)
             .set_documentation(self.ctx.docs(self.const_))
-            .set_deprecated(self.ctx.is_deprecated(self.const_))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.const_)
+                    || self.ctx.is_deprecated_assoc_item(self.const_),
+            )
             .detail(detail)
             .build();
 
diff --git a/crates/completion/src/render/function.rs b/crates/completion/src/render/function.rs
index f5b0ce3e3..8f4c66211 100644
--- a/crates/completion/src/render/function.rs
+++ b/crates/completion/src/render/function.rs
@@ -44,7 +44,9 @@ impl<'a> FunctionRender<'a> {
         CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), self.name.clone())
             .kind(self.kind())
             .set_documentation(self.ctx.docs(self.func))
-            .set_deprecated(self.ctx.is_deprecated(self.func))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
+            )
             .detail(self.detail())
             .add_call_parens(self.ctx.completion, self.name, params)
             .add_import(import_to_add)
diff --git a/crates/completion/src/render/type_alias.rs b/crates/completion/src/render/type_alias.rs
index 69b445b9c..29287143a 100644
--- a/crates/completion/src/render/type_alias.rs
+++ b/crates/completion/src/render/type_alias.rs
@@ -38,7 +38,10 @@ impl<'a> TypeAliasRender<'a> {
         let item = CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name)
             .kind(CompletionItemKind::TypeAlias)
             .set_documentation(self.ctx.docs(self.type_alias))
-            .set_deprecated(self.ctx.is_deprecated(self.type_alias))
+            .set_deprecated(
+                self.ctx.is_deprecated(self.type_alias)
+                    || self.ctx.is_deprecated_assoc_item(self.type_alias),
+            )
             .detail(detail)
             .build();
 
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index 3faf861b9..baff83305 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -83,6 +83,9 @@ pub(crate) fn completion_list_with_config(
                 let width = label_width.saturating_sub(monospace_width(it.label()));
                 format_to!(buf, "{:width$} {}", "", detail, width = width);
             }
+            if it.deprecated() {
+                format_to!(buf, " DEPRECATED");
+            }
             format_to!(buf, "\n");
             buf
         })
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 6f48322db..a4141e111 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -272,15 +272,6 @@ impl ModuleDef {
 
         hir_ty::diagnostics::validate_module_item(db, module.id.krate, id, sink)
     }
-
-    pub fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
-        match self {
-            ModuleDef::Function(f) => f.as_assoc_item(db),
-            ModuleDef::Const(c) => c.as_assoc_item(db),
-            ModuleDef::TypeAlias(t) => t.as_assoc_item(db),
-            _ => None,
-        }
-    }
 }
 
 impl Module {
@@ -1060,6 +1051,16 @@ impl AsAssocItem for TypeAlias {
         as_assoc_item(db, AssocItem::TypeAlias, self.id)
     }
 }
+impl AsAssocItem for ModuleDef {
+    fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
+        match self {
+            ModuleDef::Function(it) => it.as_assoc_item(db),
+            ModuleDef::Const(it) => it.as_assoc_item(db),
+            ModuleDef::TypeAlias(it) => it.as_assoc_item(db),
+            _ => None,
+        }
+    }
+}
 fn as_assoc_item<ID, DEF, CTOR, AST>(db: &dyn HirDatabase, ctor: CTOR, id: ID) -> Option<AssocItem>
 where
     ID: Lookup<Data = AssocItemLoc<AST>>,
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 2024acd94..44ebdbd35 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -182,12 +182,7 @@ fn runnable_action(
 ) -> Option<HoverAction> {
     match def {
         Definition::ModuleDef(it) => match it {
-            ModuleDef::Module(it) => match it.definition_source(sema.db).value {
-                ModuleSource::Module(it) => {
-                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
-                }
-                _ => None,
-            },
+            ModuleDef::Module(it) => runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it)),
             ModuleDef::Function(func) => {
                 let src = func.source(sema.db)?;
                 if src.file_id != file_id.into() {
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index f5ee7de86..8976f1080 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -6,7 +6,7 @@ use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
 use ide_db::{defs::Definition, RootDatabase};
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
+    ast::{self, AstNode, AttrsOwner},
     match_ast, SyntaxNode,
 };
 
@@ -95,27 +95,44 @@ impl Runnable {
 // |===
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let sema = Semantics::new(db);
-    let source_file = sema.parse(file_id);
-    source_file
-        .syntax()
-        .descendants()
-        .filter_map(|item| {
-            let runnable = match_ast! {
-                match item {
-                    ast::Fn(func) => {
-                        let def = sema.to_def(&func)?;
-                        runnable_fn(&sema, def)
-                    },
-                    ast::Module(it) => runnable_mod(&sema, it),
-                    _ => None,
-                }
-            };
-            runnable.or_else(|| match doc_owner_to_def(&sema, item)? {
-                Definition::ModuleDef(def) => module_def_doctest(&sema, def),
+    let module = match sema.to_module_def(file_id) {
+        None => return vec![],
+        Some(it) => it,
+    };
+
+    runnables_mod(&sema, module)
+}
+
+fn runnables_mod(sema: &Semantics<RootDatabase>, module: hir::Module) -> Vec<Runnable> {
+    let mut res: Vec<Runnable> = module
+        .declarations(sema.db)
+        .into_iter()
+        .filter_map(|def| {
+            let runnable = match def {
+                hir::ModuleDef::Module(it) => runnable_mod(&sema, it),
+                hir::ModuleDef::Function(it) => runnable_fn(&sema, it),
                 _ => None,
-            })
+            };
+            runnable.or_else(|| module_def_doctest(&sema, def))
         })
-        .collect()
+        .collect();
+
+    res.extend(module.impl_defs(sema.db).into_iter().flat_map(|it| it.items(sema.db)).filter_map(
+        |def| match def {
+            hir::AssocItem::Function(it) => {
+                runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
+            }
+            hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
+            hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
+        },
+    ));
+
+    res.extend(module.declarations(sema.db).into_iter().flat_map(|def| match def {
+        hir::ModuleDef::Module(it) => runnables_mod(sema, it),
+        _ => vec![],
+    }));
+
+    res
 }
 
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -150,26 +167,16 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
     Some(Runnable { nav, kind, cfg })
 }
 
-pub(crate) fn runnable_mod(
-    sema: &Semantics<RootDatabase>,
-    module: ast::Module,
-) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
+pub(crate) fn runnable_mod(sema: &Semantics<RootDatabase>, def: hir::Module) -> Option<Runnable> {
+    if !has_test_function_or_multiple_test_submodules(sema, &def) {
         return None;
     }
-    let module_def = sema.to_def(&module)?;
-
-    let path = module_def
-        .path_to_root(sema.db)
-        .into_iter()
-        .rev()
-        .filter_map(|it| it.name(sema.db))
-        .join("::");
+    let path =
+        def.path_to_root(sema.db).into_iter().rev().filter_map(|it| it.name(sema.db)).join("::");
 
-    let def = sema.to_def(&module)?;
     let attrs = def.attrs(sema.db);
     let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
+    let nav = def.to_nav(sema.db);
     Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
 }
 
@@ -289,30 +296,31 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
 
 // We could create runnables for modules with number_of_test_submodules > 0,
 // but that bloats the runnables for no real benefit, since all tests can be run by the submodule already
-fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
-    if let Some(item_list) = module.item_list() {
-        let mut number_of_test_submodules = 0;
-
-        for item in item_list.items() {
-            match item {
-                ast::Item::Fn(f) => {
-                    if test_related_attribute(&f).is_some() {
+fn has_test_function_or_multiple_test_submodules(
+    sema: &Semantics<RootDatabase>,
+    module: &hir::Module,
+) -> bool {
+    let mut number_of_test_submodules = 0;
+
+    for item in module.declarations(sema.db) {
+        match item {
+            hir::ModuleDef::Function(f) => {
+                if let Some(it) = f.source(sema.db) {
+                    if test_related_attribute(&it.value).is_some() {
                         return true;
                     }
                 }
-                ast::Item::Module(submodule) => {
-                    if has_test_function_or_multiple_test_submodules(&submodule) {
-                        number_of_test_submodules += 1;
-                    }
+            }
+            hir::ModuleDef::Module(submodule) => {
+                if has_test_function_or_multiple_test_submodules(sema, &submodule) {
+                    number_of_test_submodules += 1;
                 }
-                _ => (),
             }
+            _ => (),
         }
-
-        number_of_test_submodules > 1
-    } else {
-        false
     }
+
+    number_of_test_submodules > 1
 }
 
 #[cfg(test)]
@@ -753,6 +761,21 @@ mod root_tests {
                             file_id: FileId(
                                 0,
                             ),
+                            full_range: 202..286,
+                            focus_range: 206..220,
+                            name: "nested_tests_2",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "root_tests::nested_tests_0::nested_tests_2",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
                             full_range: 84..126,
                             focus_range: 107..121,
                             name: "nested_test_11",
@@ -793,21 +816,6 @@ mod root_tests {
                             file_id: FileId(
                                 0,
                             ),
-                            full_range: 202..286,
-                            focus_range: 206..220,
-                            name: "nested_tests_2",
-                            kind: Module,
-                        },
-                        kind: TestMod {
-                            path: "root_tests::nested_tests_0::nested_tests_2",
-                        },
-                        cfg: None,
-                    },
-                    Runnable {
-                        nav: NavigationTarget {
-                            file_id: FileId(
-                                0,
-                            ),
                             full_range: 235..276,
                             focus_range: 258..271,
                             name: "nested_test_2",
@@ -982,4 +990,64 @@ impl Foo {
             "#]],
         );
     }
+
+    #[test]
+    fn test_runnables_in_macro() {
+        check(
+            r#"
+//- /lib.rs
+$0
+macro_rules! gen {
+    () => {
+        #[test]
+        fn foo_test() {
+        }
+    }
+}
+mod tests {
+    gen!();
+}
+"#,
+            &[&TEST, &TEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 90..115,
+                            focus_range: 94..99,
+                            name: "tests",
+                            kind: Module,
+                        },
+                        kind: TestMod {
+                            path: "tests",
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 106..113,
+                            focus_range: 106..113,
+                            name: "foo_test",
+                            kind: Function,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "tests::foo_test",
+                            ),
+                            attr: TestAttr {
+                                ignore: false,
+                            },
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index 2a41d8167..51002e7b8 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -16,16 +16,18 @@ use crate::ExpandError;
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum TokenTextRange {
     Token(TextRange),
-    Delimiter(TextRange, TextRange),
+    Delimiter(TextRange),
 }
 
 impl TokenTextRange {
     pub fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
         match self {
             TokenTextRange::Token(it) => Some(it),
-            TokenTextRange::Delimiter(open, close) => match kind {
-                T!['{'] | T!['('] | T!['['] => Some(open),
-                T!['}'] | T![')'] | T![']'] => Some(close),
+            TokenTextRange::Delimiter(it) => match kind {
+                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
+                T!['}'] | T![')'] | T![']'] => {
+                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
+                }
                 _ => None,
             },
         }
@@ -114,8 +116,10 @@ impl TokenMap {
     pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
         let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
             TokenTextRange::Token(it) => *it == relative_range,
-            TokenTextRange::Delimiter(open, close) => {
-                *open == relative_range || *close == relative_range
+            TokenTextRange::Delimiter(it) => {
+                let open = TextRange::at(it.start(), 1.into());
+                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
+                open == relative_range || close == relative_range
             }
         })?;
         Some(token_id)
@@ -137,15 +141,17 @@ impl TokenMap {
         close_relative_range: TextRange,
     ) -> usize {
         let res = self.entries.len();
-        self.entries
-            .push((token_id, TokenTextRange::Delimiter(open_relative_range, close_relative_range)));
+        let cover = open_relative_range.cover(close_relative_range);
+
+        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
         res
     }
 
     fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
         let (_, token_text_range) = &mut self.entries[idx];
-        if let TokenTextRange::Delimiter(dim, _) = token_text_range {
-            *token_text_range = TokenTextRange::Delimiter(*dim, close_relative_range);
+        if let TokenTextRange::Delimiter(dim) = token_text_range {
+            let cover = dim.cover(close_relative_range);
+            *token_text_range = TokenTextRange::Delimiter(cover);
         }
     }
 
diff --git a/crates/parser/src/event.rs b/crates/parser/src/event.rs
index a7d06a815..903668892 100644
--- a/crates/parser/src/event.rs
+++ b/crates/parser/src/event.rs
@@ -38,14 +38,16 @@ pub(crate) enum Event {
     ///
     /// The events for it would look like this:
     ///
-    ///
+    /// ```text
     /// START(PATH) IDENT('foo') FINISH START(PATH) T![::] IDENT('bar') FINISH
     ///       |                          /\
     ///       |                          |
     ///       +------forward-parent------+
+    /// ```
     ///
     /// And the tree would look like this
     ///
+    /// ```text
     ///    +--PATH---------+
     ///    |   |           |
     ///    |   |           |
@@ -54,6 +56,7 @@ pub(crate) enum Event {
     ///   PATH
     ///    |
     ///   'foo'
+    /// ```
     ///
     /// See also `CompletedMarker::precede`.
     Start {
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 1ff2559bb..73b121f8a 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -134,8 +134,10 @@ impl<'a> Iterator for LinesWithEnds<'a> {
 
 /// Returns `idx` such that:
 ///
+/// ```text
 ///     ∀ x in slice[..idx]:  pred(x)
 ///  && ∀ x in slice[idx..]: !pred(x)
+/// ```
 ///
 /// https://github.com/rust-lang/rust/issues/73831
 pub fn partition_point<T, P>(slice: &[T], mut pred: P) -> usize