🌈

Author: the-mikedavis

helix-core/src/syntax.rs

@@ -950,6 +950,8 @@ impl Syntax {
             layers,
             next_event: None,
             last_highlight_range: None,
+            match_highlights: HashMap::new(),
+            rainbow_nesting_level: 0,
         };
         result.sort_layers();
         result
@@ -1163,6 +1165,9 @@ pub struct HighlightConfiguration {
     local_def_capture_index: Option<u32>,
     local_def_value_capture_index: Option<u32>,
     local_ref_capture_index: Option<u32>,
+    rainbow_capture_index: Option<u32>,
+    /// The number of rainbow styles in the current theme.
+    rainbow_styles: AtomicUsize,
 }
 
 #[derive(Debug)]
@@ -1188,6 +1193,11 @@ struct HighlightIter<'a> {
     iter_count: usize,
     next_event: Option<HighlightEvent>,
     last_highlight_range: Option<(usize, usize, usize)>,
+    /// A mapping between tree-sitter `QueryMatch` IDs and `Highlights`.
+    /// This can be used to re-use a single highlight for an entire match
+    /// like with rainbow matches.
+    match_highlights: HashMap<u32, Highlight>,
+    rainbow_nesting_level: usize,
 }
 
 // Adapter to convert rope chunks to bytes
@@ -1307,13 +1317,15 @@ impl HighlightConfiguration {
         let mut local_def_value_capture_index = None;
         let mut local_ref_capture_index = None;
         let mut local_scope_capture_index = None;
+        let mut rainbow_capture_index = None;
         for (i, name) in query.capture_names().iter().enumerate() {
             let i = Some(i as u32);
             match name.as_str() {
                 "local.definition" => local_def_capture_index = i,
                 "local.definition-value" => local_def_value_capture_index = i,
                 "local.reference" => local_ref_capture_index = i,
                 "local.scope" => local_scope_capture_index = i,
+                "rainbow" => rainbow_capture_index = i,
                 _ => {}
             }
         }
@@ -1342,6 +1354,8 @@ impl HighlightConfiguration {
             local_def_capture_index,
             local_def_value_capture_index,
             local_ref_capture_index,
+            rainbow_capture_index,
+            rainbow_styles: AtomicUsize::new(0),
         })
     }
 
