highlighter: Finish layers when all highlights on the layer are done

In the test cases the edoc layer (the backtick and single quote within
the comments) is recognized by `QueryIter` as being finished after it
highlights the inline code block - its only capture. The highlighter
needs to "deactivate" the layer rather than finishing (and removing it)
however, because the code block highlight extends to the next comment.

So when exiting an injection we check that the `QueryIter` considers a
layer to be finished and also that all highlights in the layer are done
as well.

Author: the-mikedavis

fixtures/highlighter/edoc_code_combined_injection.erl

@@ -0,0 +1,9 @@
+   %% `
+// ┡━┛╰─ comment markup.raw.inline
+// ╰─ comment
+   foo
+// ┗━┹─ string.special.symbol
+   %% '
+// ┡┛┡┛╰─ comment
+// │ ╰─ comment markup.raw.inline
+// ╰─ comment

fixtures/highlighter/edoc_code_combined_injection_in_markdown.md

@@ -0,0 +1,17 @@
+   ```erlang
+// ┡━┛┡━━━━┛╰─ markup.raw.block
+// │  ╰─ markup.raw.block label
+// ╰─ markup.raw.block punctuation.bracket
+   %% `
+// ┡━┛╰─ markup.raw.block comment markup.raw.inline
+// ╰─ markup.raw.block comment
+   foo
+// ┡━┛╰─ markup.raw.block
+// ╰─ markup.raw.block string.special.symbol
+   %% '
+// ┡┛┡┛╰─ markup.raw.block comment
+// │ ╰─ markup.raw.block comment markup.raw.inline
+// ╰─ markup.raw.block comment
+   ```
+// ┡━┛╰─ markup.raw.block
+// ╰─ markup.raw.block punctuation.bracket

fixtures/injections/edoc_code_combined_injection.erl

@@ -0,0 +1,5 @@
+   %% `
+//   ┗┹─ edoc
+   foo
+   %% '
+//   ┗┹─ edoc

highlighter/src/highlighter.rs

@@ -272,13 +272,27 @@ impl<'a, 'tree: 'a, Loader: LanguageLoader> Highlighter<'a, 'tree, Loader> {
                 QueryIterEvent::EnterInjection(injection) => self.enter_injection(injection.layer),
                 QueryIterEvent::Match(node) => self.start_highlight(node, &mut first_highlight),
                 QueryIterEvent::ExitInjection { injection, state } => {
-                    // state is returned if the layer is finished, if it isn't we have
-                    // a combined injection and need to deactivate its highlights
-                    if state.is_none() {
+                    // `state` is returned if the layer is finished according to the `QueryIter`.
+                    // The highlighter should only consider a layer finished, though, when it also
+                    // has no remaining ranges to highlight. If the injection is combined and has
+                    // highlight(s) past this injection's range then we should deactivate it
+                    // (saving the highlights for the layer's next injection range) rather than
+                    // removing it.
+                    let parent_start = self
+                        .layer_states
+                        .get(&self.current_layer)
+                        .map(|layer| layer.parent_highlights)
+                        .unwrap_or_default()
+                        .min(self.active_highlights.len());
+                    let layer_is_finished = state.is_some()
+                        && self.active_highlights[parent_start..]
+                            .iter()
+                            .all(|h| h.end <= injection.range.end);
+                    if layer_is_finished {
+                        self.layer_states.remove(&injection.layer);
+                    } else {
                         self.deactivate_layer(injection);
                         refresh = true;
-                    } else {
-                        self.layer_states.remove(&injection.layer);
                     }
                     let active_language = self.query.syntax().layer(self.current_layer).language;
                     self.active_config = self.query.loader().0.get_config(active_language);

highlighter/src/tests.rs

@@ -538,3 +538,21 @@ fn css_parent_child_highlight_precedence() {
     // preserved.
     highlight_fixture(&loader, "highlighter/parent_child_highlight_precedence.css");
 }
+
+#[test]
+fn edoc_code_combined_injection() {
+    let loader = TestLanguageLoader::new();
+
+    highlight_fixture(&loader, "highlighter/edoc_code_combined_injection.erl");
+    injection_fixture(&loader, "injections/edoc_code_combined_injection.erl");
+}
+
+#[test]
+fn edoc_code_combined_injection_in_markdown() {
+    let loader = TestLanguageLoader::new();
+    // Same as the above but within markdown to add extra layers.
+    highlight_fixture(
+        &loader,
+        "highlighter/edoc_code_combined_injection_in_markdown.md",
+    );
+}