Add tree-sitter-highlight-name command

book/src/generated/typable-cmd.md

@@ -55,6 +55,7 @@
 | `:lsp-restart` | Restarts the language servers used by the current doc |
 | `:lsp-stop` | Stops the language servers that are used by the current doc |
 | `:tree-sitter-scopes` | Display tree sitter scopes, primarily for theming and development. |
+| `:tree-sitter-highlight-name` | Display tree-sitter highlight name. |
 | `:debug-start`, `:dbg` | Start a debug session from a given template with given parameters. |
 | `:debug-remote`, `:dbg-tcp` | Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters. |
 | `:debug-eval` | Evaluate expression in current debug context. |

helix-core/src/syntax.rs

@@ -2456,6 +2456,44 @@ pub fn pretty_print_tree<W: fmt::Write>(fmt: &mut W, node: Node) -> fmt::Result
     }
 }
 
+pub fn get_highlight_for_node_at_position(
+    syntax: Option<&Syntax>,
+    text: RopeSlice,
+    pos: usize,
+) -> Option<Highlight> {
+    let mut highlight: Option<Highlight> = None;
+    if let Some(syntax) = syntax {
+        let pos = text.char_to_byte(pos);
+
+        let node: Node = match syntax
+            .tree()
+            .root_node()
+            .descendant_for_byte_range(pos, pos)
+        {
+            Some(node) => node,
+            None => return None,
+        };
+
+        for event in syntax
+            .highlight_iter(text.slice(..), Some(node.byte_range()), None)
+            .map(|event| event.unwrap())
+        {
+            match event {
+                HighlightEvent::Source { start, end } => {
+                    if start == node.start_byte() && end == node.end_byte() {
+                        break;
+                    }
+                }
+                HighlightEvent::HighlightStart(hl) => {
+                    highlight = Some(hl);
+                }
+                HighlightEvent::HighlightEnd => {}
+            }
+        }
+    }
+    highlight
+}
+
 fn pretty_print_tree_impl<W: fmt::Write>(
     fmt: &mut W,
     cursor: &mut TreeCursor,

helix-term/src/commands/typed.rs

@@ -1527,6 +1527,46 @@ fn tree_sitter_scopes(
     Ok(())
 }
 
+fn tree_sitter_highlight_name(
+    cx: &mut compositor::Context,
+    _args: &[Cow<str>],
+    event: PromptEvent,
+) -> anyhow::Result<()> {
+    if event != PromptEvent::Validate {
+        return Ok(());
+    }
+
+    let (view, doc) = current!(cx.editor);
+    let text = doc.text().slice(..);
+
+    let pos = doc.selection(view.id).primary().cursor(text);
+
+    let mut highlight_name: &str = "";
+    if let Some(highlight) =
+        helix_core::syntax::get_highlight_for_node_at_position(doc.syntax(), text, pos)
+    {
+        let theme = &cx.editor.theme;
+        highlight_name = theme.scope(highlight.0);
+    }
+
+    let content = format!("``json\n{:?}\n````", highlight_name);
+
+    let callback = async move {
+        let call: job::Callback = Callback::EditorCompositor(Box::new(
+            move |editor: &mut Editor, compositor: &mut Compositor| {
+                let content = ui::Markdown::new(content, editor.syn_loader.clone());
+                let popup = Popup::new("hover", content).auto_close(true);
+                compositor.replace_or_push("hover", popup);
+            },
+        ));
+        Ok(call)
+    };
+
+    cx.jobs.callback(callback);
+
+    Ok(())
+}
+
 fn vsplit(
     cx: &mut compositor::Context,
     args: &[Cow<str>],
@@ -2684,6 +2724,13 @@ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
         fun: tree_sitter_scopes,
         signature: CommandSignature::none(),
     },
+    TypableCommand {
+        name: "tree-sitter-highlight-name",
+        aliases: &[],
+        doc: "Display tree-sitter highlight name.",
+        fun: tree_sitter_highlight_name,
+        signature: CommandSignature::none(),
+    },
     TypableCommand {
         name: "debug-start",
         aliases: &["dbg"],

helix-view/src/theme.rs

@@ -297,6 +297,11 @@ impl Theme {
         self.highlights[index]
     }
 
+    #[inline]
+    pub fn scope(&self, index: usize) -> &str {
+        &self.scopes[index]
+    }
+
     pub fn name(&self) -> &str {
         &self.name
     }