@@ -1373,7 +1387,6 @@ impl HighlightConfiguration {
                 let mut best_index = None;
                 let mut best_match_len = 0;
                 for (i, recognized_name) in recognized_names.iter().enumerate() {
-                    let recognized_name = recognized_name;
                     let mut len = 0;
                     let mut matches = true;
                     for part in recognized_name.split('.') {
@@ -1393,6 +1406,13 @@ impl HighlightConfiguration {
             .collect();
 
         self.highlight_indices.store(Arc::new(indices));
+
+        let rainbow_styles = recognized_names
+            .iter()
+            .filter(|name| name.starts_with("rainbow."))
+            .count();
+
+        self.rainbow_styles.store(rainbow_styles, Ordering::Relaxed);
     }
 }
 
@@ -1765,7 +1785,46 @@ impl<'a> Iterator for HighlightIter<'a> {
                 }
             }
 
-            let current_highlight = layer.config.highlight_indices.load()[capture.index as usize];
+            // If the capture corresponds to the `@rainbow` scope, lookup the match
+            // in the `match_highlights` map. Otherwise, use the highlight from
+            // attempt to replace its default
+            let rainbow_highlight = if layer.config.rainbow_capture_index == Some(capture.index) {
+                let rainbow_styles = layer.config.rainbow_styles.load(Ordering::Relaxed);
+
+                if rainbow_styles > 0 {
+                    if capture_index == 0 {
+                        // Initial capture in the match, add the entry and increment
+                        // nesting level, wrapping around to the first rainbow color.
+                        let next_highlight = Highlight(self.rainbow_nesting_level);
+
+                        self.rainbow_nesting_level =
+                            (self.rainbow_nesting_level + 1) % rainbow_styles;
+
+                        self.match_highlights.insert(match_.id(), next_highlight);
+
+                        Some(next_highlight)
+                    } else if capture_index == match_.captures.len() - 1 {
+                        // Final capture in the match, remove the entry and decrement
+                        // nesting level, wrapping around to the last rainbow color.
+                        self.rainbow_nesting_level = self
+                            .rainbow_nesting_level
+                            .checked_sub(1)
+                            .unwrap_or(rainbow_styles - 1);
+
+                        self.match_highlights.remove(&match_.id())
+                    } else {
+                        // Any nodes between the first and last re-use the highlight.
+                        self.match_highlights.get(&match_.id()).copied()
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            let current_highlight = rainbow_highlight
+                .or_else(|| layer.config.highlight_indices.load()[capture.index as usize]);
 
             // If this node represents a local definition, then store the current
             // highlight value on the local scope entry representing this node.

helix-view/src/editor.rs

@@ -155,14 +155,16 @@ pub struct Config {
     #[serde(default)]
     pub search: SearchConfig,
     pub lsp: LspConfig,
-    /// Column numbers at which to draw the rulers. Default to `[]`, meaning no rulers.
+    /// Column numbers at which to draw the rulers. Defaults to `[]`, meaning no rulers.
     pub rulers: Vec<u16>,
     #[serde(default)]
     pub whitespace: WhitespaceConfig,
     /// Vertical indent width guides.
     pub indent_guides: IndentGuidesConfig,
     /// Whether to color modes with different colors. Defaults to `false`.
     pub color_modes: bool,
+    /// Whether to highlight rainbow brackets. Defaults to `false`.
+    pub rainbow_brackets: bool,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
@@ -417,6 +419,8 @@ impl Default for Config {
             whitespace: WhitespaceConfig::default(),
             indent_guides: IndentGuidesConfig::default(),
             color_modes: false,
+            // FIXME set me to `false` before un-drafting the PR
+            rainbow_brackets: true,
         }
     }
 }
@@ -646,8 +650,13 @@ impl Editor {
             return;
         }
 
-        let scopes = theme.scopes();
-        self.syn_loader.set_scopes(scopes.to_vec());
+        let theme = if self.config().rainbow_brackets {
+            theme.with_rainbow()
+        } else {
+            theme
+        };
+
+        self.syn_loader.set_scopes(theme.scopes().to_vec());
 
         match preview {
             ThemeAction::Preview => {

helix-view/src/theme.rs

@@ -103,6 +103,7 @@ pub struct Theme {
     // tree-sitter highlight styles are stored in a Vec to optimize lookups
     scopes: Vec<String>,
     highlights: Vec<Style>,
+    rainbow: Vec<Style>,
 }
 
 impl<'de> Deserialize<'de> for Theme {
@@ -113,6 +114,7 @@ impl<'de> Deserialize<'de> for Theme {
         let mut styles = HashMap::new();
         let mut scopes = Vec::new();
         let mut highlights = Vec::new();
+        let mut rainbows = Vec::new();
 
         if let Ok(mut colors) = HashMap::<String, Value>::deserialize(deserializer) {
             // TODO: alert user of parsing failures in editor
@@ -126,6 +128,19 @@ impl<'de> Deserialize<'de> for Theme {
                 })
                 .unwrap_or_default();
 
+            for style_value in colors
+                .remove("rainbow")
+                .and_then(|v| v.as_array().cloned())
+                .unwrap_or_default()
+                .iter()
+            {
+                let mut style = Style::default();
+                match palette.parse_style(&mut style, style_value.clone()) {
+                    Ok(()) => rainbows.push(style),
+                    Err(err) => warn!("{}", err),
+                }
+            }
+
             styles.reserve(colors.len());
             scopes.reserve(colors.len());
             highlights.reserve(colors.len());
@@ -147,6 +162,7 @@ impl<'de> Deserialize<'de> for Theme {
             scopes,
             styles,
             highlights,
+            rainbow: rainbows,
         })
     }
 }
@@ -185,6 +201,47 @@ impl Theme {
                 .all(|color| !matches!(color, Some(Color::Rgb(..))))
         })
     }
+
+    /// Returns a new theme with rainbow scopes enabled.
+    ///
+    /// Rainbow scopes are prepended to the `scopes` and `highlights` `Vec`s
+    /// and merged into the `styles` `HashMap`.
+    pub fn with_rainbow(&self) -> Self {
+        let mut scopes = Vec::new();
+        let mut styles = self.styles.clone();
+
+        let rainbow = if self.rainbow.is_empty() {
+            // Default rainbow
+            vec![
+                Style::default().fg(Color::Red),
+                Style::default().fg(Color::Yellow),
+                Style::default().fg(Color::Green),
+                Style::default().fg(Color::Blue),
+                Style::default().fg(Color::Cyan),
+                Style::default().fg(Color::Magenta),
+            ]
+        } else {
+            self.rainbow.clone()
+        };
+
+        let mut highlights = rainbow.clone();
+
+        for (i, style) in rainbow.iter().enumerate() {
+            let name = format!("rainbow.{}", i);
+            styles.insert(name.clone(), *style);
+            scopes.push(name);
+        }
+
+        scopes.extend(self.scopes.clone());
+        highlights.extend(self.highlights.clone());
+
+        Self {
+            scopes,
+            styles,
+            highlights,
+            rainbow,
+        }
+    }
 }
 
 struct ThemePalette {