feat: Use ThemeKey everywhere when getting Styles

This also means we can avoid allocating `String`s in a lot of cases but means we allocate a `Vec`
more often. Comparing the perf difference is hard but I have not seen Helix slow down because of
this.

Author: poliorcetics

helix-core/src/syntax.rs

@@ -352,7 +352,10 @@ pub fn read_query(language: &str, filename: &str) -> String {
 }
 
 impl LanguageConfiguration {
-    fn initialize_highlight(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {
+    fn initialize_highlight<T: AsRef<str>>(
+        &self,
+        scopes: &[T],
+    ) -> Option<Arc<HighlightConfiguration>> {
         let language = self.language_id.to_ascii_lowercase();
 
         let highlights_query = read_query(&language, "highlights.scm");
@@ -382,13 +385,16 @@ impl LanguageConfiguration {
         }
     }
 
-    pub fn reconfigure(&self, scopes: &[String]) {
+    pub fn reconfigure(&self, scopes: &[&str]) {
         if let Some(Some(config)) = self.highlight_config.get() {
             config.configure(scopes);
         }
     }
 
-    pub fn highlight_config(&self, scopes: &[String]) -> Option<Arc<HighlightConfiguration>> {
+    pub fn highlight_config<T: AsRef<str>>(
+        &self,
+        scopes: &[T],
+    ) -> Option<Arc<HighlightConfiguration>> {
         self.highlight_config
             .get_or_init(|| self.initialize_highlight(scopes))
             .clone()
@@ -546,16 +552,17 @@ impl Loader {
         self.language_configs.iter()
     }
 
-    pub fn set_scopes(&self, scopes: Vec<String>) {
-        self.scopes.store(Arc::new(scopes));
+    pub fn set_scopes(&self, scopes: &[&str]) {
+        self.scopes
+            .store(Arc::new(scopes.iter().map(ToString::to_string).collect()));
 
         // Reconfigure existing grammars
         for config in self
             .language_configs
             .iter()
             .filter(|cfg| cfg.is_highlight_initialized())
         {
-            config.reconfigure(&self.scopes());
+            config.reconfigure(scopes);
         }
     }
 
@@ -1361,7 +1368,7 @@ impl HighlightConfiguration {
     ///
     /// When highlighting, results are returned as `Highlight` values, which contain the index
     /// of the matched highlight this list of highlight names.
-    pub fn configure(&self, recognized_names: &[String]) {
+    pub fn configure<T: AsRef<str>>(&self, recognized_names: &[T]) {
         let mut capture_parts = Vec::new();
         let indices: Vec<_> = self
             .query
@@ -1377,7 +1384,7 @@ impl HighlightConfiguration {
                     let recognized_name = recognized_name;
                     let mut len = 0;
                     let mut matches = true;
-                    for (i, part) in recognized_name.split('.').enumerate() {
+                    for (i, part) in recognized_name.as_ref().split('.').enumerate() {
                         match capture_parts.get(i) {
                             Some(capture_part) if *capture_part == part => len += 1,
                             _ => {
@@ -2043,7 +2050,7 @@ mod test {
 
     #[test]
     fn test_parser() {
-        let highlight_names: Vec<String> = [
+        let highlight_names: &[&str] = &[
             "attribute",
             "constant",
             "function.builtin",
@@ -2062,11 +2069,7 @@ mod test {
             "variable",
             "variable.builtin",
             "variable.parameter",
-        ]
-        .iter()
-        .cloned()
-        .map(String::from)
-        .collect();
+        ];
 
         let loader = Loader::new(Configuration { language: vec![] });
 
@@ -2080,7 +2083,7 @@ mod test {
             "", // locals.scm
         )
         .unwrap();
-        config.configure(&highlight_names);
+        config.configure(highlight_names);
 
         let source = Rope::from_str(
             "

helix-core/tests/indent.rs

@@ -38,7 +38,7 @@ fn test_treesitter_indent(file_name: &str, lang_scope: &str) {
     std::env::set_var("HELIX_RUNTIME", runtime.to_str().unwrap());
 
     let language_config = loader.language_config_for_scope(lang_scope).unwrap();
-    let highlight_config = language_config.highlight_config(&[]).unwrap();
+    let highlight_config = language_config.highlight_config::<String>(&[]).unwrap();
     let syntax = Syntax::new(&doc, highlight_config, std::sync::Arc::new(loader));
     let indent_query = language_config.indent_query().unwrap();
     let text = doc.slice(..);

helix-term/src/commands/dap.rs

@@ -8,7 +8,7 @@ use dap::{StackFrame, Thread, ThreadStates};
 use helix_core::syntax::{DebugArgumentValue, DebugConfigCompletion, DebugTemplate};
 use helix_dap::{self as dap, Client};
 use helix_lsp::block_on;
-use helix_view::editor::Breakpoint;
+use helix_view::{editor::Breakpoint, theme::ThemeKey};
 
 use serde_json::{to_value, Value};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -495,9 +495,9 @@ pub fn dap_variables(cx: &mut Context) {
     let mut variables = Vec::new();
 
     let theme = &cx.editor.theme;
-    let scope_style = theme.get("ui.linenr.selected");
-    let type_style = theme.get("ui.text");
-    let text_style = theme.get("ui.text.focus");
+    let scope_style = theme.get(ThemeKey::UiLinenrSelected);
+    let type_style = theme.get(ThemeKey::UiText);
+    let text_style = theme.get(ThemeKey::UiTextFocus);
 
     for scope in scopes.iter() {
         // use helix_view::graphics::Style;

helix-term/src/commands/lsp.rs

@@ -9,7 +9,10 @@ use tui::text::{Span, Spans};
 use super::{align_view, push_jump, Align, Context, Editor, Open};
 
 use helix_core::{path, Selection};
-use helix_view::{editor::Action, theme::Style};
+use helix_view::{
+    editor::Action,
+    theme::{Style, ThemeKey},
+};
 
 use crate::{
     compositor::{self, Compositor},
@@ -268,10 +271,10 @@ fn diag_picker(
     }
 
     let styles = DiagnosticStyles {
-        hint: cx.editor.theme.get("hint"),
-        info: cx.editor.theme.get("info"),
-        warning: cx.editor.theme.get("warning"),
-        error: cx.editor.theme.get("error"),
+        hint: cx.editor.theme.get(ThemeKey::Hint),
+        info: cx.editor.theme.get(ThemeKey::Info),
+        warning: cx.editor.theme.get(ThemeKey::Warning),
+        error: cx.editor.theme.get(ThemeKey::Error),
     };
 
     FilePicker::new(

helix-term/src/ui/completion.rs

@@ -1,5 +1,5 @@
 use crate::compositor::{Component, Context, Event, EventResult};
-use helix_view::editor::CompleteAction;
+use helix_view::{editor::CompleteAction, theme::ThemeKey};
 use tui::buffer::Buffer as Surface;
 use tui::text::Spans;
 
@@ -411,7 +411,7 @@ impl Component for Completion {
             };
 
             // clear area
-            let background = cx.editor.theme.get("ui.popup");
+            let background = cx.editor.theme.get(ThemeKey::UiPopup);
             surface.clear_with(area, background);
             markdown_doc.render(area, surface, cx);
         }

helix-term/src/ui/editor.rs

@@ -21,6 +21,7 @@ use helix_view::{
     graphics::{Color, CursorKind, Modifier, Rect, Style},
     input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
     keyboard::{KeyCode, KeyModifiers},
+    theme::ThemeKey,
     Document, Editor, Theme, View,
 };
 use std::{borrow::Cow, path::PathBuf};
@@ -107,7 +108,7 @@ impl EditorView {
                             area.width,
                             1,
                         ),
-                        theme.get("ui.highlight"),
+                        theme.get(ThemeKey::UiHighlight),
                     );
                 }
             }
@@ -153,7 +154,7 @@ impl EditorView {
         // if we're not at the edge of the screen, draw a right border
         if viewport.right() != view.area.right() {
             let x = area.right();
-            let border_style = theme.get("ui.window");
+            let border_style = theme.get(ThemeKey::UiWindow);
             for y in area.top()..area.bottom() {
                 surface[(x, y)]
                     .set_symbol(tui::symbols::line::VERTICAL)
@@ -185,7 +186,7 @@ impl EditorView {
     ) {
         let editor_rulers = &editor.config().rulers;
         let ruler_theme = theme
-            .try_get("ui.virtual.ruler")
+            .try_get(ThemeKey::UiVirtualRuler)
             .unwrap_or_else(|| Style::default().bg(Color::Red));
 
         let rulers = doc
@@ -268,20 +269,20 @@ impl EditorView {
             theme
             .find_scope_index(scope)
             // get one of the themes below as fallback values
-            .or_else(|| theme.find_scope_index("diagnostic"))
-            .or_else(|| theme.find_scope_index("ui.cursor"))
-            .or_else(|| theme.find_scope_index("ui.selection"))
+            .or_else(|| theme.find_scope_index(ThemeKey::Diagnostic))
+            .or_else(|| theme.find_scope_index(ThemeKey::UiCursor))
+            .or_else(|| theme.find_scope_index(ThemeKey::UiSelection))
             .expect(
                 "at least one of the following scopes must be defined in the theme: `diagnostic`, `ui.cursor`, or `ui.selection`",
             )
         };
 
         // basically just queries the theme color defined in the config
-        let hint = get_scope_of("diagnostic.hint");
-        let info = get_scope_of("diagnostic.info");
-        let warning = get_scope_of("diagnostic.warning");
-        let error = get_scope_of("diagnostic.error");
-        let r#default = get_scope_of("diagnostic"); // this is a bit redundant but should be fine
+        let hint = get_scope_of(ThemeKey::DiagnosticHint);
+        let info = get_scope_of(ThemeKey::DiagnosticInfo);
+        let warning = get_scope_of(ThemeKey::DiagnosticWarning);
+        let error = get_scope_of(ThemeKey::DiagnosticError);
+        let r#default = get_scope_of(ThemeKey::Diagnostic); // this is a bit redundant but should be fine
 
         doc.diagnostics()
             .iter()
@@ -317,24 +318,24 @@ impl EditorView {
         let cursor_is_block = cursorkind == CursorKind::Block;
 
         let selection_scope = theme
-            .find_scope_index("ui.selection")
+            .find_scope_index(ThemeKey::UiSelection)
             .expect("could not find `ui.selection` scope in the theme!");
         let base_cursor_scope = theme
-            .find_scope_index("ui.cursor")
+            .find_scope_index(ThemeKey::UiCursor)
             .unwrap_or(selection_scope);
 
         let cursor_scope = match mode {
-            Mode::Insert => theme.find_scope_index("ui.cursor.insert"),
-            Mode::Select => theme.find_scope_index("ui.cursor.select"),
+            Mode::Insert => theme.find_scope_index(ThemeKey::UiCursorInsert),
+            Mode::Select => theme.find_scope_index(ThemeKey::UiCursorSelect),
             Mode::Normal => Some(base_cursor_scope),
         }
         .unwrap_or(base_cursor_scope);
 
         let primary_cursor_scope = theme
-            .find_scope_index("ui.cursor.primary")
+            .find_scope_index(ThemeKey::UiCursorPrimary)
             .unwrap_or(cursor_scope);
         let primary_selection_scope = theme
-            .find_scope_index("ui.selection.primary")
+            .find_scope_index(ThemeKey::UiSelectionPrimary)
             .unwrap_or(selection_scope);
 
         let mut spans: Vec<(usize, std::ops::Range<usize>)> = Vec::new();
@@ -418,17 +419,17 @@ impl EditorView {
         };
         let indent_guide_char = config.indent_guides.character.to_string();
 
-        let text_style = theme.get("ui.text");
-        let whitespace_style = theme.get("ui.virtual.whitespace");
+        let text_style = theme.get(ThemeKey::UiText);
+        let whitespace_style = theme.get(ThemeKey::UiVirtualWhitespace);
 
         let mut is_in_indent_area = true;
         let mut last_line_indent_level = 0;
 
         // use whitespace style as fallback for indent-guide
         let indent_guide_style = text_style.patch(
             theme
-                .try_get("ui.virtual.indent-guide")
-                .unwrap_or_else(|| theme.get("ui.virtual.whitespace")),
+                .try_get(ThemeKey::UiVirtualIndentguide)
+                .unwrap_or_else(|| theme.get(ThemeKey::UiVirtualWhitespace)),
         );
 
         let draw_indent_guides = |indent_level, line, surface: &mut Surface| {
@@ -606,7 +607,7 @@ impl EditorView {
                 if (pos.col as u16) < viewport.width + view.offset.col as u16
                     && pos.col >= view.offset.col
                 {
-                    let style = theme.try_get("ui.cursor.match").unwrap_or_else(|| {
+                    let style = theme.try_get(ThemeKey::UiCursorMatch).unwrap_or_else(|| {
                         Style::default()
                             .add_modifier(Modifier::REVERSED)
                             .add_modifier(Modifier::DIM)
@@ -626,19 +627,19 @@ impl EditorView {
             viewport,
             editor
                 .theme
-                .try_get("ui.bufferline.background")
-                .unwrap_or_else(|| editor.theme.get("ui.statusline")),
+                .try_get(ThemeKey::UiBufferlineBackground)
+                .unwrap_or_else(|| editor.theme.get(ThemeKey::UiStatusline)),
         );
 
         let bufferline_active = editor
             .theme
-            .try_get("ui.bufferline.active")
-            .unwrap_or_else(|| editor.theme.get("ui.statusline.active"));
+            .try_get(ThemeKey::UiBufferlineActive)
+            .unwrap_or_else(|| editor.theme.get(ThemeKey::UiStatuslineActive));
 
         let bufferline_inactive = editor
             .theme
-            .try_get("ui.bufferline")
-            .unwrap_or_else(|| editor.theme.get("ui.statusline.inactive"));
+            .try_get(ThemeKey::UiBufferline)
+            .unwrap_or_else(|| editor.theme.get(ThemeKey::UiStatuslineInactive));
 
         let mut x = viewport.x;
         let current_doc = view!(editor).doc;
@@ -695,7 +696,7 @@ impl EditorView {
 
         let mut offset = 0;
 
-        let gutter_style = theme.get("ui.gutter");
+        let gutter_style = theme.get(ThemeKey::UiGutter);
 
         // avoid lots of small allocations by reusing a text buffer for each line
         let mut text = String::with_capacity(8);
@@ -752,13 +753,13 @@ impl EditorView {
             diagnostic.range.start <= cursor && diagnostic.range.end >= cursor
         });
 
-        let warning = theme.get("warning");
-        let error = theme.get("error");
-        let info = theme.get("info");
-        let hint = theme.get("hint");
+        let warning = theme.get(ThemeKey::Warning);
+        let error = theme.get(ThemeKey::Error);
+        let info = theme.get(ThemeKey::Info);
+        let hint = theme.get(ThemeKey::Hint);
 
         let mut lines = Vec::new();
-        let background_style = theme.get("ui.background");
+        let background_style = theme.get(ThemeKey::UiBackground);
         for diagnostic in diagnostics {
             let style = Style::reset()
                 .patch(background_style)
@@ -802,8 +803,8 @@ impl EditorView {
             .map(|range| range.cursor_line(text))
             .collect();
 
-        let primary_style = theme.get("ui.cursorline.primary");
-        let secondary_style = theme.get("ui.cursorline.secondary");
+        let primary_style = theme.get(ThemeKey::UiCursorlinePrimary);
+        let secondary_style = theme.get(ThemeKey::UiCursorlineSecondary);
 
         for line in view.offset.row..(last_line + 1) {
             let area = Rect::new(
@@ -1342,7 +1343,7 @@ impl Component for EditorView {
 
     fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
         // clear with background color
-        surface.set_style(area, cx.editor.theme.get("ui.background"));
+        surface.set_style(area, cx.editor.theme.get(ThemeKey::UiBackground));
         let config = cx.editor.config();
 
         // check if bufferline should be rendered
@@ -1386,9 +1387,9 @@ impl Component for EditorView {
             status_msg_width = status_msg.width();
             use helix_view::editor::Severity;
             let style = if *severity == Severity::Error {
-                cx.editor.theme.get("error")
+                cx.editor.theme.get(ThemeKey::Error)
             } else {
-                cx.editor.theme.get("ui.text")
+                cx.editor.theme.get(ThemeKey::UiText)
             };
 
             surface.set_string(
@@ -1410,7 +1411,7 @@ impl Component for EditorView {
             if let Some(pseudo_pending) = &cx.editor.pseudo_pending {
                 disp.push_str(pseudo_pending.as_str())
             }
-            let style = cx.editor.theme.get("ui.text");
+            let style = cx.editor.theme.get(ThemeKey::UiText);
             let macro_width = if cx.editor.macro_recording.is_some() {
                 3
             } else {