4 files changed, 50 insertions, 44 deletions

diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index c34708324..e331f8886 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -17,7 +17,7 @@ use crate::{
     doc_links::{remove_links, rewrite_links},
     markdown_remove::remove_markdown,
     markup::Markup,
-    runnables::{runnable, runnable_fn},
+    runnables::{runnable_fn, runnable_mod},
     FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
 
@@ -192,7 +192,7 @@ fn runnable_action(
         Definition::ModuleDef(it) => match it {
             ModuleDef::Module(it) => match it.definition_source(sema.db).value {
                 ModuleSource::Module(it) => {
-                    runnable(&sema, it.syntax().clone()).map(|it| HoverAction::Runnable(it))
+                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
                 }
                 _ => None,
             },
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 557563d7e..3a1e204db 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -96,21 +96,23 @@ 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(|i| runnable(&sema, i)).collect()
-}
-
-pub(crate) fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
-    let runnable_item = match_ast! {
-        match (item.clone()) {
-            ast::Fn(func) => {
-                let def = sema.to_def(&func)?;
-                runnable_fn(sema, def)
-            },
-            ast::Module(it) => runnable_mod(sema, it),
-            _ => None,
-        }
-    };
-    runnable_item.or_else(|| runnable_doctest(sema, item))
+    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(|| runnable_doctest(&sema, item))
+        })
+        .collect()
 }
 
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -145,6 +147,29 @@ 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) {
+        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 def = sema.to_def(&module)?;
+    let attrs = def.attrs(sema.db);
+    let cfg = attrs.cfg();
+    let nav = module_def.to_nav(sema.db);
+    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
+}
+
 fn runnable_doctest(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
     match_ast! {
         match item {
@@ -253,26 +278,6 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
     })
 }
 
-fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
-        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 def = sema.to_def(&module)?;
-    let attrs = def.attrs(sema.db);
-    let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
-    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
-}
-
 // 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 {
diff --git a/crates/ide/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs
index 11c11ed28..c6f0417ec 100644
--- a/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -51,18 +51,20 @@ impl Node {
             }
         }
 
-        let (start, len) =
+        let overlapping =
             equal_range_by(&self.nested, |n| ordering(n.hl_range.range, hl_range.range));
 
-        if len == 1 && self.nested[start].hl_range.range.contains_range(hl_range.range) {
-            return self.nested[start].add(hl_range);
+        if overlapping.len() == 1
+            && self.nested[overlapping.start].hl_range.range.contains_range(hl_range.range)
+        {
+            return self.nested[overlapping.start].add(hl_range);
         }
 
         let nested = self
             .nested
-            .splice(start..start + len, iter::once(Node::new(hl_range)))
+            .splice(overlapping.clone(), iter::once(Node::new(hl_range)))
             .collect::<Vec<_>>();
-        self.nested[start].nested = nested;
+        self.nested[overlapping.start].nested = nested;
     }
 
     fn flatten(&self, acc: &mut Vec<HlRange>) {
diff --git a/crates/ide/src/syntax_highlighting/injector.rs b/crates/ide/src/syntax_highlighting/injector.rs
index e8f17eb69..fd4025694 100644
--- a/crates/ide/src/syntax_highlighting/injector.rs
+++ b/crates/ide/src/syntax_highlighting/injector.rs
@@ -33,8 +33,7 @@ impl Injector {
         &self.buf
     }
     pub(super) fn map_range_up(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
-        let (start, len) = equal_range_by(&self.ranges, |&(r, _)| ordering(r, range));
-        (start..start + len).filter_map(move |i| {
+        equal_range_by(&self.ranges, |&(r, _)| ordering(r, range)).filter_map(move |i| {
             let (target_range, delta) = self.ranges[i];
             let intersection = target_range.intersect(range).unwrap();
             Some(intersection + delta?)