Merge 55151a3888 into 109f53fb60

* Make dark_plus.toml more accurate to VSCode

* theme(dark_plus): make type.builtin blue

* Refactor dark_plus and add myself as new maintainer

Co-authored-by: NAME <NAME@EXAMPLE.COM>

---------

Co-authored-by: Luca Saccarola <96259932+saccarosium@users.noreply.github.com>
Co-authored-by: Luca Saccarola <github.e41mv@aleeas.com>
Co-authored-by: NAME <NAME@EXAMPLE.COM>

helix-core/src/match_brackets.rs

@@ -9,16 +9,32 @@
 const MAX_PLAINTEXT_SCAN: usize = 10000;
 const MATCH_LIMIT: usize = 16;
 
-// Limit matching pairs to only ( ) { } [ ] < > ' ' " "
-const PAIRS: &[(char, char)] = &[
+pub const BRACKETS: [(char, char); 7] = [
     ('(', ')'),
     ('{', '}'),
     ('[', ']'),
     ('<', '>'),
-    ('\'', '\''),
-    ('\"', '\"'),
+    ('«', '»'),
+    ('「', '」'),
+    ('（', '）'),
 ];
 
+// The difference between BRACKETS and PAIRS is that we can find matching
+// BRACKETS in a plain text file, but we can't do the same for PAIRs.
+// PAIRS also contains all BRACKETS.
+pub const PAIRS: [(char, char); BRACKETS.len() + 3] = {
+    let mut pairs = [(' ', ' '); BRACKETS.len() + 3];
+    let mut idx = 0;
+    while idx < BRACKETS.len() {
+        pairs[idx] = BRACKETS[idx];
+        idx += 1;
+    }
+    pairs[idx] = ('"', '"');
+    pairs[idx + 1] = ('\'', '\'');
+    pairs[idx + 2] = ('`', '`');
+    pairs
+};
+
 /// Returns the position of the matching bracket under cursor.
 ///
 /// If the cursor is on the opening bracket, the position of
@@ -30,7 +46,7 @@
 /// If no matching bracket is found, `None` is returned.
 #[must_use]
 pub fn find_matching_bracket(syntax: &Syntax, doc: RopeSlice, pos: usize) -> Option<usize> {
-    if pos >= doc.len_chars() || !is_valid_bracket(doc.char(pos)) {
+    if pos >= doc.len_chars() || !is_valid_pair(doc.char(pos)) {
         return None;
     }
     find_pair(syntax, doc, pos, false)
@@ -67,7 +83,7 @@ fn find_pair(
             let (start_byte, end_byte) = surrounding_bytes(doc, &node)?;
             let (start_char, end_char) = (doc.byte_to_char(start_byte), doc.byte_to_char(end_byte));
 
-            if is_valid_pair(doc, start_char, end_char) {
+            if is_valid_pair_on_pos(doc, start_char, end_char) {
                 if end_byte == pos {
                     return Some(start_char);
                 }
@@ -140,14 +156,22 @@ fn find_pair(
 /// If no matching bracket is found, `None` is returned.
 #[must_use]
 pub fn find_matching_bracket_plaintext(doc: RopeSlice, cursor_pos: usize) -> Option<usize> {
-    // Don't do anything when the cursor is not on top of a bracket.
     let bracket = doc.get_char(cursor_pos)?;
+    let matching_bracket = {
+        let pair = get_pair(bracket);
+        if pair.0 == bracket {
+            pair.1
+        } else {
+            pair.0
+        }
+    };
+    // Don't do anything when the cursor is not on top of a bracket.
     if !is_valid_bracket(bracket) {
         return None;
     }
 
     // Determine the direction of the matching.
-    let is_fwd = is_forward_bracket(bracket);
+    let is_fwd = is_open_bracket(bracket);
     let chars_iter = if is_fwd {
         doc.chars_at(cursor_pos + 1)
     } else {
@@ -159,19 +183,7 @@ pub fn find_matching_bracket_plaintext(doc: RopeSlice, cursor_pos: usize) -> Opt
     for (i, candidate) in chars_iter.take(MAX_PLAINTEXT_SCAN).enumerate() {
         if candidate == bracket {
             open_cnt += 1;
-        } else if is_valid_pair(
-            doc,
-            if is_fwd {
-                cursor_pos
-            } else {
-                cursor_pos - i - 1
-            },
-            if is_fwd {
-                cursor_pos + i + 1
-            } else {
-                cursor_pos
-            },
-        ) {
+        } else if candidate == matching_bracket {
             // Return when all pending brackets have been closed.
             if open_cnt == 1 {
                 return Some(if is_fwd {
@@ -187,15 +199,49 @@ pub fn find_matching_bracket_plaintext(doc: RopeSlice, cursor_pos: usize) -> Opt
     None
 }
 
-fn is_valid_bracket(c: char) -> bool {
-    PAIRS.iter().any(|(l, r)| *l == c || *r == c)
+/// Returns the open and closing chars pair. If not found in
+/// [`BRACKETS`] returns (ch, ch).
+///
+/// ```
+/// use helix_core::match_brackets::get_pair;
+///
+/// assert_eq!(get_pair('['), ('[', ']'));
+/// assert_eq!(get_pair('}'), ('{', '}'));
+/// assert_eq!(get_pair('"'), ('"', '"'));
+/// ```
+pub fn get_pair(ch: char) -> (char, char) {
+    PAIRS
+        .iter()
+        .find(|(open, close)| *open == ch || *close == ch)
+        .copied()
+        .unwrap_or((ch, ch))
 }
 
-fn is_forward_bracket(c: char) -> bool {
-    PAIRS.iter().any(|(l, _)| *l == c)
+pub fn is_open_bracket(ch: char) -> bool {
+    BRACKETS.iter().any(|(l, _)| *l == ch)
 }
 
-fn is_valid_pair(doc: RopeSlice, start_char: usize, end_char: usize) -> bool {
+pub fn is_close_bracket(ch: char) -> bool {
+    BRACKETS.iter().any(|(_, r)| *r == ch)
+}
+
+pub fn is_valid_bracket(ch: char) -> bool {
+    BRACKETS.iter().any(|(l, r)| *l == ch || *r == ch)
+}
+
+pub fn is_open_pair(ch: char) -> bool {
+    PAIRS.iter().any(|(l, _)| *l == ch)
+}
+
+pub fn is_close_pair(ch: char) -> bool {
+    PAIRS.iter().any(|(_, r)| *r == ch)
+}
+
+pub fn is_valid_pair(ch: char) -> bool {
+    PAIRS.iter().any(|(l, r)| *l == ch || *r == ch)
+}
+
+fn is_valid_pair_on_pos(doc: RopeSlice, start_char: usize, end_char: usize) -> bool {
     PAIRS.contains(&(doc.char(start_char), doc.char(end_char)))
 }
 

helix-core/src/object.rs

@@ -1,4 +1,4 @@
-use crate::{syntax::TreeCursor, Range, RopeSlice, Selection, Syntax};
+use crate::{movement::Direction, syntax::TreeCursor, Range, RopeSlice, Selection, Syntax};
 
 pub fn expand_selection(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
     let cursor = &mut syntax.walk();
@@ -25,19 +25,31 @@ pub fn expand_selection(syntax: &Syntax, text: RopeSlice, selection: Selection)
 }
 
 pub fn shrink_selection(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
-    select_node_impl(syntax, text, selection, |cursor| {
-        cursor.goto_first_child();
-    })
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            cursor.goto_first_child();
+        },
+        None,
+    )
 }
 
 pub fn select_next_sibling(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
-    select_node_impl(syntax, text, selection, |cursor| {
-        while !cursor.goto_next_sibling() {
-            if !cursor.goto_parent() {
-                break;
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            while !cursor.goto_next_sibling() {
+                if !cursor.goto_parent() {
+                    break;
+                }
             }
-        }
-    })
+        },
+        Some(Direction::Forward),
+    )
 }
 
 pub fn select_all_siblings(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
@@ -81,13 +93,19 @@ fn select_children<'n>(
 }
 
 pub fn select_prev_sibling(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
-    select_node_impl(syntax, text, selection, |cursor| {
-        while !cursor.goto_prev_sibling() {
-            if !cursor.goto_parent() {
-                break;
+    select_node_impl(
+        syntax,
+        text,
+        selection,
+        |cursor| {
+            while !cursor.goto_prev_sibling() {
+                if !cursor.goto_parent() {
+                    break;
+                }
             }
-        }
-    })
+        },
+        Some(Direction::Backward),
+    )
 }
 
 fn select_node_impl<F>(
@@ -95,6 +113,7 @@ fn select_node_impl<F>(
     text: RopeSlice,
     selection: Selection,
     motion: F,
+    direction: Option<Direction>,
 ) -> Selection
 where
     F: Fn(&mut TreeCursor),
@@ -113,6 +132,6 @@ fn select_node_impl<F>(
         let from = text.byte_to_char(node.start_byte());
         let to = text.byte_to_char(node.end_byte());
 
-        Range::new(from, to).with_direction(range.direction())
+        Range::new(from, to).with_direction(direction.unwrap_or_else(|| range.direction()))
     })
 }

helix-core/src/selection.rs

@@ -122,7 +122,7 @@ pub fn is_empty(&self) -> bool {
     }
 
     /// `Direction::Backward` when head < anchor.
-    /// `Direction::Backward` otherwise.
+    /// `Direction::Forward` otherwise.
     #[inline]
     #[must_use]
     pub fn direction(&self) -> Direction {

helix-core/src/surround.rs

@@ -1,18 +1,16 @@
 use std::fmt::Display;
 
-use crate::{movement::Direction, search, Range, Selection};
+use crate::{
+    graphemes::next_grapheme_boundary,
+    match_brackets::{
+        find_matching_bracket, find_matching_bracket_fuzzy, get_pair, is_close_bracket,
+        is_open_bracket,
+    },
+    movement::Direction,
+    search, Range, Selection, Syntax,
+};
 use ropey::RopeSlice;
 
-pub const PAIRS: &[(char, char)] = &[
-    ('(', ')'),
-    ('[', ']'),
-    ('{', '}'),
-    ('<', '>'),
-    ('«', '»'),
-    ('「', '」'),
-    ('（', '）'),
-];
-
 #[derive(Debug, PartialEq, Eq)]
 pub enum Error {
     PairNotFound,
@@ -34,32 +32,68 @@ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 
 type Result<T> = std::result::Result<T, Error>;
 
-/// Given any char in [PAIRS], return the open and closing chars. If not found in
-/// [PAIRS] return (ch, ch).
+/// Finds the position of surround pairs of any [`crate::match_brackets::PAIRS`]
+/// using tree-sitter when possible.
 ///
-/// ```
-/// use helix_core::surround::get_pair;
+/// # Returns
 ///
-/// assert_eq!(get_pair('['), ('[', ']'));
-/// assert_eq!(get_pair('}'), ('{', '}'));
-/// assert_eq!(get_pair('"'), ('"', '"'));
-/// ```
-pub fn get_pair(ch: char) -> (char, char) {
-    PAIRS
-        .iter()
-        .find(|(open, close)| *open == ch || *close == ch)
-        .copied()
-        .unwrap_or((ch, ch))
+/// Tuple `(anchor, head)`, meaning it is not always ordered.
+pub fn find_nth_closest_pairs_pos(
+    syntax: Option<&Syntax>,
+    text: RopeSlice,
+    range: Range,
+    skip: usize,
+) -> Result<(usize, usize)> {
+    match syntax {
+        Some(syntax) => find_nth_closest_pairs_ts(syntax, text, range, skip),
+        None => find_nth_closest_pairs_plain(text, range, skip),
+    }
 }
 
-pub fn find_nth_closest_pairs_pos(
+fn find_nth_closest_pairs_ts(
+    syntax: &Syntax,
     text: RopeSlice,
     range: Range,
     mut skip: usize,
 ) -> Result<(usize, usize)> {
-    let is_open_pair = |ch| PAIRS.iter().any(|(open, _)| *open == ch);
-    let is_close_pair = |ch| PAIRS.iter().any(|(_, close)| *close == ch);
+    let mut opening = range.from();
+    // We want to expand the selection if we are already on the found pair,
+    // otherwise we would need to subtract "-1" from "range.to()".
+    let mut closing = range.to();
 
+    while skip > 0 {
+        closing = find_matching_bracket_fuzzy(syntax, text, closing).ok_or(Error::PairNotFound)?;
+        opening = find_matching_bracket(syntax, text, closing).ok_or(Error::PairNotFound)?;
+        // If we're already on a closing bracket "find_matching_bracket_fuzzy" will return
+        // the position of the opening bracket.
+        if closing < opening {
+            (opening, closing) = (closing, opening);
+        }
+
+        // In case found brackets are partially inside current selection.
+        if range.from() < opening || closing < range.to() - 1 {
+            closing = next_grapheme_boundary(text, closing);
+        } else {
+            skip -= 1;
+            if skip != 0 {
+                closing = next_grapheme_boundary(text, closing);
+            }
+        }
+    }
+
+    // Keep the original direction.
+    if let Direction::Forward = range.direction() {
+        Ok((opening, closing))
+    } else {
+        Ok((closing, opening))
+    }
+}
+
+fn find_nth_closest_pairs_plain(
+    text: RopeSlice,
+    range: Range,
+    mut skip: usize,
+) -> Result<(usize, usize)> {
     let mut stack = Vec::with_capacity(2);
     let pos = range.from();
     let mut close_pos = pos.saturating_sub(1);
@@ -67,7 +101,7 @@ pub fn find_nth_closest_pairs_pos(
     for ch in text.chars_at(pos) {
         close_pos += 1;
 
-        if is_open_pair(ch) {
+        if is_open_bracket(ch) {
             // Track open pairs encountered so that we can step over
             // the corresponding close pairs that will come up further
             // down the loop. We want to find a lone close pair whose
@@ -76,7 +110,7 @@ pub fn find_nth_closest_pairs_pos(
             continue;
         }
 
-        if !is_close_pair(ch) {
+        if !is_close_bracket(ch) {
             // We don't care if this character isn't a brace pair item,
             // so short circuit here.
             continue;
@@ -157,7 +191,11 @@ pub fn find_nth_pairs_pos(
         )
     };
 
-    Option::zip(open, close).ok_or(Error::PairNotFound)
+    // preserve original direction
+    match range.direction() {
+        Direction::Forward => Option::zip(open, close).ok_or(Error::PairNotFound),
+        Direction::Backward => Option::zip(close, open).ok_or(Error::PairNotFound),
+    }
 }
 
 fn find_nth_open_pair(
@@ -249,6 +287,7 @@ fn find_nth_close_pair(
 /// are automatically detected around each cursor (note that this may result
 /// in them selecting different surround characters for each selection).
 pub fn get_surround_pos(
+    syntax: Option<&Syntax>,
     text: RopeSlice,
     selection: &Selection,
     ch: Option<char>,
@@ -257,9 +296,13 @@ pub fn get_surround_pos(
     let mut change_pos = Vec::new();
 
     for &range in selection {
-        let (open_pos, close_pos) = match ch {
-            Some(ch) => find_nth_pairs_pos(text, ch, range, skip)?,
-            None => find_nth_closest_pairs_pos(text, range, skip)?,
+        let (open_pos, close_pos) = {
+            let range_raw = match ch {
+                Some(ch) => find_nth_pairs_pos(text, ch, range, skip)?,
+                None => find_nth_closest_pairs_pos(syntax, text, range, skip)?,
+            };
+            let range = Range::new(range_raw.0, range_raw.1);
+            (range.from(), range.to())
         };
         if change_pos.contains(&open_pos) || change_pos.contains(&close_pos) {
             return Err(Error::CursorOverlap);
@@ -288,7 +331,7 @@ fn test_get_surround_pos() {
             );
 
         assert_eq!(
-            get_surround_pos(doc.slice(..), &selection, Some('('), 1).unwrap(),
+            get_surround_pos(None, doc.slice(..), &selection, Some('('), 1).unwrap(),
             expectations
         );
     }
@@ -303,7 +346,7 @@ fn test_get_surround_pos_bail_different_surround_chars() {
             );
 
         assert_eq!(
-            get_surround_pos(doc.slice(..), &selection, Some('('), 1),
+            get_surround_pos(None, doc.slice(..), &selection, Some('('), 1),
             Err(Error::PairNotFound)
         );
     }
@@ -318,7 +361,7 @@ fn test_get_surround_pos_bail_overlapping_surround_chars() {
             );
 
         assert_eq!(
-            get_surround_pos(doc.slice(..), &selection, Some('('), 1),
+            get_surround_pos(None, doc.slice(..), &selection, Some('('), 1),
             Err(Error::PairNotFound) // overlapping surround chars
         );
     }
@@ -333,7 +376,7 @@ fn test_get_surround_pos_bail_cursor_overlap() {
             );
 
         assert_eq!(
-            get_surround_pos(doc.slice(..), &selection, Some('['), 1),
+            get_surround_pos(None, doc.slice(..), &selection, Some('['), 1),
             Err(Error::CursorOverlap)
         );
     }
@@ -397,7 +440,7 @@ fn test_find_nth_closest_pairs_pos_index_range_panic() {
             );
 
         assert_eq!(
-            find_nth_closest_pairs_pos(doc.slice(..), selection.primary(), 1),
+            find_nth_closest_pairs_pos(None, doc.slice(..), selection.primary(), 1),
             Err(Error::PairNotFound)
         )
     }

helix-core/src/syntax.rs

@@ -69,6 +69,21 @@ fn deserialize_tab_width<'de, D>(deserializer: D) -> Result<usize, D::Error>
     })
 }
 
+fn deserialize_tab_width_option<'de, D>(deserializer: D) -> Result<Option<usize>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    usize::deserialize(deserializer).and_then(|n| {
+        if n > 0 && n <= 16 {
+            Ok(Some(n))
+        } else {
+            Err(serde::de::Error::custom(
+                "tab width must be a value from 1 to 16 inclusive",
+            ))
+        }
+    })
+}
+
 pub fn deserialize_auto_pairs<'de, D>(deserializer: D) -> Result<Option<AutoPairs>, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -146,7 +161,7 @@ pub struct LanguageConfiguration {
     )]
     pub language_servers: Vec<LanguageServerFeatures>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub indent: Option<IndentationConfiguration>,
+    pub indent: Option<LanguageIndentationConfiguration>,
 
     #[serde(skip)]
     pub(crate) indent_query: OnceCell<Option<Query>>,
@@ -536,12 +551,22 @@ pub struct DebuggerQuirks {
     pub absolute_paths: bool,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct IndentationConfiguration {
+    #[serde(deserialize_with = "deserialize_tab_width_option")]
+    pub tab_width: Option<usize>,
+    pub unit: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct LanguageIndentationConfiguration {
     #[serde(deserialize_with = "deserialize_tab_width")]
     pub tab_width: usize,
     pub unit: String,
+    #[serde(default)]
+    pub required: bool,
 }
 
 /// How the indentation for a newly inserted line should be determined.
@@ -603,6 +628,15 @@ fn from_str(s: &str) -> Result<Self, Self::Err> {
     }
 }
 
+impl Default for IndentationConfiguration {
+    fn default() -> Self {
+        IndentationConfiguration {
+            tab_width: None,
+            unit: None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct TextObjectQuery {
     pub query: Query,

helix-core/src/textobject.rs

@@ -7,9 +7,9 @@
 use crate::graphemes::{next_grapheme_boundary, prev_grapheme_boundary};
 use crate::line_ending::rope_is_line_ending;
 use crate::movement::Direction;
-use crate::surround;
 use crate::syntax::LanguageConfiguration;
 use crate::Range;
+use crate::{surround, Syntax};
 
 fn find_word_boundary(slice: RopeSlice, mut pos: usize, direction: Direction, long: bool) -> usize {
     use CharCategory::{Eol, Whitespace};
@@ -199,25 +199,28 @@ pub fn textobject_paragraph(
 }
 
 pub fn textobject_pair_surround(
+    syntax: Option<&Syntax>,
     slice: RopeSlice,
     range: Range,
     textobject: TextObject,
     ch: char,
     count: usize,
 ) -> Range {
-    textobject_pair_surround_impl(slice, range, textobject, Some(ch), count)
+    textobject_pair_surround_impl(syntax, slice, range, textobject, Some(ch), count)
 }
 
 pub fn textobject_pair_surround_closest(
+    syntax: Option<&Syntax>,
     slice: RopeSlice,
     range: Range,
     textobject: TextObject,
     count: usize,
 ) -> Range {
-    textobject_pair_surround_impl(slice, range, textobject, None, count)
+    textobject_pair_surround_impl(syntax, slice, range, textobject, None, count)
 }
 
 fn textobject_pair_surround_impl(
+    syntax: Option<&Syntax>,
     slice: RopeSlice,
     range: Range,
     textobject: TextObject,
@@ -226,8 +229,7 @@ fn textobject_pair_surround_impl(
 ) -> Range {
     let pair_pos = match ch {
         Some(ch) => surround::find_nth_pairs_pos(slice, ch, range, count),
-        // Automatically find the closest surround pairs
-        None => surround::find_nth_closest_pairs_pos(slice, range, count),
+        None => surround::find_nth_closest_pairs_pos(syntax, slice, range, count),
     };
     pair_pos
         .map(|(anchor, head)| match textobject {
@@ -574,7 +576,8 @@ fn test_textobject_surround() {
             let slice = doc.slice(..);
             for &case in scenario {
                 let (pos, objtype, expected_range, ch, count) = case;
-                let result = textobject_pair_surround(slice, Range::point(pos), objtype, ch, count);
+                let result =
+                    textobject_pair_surround(None, slice, Range::point(pos), objtype, ch, count);
                 assert_eq!(
                     result,
                     expected_range.into(),

helix-term/src/commands.rs

@@ -5409,13 +5409,22 @@ fn select_textobject(cx: &mut Context, objtype: textobject::TextObject) {
                         'e' => textobject_treesitter("entry", range),
                         'p' => textobject::textobject_paragraph(text, range, objtype, count),
                         'm' => textobject::textobject_pair_surround_closest(
-                            text, range, objtype, count,
+                            doc.syntax(),
+                            text,
+                            range,
+                            objtype,
+                            count,
                         ),
                         'g' => textobject_change(range),
                         // TODO: cancel new ranges if inconsistent surround matches across lines
-                        ch if !ch.is_ascii_alphanumeric() => {
-                            textobject::textobject_pair_surround(text, range, objtype, ch, count)
-                        }
+                        ch if !ch.is_ascii_alphanumeric() => textobject::textobject_pair_surround(
+                            doc.syntax(),
+                            text,
+                            range,
+                            objtype,
+                            ch,
+                            count,
+                        ),
                         _ => range,
                     }
                 });
@@ -5440,7 +5449,7 @@ fn select_textobject(cx: &mut Context, objtype: textobject::TextObject) {
         ("c", "Comment (tree-sitter)"),
         ("T", "Test (tree-sitter)"),
         ("e", "Data structure entry (tree-sitter)"),
-        ("m", "Closest surrounding pair"),
+        ("m", "Closest surrounding pair (tree-sitter)"),
         ("g", "Change"),
         (" ", "... or any character acting as a pair"),
     ];
@@ -5454,7 +5463,7 @@ fn surround_add(cx: &mut Context) {
         // surround_len is the number of new characters being added.
         let (open, close, surround_len) = match event.char() {
             Some(ch) => {
-                let (o, c) = surround::get_pair(ch);
+                let (o, c) = match_brackets::get_pair(ch);
                 let mut open = Tendril::new();
                 open.push(o);
                 let mut close = Tendril::new();
@@ -5505,13 +5514,14 @@ fn surround_replace(cx: &mut Context) {
         let text = doc.text().slice(..);
         let selection = doc.selection(view.id);
 
-        let change_pos = match surround::get_surround_pos(text, selection, surround_ch, count) {
-            Ok(c) => c,
-            Err(err) => {
-                cx.editor.set_error(err.to_string());
-                return;
-            }
-        };
+        let change_pos =
+            match surround::get_surround_pos(doc.syntax(), text, selection, surround_ch, count) {
+                Ok(c) => c,
+                Err(err) => {
+                    cx.editor.set_error(err.to_string());
+                    return;
+                }
+            };
 
         let selection = selection.clone();
         let ranges: SmallVec<[Range; 1]> = change_pos.iter().map(|&p| Range::point(p)).collect();
@@ -5526,7 +5536,7 @@ fn surround_replace(cx: &mut Context) {
                 Some(to) => to,
                 None => return doc.set_selection(view.id, selection),
             };
-            let (open, close) = surround::get_pair(to);
+            let (open, close) = match_brackets::get_pair(to);
 
             // the changeset has to be sorted to allow nested surrounds
             let mut sorted_pos: Vec<(usize, char)> = Vec::new();
@@ -5563,13 +5573,14 @@ fn surround_delete(cx: &mut Context) {
         let text = doc.text().slice(..);
         let selection = doc.selection(view.id);
 
-        let mut change_pos = match surround::get_surround_pos(text, selection, surround_ch, count) {
-            Ok(c) => c,
-            Err(err) => {
-                cx.editor.set_error(err.to_string());
-                return;
-            }
-        };
+        let mut change_pos =
+            match surround::get_surround_pos(doc.syntax(), text, selection, surround_ch, count) {
+                Ok(c) => c,
+                Err(err) => {
+                    cx.editor.set_error(err.to_string());
+                    return;
+                }
+            };
         change_pos.sort_unstable(); // the changeset has to be sorted to allow nested surrounds
         let transaction =
             Transaction::change(doc.text(), change_pos.into_iter().map(|p| (p, p + 1, None)));

helix-term/tests/test/commands.rs

@@ -664,3 +664,63 @@ async fn test_read_file() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn surround_delete() -> anyhow::Result<()> {
+    // Test `surround_delete` when head < anchor
+    test(("(#[|  ]#)", "mdm", "#[|  ]#")).await?;
+    test(("(#[|  ]#)", "md(", "#[|  ]#")).await?;
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn surround_replace_ts() -> anyhow::Result<()> {
+    const INPUT: &str = r#"\
+fn foo() {
+    if let Some(_) = None {
+        todo!("f#[|o]#o)");
+    }
+}
+"#;
+    test((
+        INPUT,
+        ":lang rust<ret>mrm'",
+        r#"\
+fn foo() {
+    if let Some(_) = None {
+        todo!('f#[|o]#o)');
+    }
+}
+"#,
+    ))
+    .await?;
+
+    test((
+        INPUT,
+        ":lang rust<ret>3mrm[",
+        r#"\
+fn foo() {
+    if let Some(_) = None [
+        todo!("f#[|o]#o)");
+    ]
+}
+"#,
+    ))
+    .await?;
+
+    test((
+        INPUT,
+        ":lang rust<ret>2mrm{",
+        r#"\
+fn foo() {
+    if let Some(_) = None {
+        todo!{"f#[|o]#o)"};
+    }
+}
+"#,
+    ))
+    .await?;
+
+    Ok(())
+}

helix-term/tests/test/commands/movement.rs

@@ -726,3 +726,83 @@ async fn select_all_children() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_select_next_sibling() -> anyhow::Result<()> {
+    let tests = vec![
+        // basic test
+        (
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 #[}|]#
+                fn dec(x: usize) -> usize { x - 1 }
+                fn ident(x: usize) -> usize { x }
+            "##},
+            "<A-n>",
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 }
+                #[fn dec(x: usize) -> usize { x - 1 }|]#
+                fn ident(x: usize) -> usize { x }
+            "##},
+        ),
+        // direction is not preserved and is always forward.
+        (
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 #[}|]#
+                fn dec(x: usize) -> usize { x - 1 }
+                fn ident(x: usize) -> usize { x }
+            "##},
+            "<A-n><A-;><A-n>",
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 }
+                fn dec(x: usize) -> usize { x - 1 }
+                #[fn ident(x: usize) -> usize { x }|]#
+            "##},
+        ),
+    ];
+
+    for test in tests {
+        test_with_config(AppBuilder::new().with_file("foo.rs", None), test).await?;
+    }
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_select_prev_sibling() -> anyhow::Result<()> {
+    let tests = vec![
+        // basic test
+        (
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 }
+                fn dec(x: usize) -> usize { x - 1 }
+                #[|f]#n ident(x: usize) -> usize { x }
+            "##},
+            "<A-p>",
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 }
+                #[|fn dec(x: usize) -> usize { x - 1 }]#
+                fn ident(x: usize) -> usize { x }
+            "##},
+        ),
+        // direction is not preserved and is always backward.
+        (
+            indoc! {r##"
+                fn inc(x: usize) -> usize { x + 1 }
+                fn dec(x: usize) -> usize { x - 1 }
+                #[|f]#n ident(x: usize) -> usize { x }
+            "##},
+            "<A-p><A-;><A-p>",
+            indoc! {r##"
+                #[|fn inc(x: usize) -> usize { x + 1 }]#
+                fn dec(x: usize) -> usize { x - 1 }
+                fn ident(x: usize) -> usize { x }
+            "##},
+        ),
+    ];
+
+    for test in tests {
+        test_with_config(AppBuilder::new().with_file("foo.rs", None), test).await?;
+    }
+
+    Ok(())
+}

helix-term/tests/test/movement.rs

@@ -107,6 +107,14 @@ async fn surround_by_character() -> anyhow::Result<()> {
     ))
     .await?;
 
+    // Selection direction is preserved
+    test((
+        "(so [many {go#[|od]#} text] here)",
+        "mi{",
+        "(so [many {#[|good]#} text] here)",
+    ))
+    .await?;
+
     Ok(())
 }
 
@@ -366,6 +374,41 @@ async fn surround_around_pair() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn match_around_closest_ts() -> anyhow::Result<()> {
+    test_with_config(
+        AppBuilder::new().with_file("foo.rs", None),
+        (
+            r#"fn main() {todo!{"f#[|oo]#)"};}"#,
+            "mam",
+            r#"fn main() {todo!{#[|"foo)"]#};}"#,
+        ),
+    )
+    .await?;
+
+    test_with_config(
+        AppBuilder::new().with_file("foo.rs", None),
+        (
+            r##"fn main() { let _ = ("#[|1]#23", "#(|1)#23"); } "##,
+            "3mam",
+            r##"fn main() #[|{ let _ = ("123", "123"); }]# "##,
+        ),
+    )
+    .await?;
+
+    test_with_config(
+        AppBuilder::new().with_file("foo.rs", None),
+        (
+            r##" fn main() { let _ = ("12#[|3", "12]#3"); } "##,
+            "1mam",
+            r##" fn main() { let _ = #[|("123", "123")]#; } "##,
+        ),
+    )
+    .await?;
+
+    Ok(())
+}
+
 /// Ensure the very initial cursor in an opened file is the width of
 /// the first grapheme
 #[tokio::test(flavor = "multi_thread")]
@@ -666,7 +709,7 @@ async fn tree_sitter_motions_work_across_injections() -> anyhow::Result<()> {
         (
             "<script>let #[|x]# = 1;</script>",
             "<A-n>",
-            "<script>let x #[|=]# 1;</script>",
+            "<script>let x #[=|]# 1;</script>",
         ),
     )
     .await?;

helix-view/src/document.rs

@@ -7,7 +7,7 @@
 use helix_core::chars::char_is_word;
 use helix_core::doc_formatter::TextFormat;
 use helix_core::encoding::Encoding;
-use helix_core::syntax::{Highlight, LanguageServerFeature};
+use helix_core::syntax::{Highlight, LanguageServerFeature, IndentationConfiguration};
 use helix_core::text_annotations::{InlineAnnotation, Overlay};
 use helix_lsp::util::lsp_pos_to_pos;
 use helix_stdx::faccess::{copy_metadata, readonly};
@@ -628,7 +628,7 @@ fn take_with<T, F>(mut_ref: &mut T, f: F)
 use url::Url;
 
 impl Document {
-    pub fn from(
+    fn from0(
         text: Rope,
         encoding_with_bom_info: Option<(&'static Encoding, bool)>,
         config: Arc<dyn DynAccess<Config>>,
@@ -671,6 +671,16 @@ pub fn from(
         }
     }
 
+    pub fn from(
+        text: Rope,
+        encoding_with_bom_info: Option<(&'static Encoding, bool)>,
+        config: Arc<dyn DynAccess<Config>>,
+    ) -> Self {
+        let mut doc = Self::from0(text, encoding_with_bom_info, config);
+        doc.detect_indent_and_line_ending();
+        doc
+    }
+
     pub fn default(config: Arc<dyn DynAccess<Config>>) -> Self {
         let line_ending: LineEnding = config.load().default_line_ending.into();
         let text = Rope::from(line_ending.as_str());
@@ -697,7 +707,7 @@ pub fn open(
             (Rope::from(line_ending.as_str()), encoding, false)
         };
 
-        let mut doc = Self::from(rope, Some((encoding, has_bom)), config);
+        let mut doc = Self::from0(rope, Some((encoding, has_bom)), config);
 
         // set the path and try detecting the language
         doc.set_path(Some(path));
@@ -1000,14 +1010,13 @@ pub fn detect_language_config(
             .or_else(|| config_loader.language_config_for_shebang(self.text().slice(..)))
     }
 
-    /// Detect the indentation used in the file, or otherwise defaults to the language indentation
-    /// configured in `languages.toml`, with a fallback to tabs if it isn't specified. Line ending
+    /// Detect the indentation used in the file, or otherwise defaults to the global indentation
+    /// configured in `config.toml` and then the language indentation configured in 
+    /// `languages.toml`, with a fallback to tabs if it isn't specified. Line ending
     /// is likewise auto-detected, and will remain unchanged if no line endings were detected.
     pub fn detect_indent_and_line_ending(&mut self) {
         self.indent_style = auto_detect_indent_style(&self.text).unwrap_or_else(|| {
-            self.language_config()
-                .and_then(|config| config.indent.as_ref())
-                .map_or(DEFAULT_INDENT, |config| IndentStyle::from_str(&config.unit))
+            self.indent_config(DEFAULT_INDENT, |config| config.unit.as_ref().map(|unit| IndentStyle::from_str(unit)))
         });
         if let Some(line_ending) = auto_detect_line_ending(&self.text) {
             self.line_ending = line_ending;
@@ -1023,6 +1032,17 @@ pub fn detect_readonly(&mut self) {
         };
     }
 
+    fn indent_config<T, F: Fn(IndentationConfiguration) -> Option<T>>(&self, default: T, mapper: F) -> T {
+        let mut indent = self.config.load().indent.clone();
+
+        if let Some(c) = self.language_config().and_then(|config| config.indent.as_ref()) {
+            indent.tab_width = indent.tab_width.filter(|_| !c.required).or(Some(c.tab_width));
+            indent.unit = indent.unit.filter(|_| !c.required).or(Some(c.unit.clone()));
+        }
+
+        mapper(indent).unwrap_or(default)
+    }
+
     /// Reload the document from its path.
     pub fn reload(
         &mut self,
@@ -1680,9 +1700,7 @@ pub fn syntax(&self) -> Option<&Syntax> {
 
     /// The width that the tab character is rendered at
     pub fn tab_width(&self) -> usize {
-        self.language_config()
-            .and_then(|config| config.indent.as_ref())
-            .map_or(4, |config| config.tab_width) // fallback to 4 columns
+        self.indent_config(4, |config| config.tab_width) // fallback to 4 columns
     }
 
     // The width (in spaces) of a level of indentation.

helix-view/src/editor.rs

@@ -41,7 +41,7 @@
 pub use helix_core::diagnostic::Severity;
 use helix_core::{
     auto_pairs::AutoPairs,
-    syntax::{self, AutoPairConfig, IndentationHeuristic, LanguageServerFeature, SoftWrap},
+    syntax::{self, AutoPairConfig, IndentationConfiguration, IndentationHeuristic, LanguageServerFeature, SoftWrap},
     Change, LineEnding, Position, Range, Selection, NATIVE_LINE_ENDING,
 };
 use helix_dap as dap;
@@ -310,6 +310,7 @@ pub struct Config {
     pub rulers: Vec<u16>,
     #[serde(default)]
     pub whitespace: WhitespaceConfig,
+    pub indent: IndentationConfiguration,
     /// Persistently display open buffers along the top
     pub bufferline: BufferLine,
     /// Vertical indent width guides.
@@ -897,6 +898,7 @@ fn default() -> Self {
             terminal: get_terminal_provider(),
             rulers: Vec::new(),
             whitespace: WhitespaceConfig::default(),
+            indent: IndentationConfiguration::default(),
             bufferline: BufferLine::default(),
             indent_guides: IndentGuidesConfig::default(),
             color_modes: false,

languages.toml

@@ -791,7 +791,7 @@ roots = ["pyproject.toml", "setup.py", "poetry.lock", "pyrightconfig.json"]
 comment-token = "#"
 language-servers = [ "pylsp" ]
 # TODO: pyls needs utf-8 offsets
-indent = { tab-width = 4, unit = "    " }
+indent = { tab-width = 4, unit = "    ", required = true }
 
 [[grammar]]
 name = "python"
@@ -1207,7 +1207,7 @@ name = "yaml"
 scope = "source.yaml"
 file-types = ["yml", "yaml"]
 comment-token = "#"
-indent = { tab-width = 2, unit = "  " }
+indent = { tab-width = 2, unit = "  ", required = true }
 language-servers = [ "yaml-language-server", "ansible-language-server" ]
 injection-regex = "yml|yaml"
 
@@ -1339,7 +1339,7 @@ file-types = [{ glob = "Makefile" }, { glob = "makefile" }, "make", "mk", "mak",
 shebangs = ["make", "gmake"]
 injection-regex = "(make|makefile|Makefile|mk)"
 comment-token = "#"
-indent = { tab-width = 4, unit = "\t" }
+indent = { tab-width = 4, unit = "\t", required = true }
 
 [[grammar]]
 name = "make"
@@ -1643,7 +1643,7 @@ source = { git = "https://github.com/mtoohey31/tree-sitter-gitattributes", rev =
 [[language]]
 name = "git-ignore"
 scope = "source.gitignore"
-file-types = [{ glob = ".gitignore" }, { glob = ".gitignore_global" }, { glob = ".ignore" }, { glob = ".prettierignore" }, { glob = ".eslintignore" }, { glob = ".npmignore"}, { glob = "CODEOWNERS" }, { glob = ".config/helix/ignore" }, { glob = ".helix/ignore" }]
+file-types = [{ glob = ".gitignore_global" }, { glob = ".ignore" }, { glob = "CODEOWNERS" }, { glob = ".config/helix/ignore" }, { glob = ".helix/ignore" }, { glob = ".*ignore" }]
 injection-regex = "git-ignore"
 comment-token = "#"
 grammar = "gitignore"
@@ -2939,7 +2939,7 @@ file-types = ["nim", "nims", "nimble"]
 shebangs = []
 comment-token = "#"
 block-comment-tokens = { start = "#[", end = "]#" }
-indent = { tab-width = 2, unit = "  " }
+indent = { tab-width = 2, unit = "  ", required = true }
 language-servers = [ "nimlangserver" ]
 
 [language.auto-pairs]

runtime/themes/dark_plus.toml

@@ -1,105 +1,93 @@
+# Author: David Else <12832280+David-Else@users.noreply.github.com>
 
-"namespace" = { fg = "type" }
-"module" = { fg = "type" }
+# SYNTAX
+"attribute"                 = "fn_declaration"
+"comment"                   = "dark_green"
+"constant"                  = "constant"
+"constant.builtin"          = "blue2"
+"constant.character"        = "orange"
+"constant.character.escape" = "gold"
+"constant.numeric"          = "pale_green"
+"constructor"               = "type"
+"diff.delta"                = "blue4"
+"diff.minus"                = "orange_red"
+"diff.plus"                 = "dark_green2"
+"function"                  = "fn_declaration"
+"function.builtin"          = "fn_declaration"
+"function.macro"            = "blue2"
+"keyword"                   = "blue2"
+"keyword.control"           = "special"
+"keyword.directive"         = "special"
+"label"                     = "blue2"
+"module"                    = "type"
+"namespace"                 = "type"
+"operator"                  = "text"
+"punctuation"               = "text"
+"punctuation.delimiter"     = "text"
+"special"                   = "text"
+"string"                    = "orange"
+"string.regexp"             = "gold"
+"tag"                       = "blue2"
+"type"                      = "type"
+"type.builtin"              = "type"
+"type.enum.variant"         = "constant"
+"variable"                  = "variable"
+"variable.builtin"          = "blue2"
+"variable.other.member"     = "variable"
+"variable.parameter"        = "variable"
 
-"type" = { fg = "type" }
-"type.builtin" = { fg = "type" }
-"type.enum.variant" = { fg = "constant" }
-"constructor" = { fg = "type" }
-"variable.other.member" = { fg = "variable" }
-
-"keyword" = { fg = "blue2" }
-"keyword.directive" = { fg = "blue2" }
-"keyword.control" = { fg = "special" }
-"label" = { fg = "blue2" }
-"tag" = "blue2"
-
-"special" = { fg = "text" }
-"operator" = { fg = "text" }
-
-"punctuation" = { fg = "text" }
-"punctuation.delimiter" = { fg = "text" }
-
-"variable" = { fg = "variable" }
-"variable.parameter" = { fg = "variable" }
-"variable.builtin" = { fg = "blue2" }
-"constant" = { fg = "constant" }
-"constant.builtin" = { fg = "blue2" }
-
-"function" = { fg = "fn_declaration" }
-"function.builtin" = { fg = "fn_declaration" }
-"function.macro" = { fg = "blue2" }
-"attribute" = { fg = "fn_declaration" }
-
-"comment" = { fg = "dark_green" }
-
-"string" = { fg = "orange" }
-"constant.character" = { fg = "orange" }
-"string.regexp" = { fg = "gold" }
-"constant.numeric" = { fg = "pale_green" }
-"constant.character.escape" = { fg = "gold" }
-
-"markup.heading" = { fg = "blue2", modifiers = ["bold"] }
-"markup.list" = "blue3"
-"markup.bold" = { fg = "blue2", modifiers = ["bold"] }
-"markup.italic" = { modifiers = ["italic"] }
+# MARKUP
+"markup.heading"       = { fg = "blue2", modifiers = ["bold"] }
+"markup.list"          = "blue3"
+"markup.bold"          = { fg = "blue2", modifiers = ["bold"] }
+"markup.italic"        = { modifiers = ["italic"] }
 "markup.strikethrough" = { modifiers = ["crossed_out"] }
-"markup.link.url" = { modifiers = ["underlined"] }
-"markup.link.text" = "orange"
-"markup.quote" = "dark_green"
-"markup.raw" = "orange"
-
-"diff.plus" = { fg = "dark_green2" }
-"diff.delta" = { fg = "blue4" }
-"diff.minus" = { fg = "orange_red" }
-
-"ui.background" = { fg = "light_gray", bg = "dark_gray2" }
-
-"ui.window" = { bg = "widget" }
-"ui.popup" = { fg = "text", bg = "widget" }
-"ui.help" = { fg = "text", bg = "widget" }
-"ui.menu" = { fg = "text", bg = "widget" }
-"ui.menu.selected" = { bg = "dark_blue2" }
+"markup.link.url"      = { modifiers = ["underlined"] }
+"markup.link.text"     = "orange"
+"markup.quote"         = "dark_green"
+"markup.raw"           = "orange"
 
+# UI
+"ui.background"              = { fg = "light_gray", bg = "dark_gray2" }
+"ui.window"                  = { bg = "widget" }
+"ui.popup"                   = { fg = "text", bg = "widget" }
+"ui.help"                    = { fg = "text", bg = "widget" }
+"ui.menu"                    = { fg = "text", bg = "widget" }
+"ui.menu.selected"           = { bg = "dark_blue2" }
 # TODO: Alternate bg colour for `ui.cursor.match` and `ui.selection`.
-"ui.cursor" = { fg = "cursor", modifiers = ["reversed"] }
-"ui.cursor.primary" = { fg = "cursor", modifiers = ["reversed"] }
-"ui.cursor.match" = { bg = "#3a3d41", modifiers = ["underlined"] }
-
-"ui.selection" = { bg = "#3a3d41" }
-"ui.selection.primary" = { bg = "dark_blue" }
-
-"ui.linenr" = { fg = "dark_gray" }
-"ui.linenr.selected" = { fg = "light_gray2" }
-
-"ui.cursorline.primary" = { bg = "dark_gray3" }
-"ui.statusline" = { fg = "white", bg = "blue" }
-"ui.statusline.inactive" = { fg = "white", bg = "blue" }
-"ui.statusline.insert" = { fg = "white", bg = "yellow" }
-"ui.statusline.select" = { fg = "white", bg = "magenta" }
-
-"ui.bufferline" = { fg = "text", bg = "widget" }
-"ui.bufferline.active" = { fg = "white", bg = "blue" }
-"ui.bufferline.background" = { bg = "background" }
-
-"ui.text" = { fg = "text" }
-"ui.text.focus" = { fg = "white" }
-
-"ui.virtual.whitespace" = { fg = "dark_gray" }
-"ui.virtual.ruler" = { bg = "borders" }
-"ui.virtual.indent-guide" = { fg = "dark_gray4" }
-"ui.virtual.inlay-hint" = { fg = "dark_gray5"}
-"ui.virtual.jump-label" = { fg = "dark_gray", modifiers = ["bold"] }
-
-"warning" = { fg = "gold2" }
-"error" = { fg = "red" }
-"info" = { fg = "light_blue" }
-"hint" = { fg = "light_gray3" }
-
+"ui.cursor"                  = { fg = "cursor", modifiers = ["reversed"] }
+"ui.cursor.primary"          = { fg = "cursor", modifiers = ["reversed"] }
+"ui.cursor.match"            = { bg = "#3a3d41", modifiers = ["underlined"] }
+"ui.selection"               = { bg = "#3a3d41" }
+"ui.selection.primary"       = { bg = "dark_blue" }
+"ui.linenr"                  = { fg = "dark_gray" }
+"ui.linenr.selected"         = { fg = "light_gray2" }
+"ui.cursorline.primary"      = { bg = "dark_gray3" }
+"ui.statusline"              = { fg = "white", bg = "blue" }
+"ui.statusline.inactive"     = { fg = "white", bg = "widget" }
+"ui.statusline.insert"       = { fg = "white", bg = "yellow" }
+"ui.statusline.select"       = { fg = "white", bg = "magenta" }
+"ui.bufferline"              = { fg = "text", bg = "widget" }
+"ui.bufferline.active"       = { fg = "white", bg = "blue" }
+"ui.bufferline.background"   = { bg = "background" }
+"ui.text"                    = { fg = "text" }
+"ui.text.focus"              = { fg = "white" }
+"ui.virtual.whitespace"      = { fg = "#3e3e3d" }
+"ui.virtual.ruler"           = { bg = "borders" }
+"ui.virtual.indent-guide"    = { fg = "dark_gray4" }
+"ui.virtual.inlay-hint"      = { fg = "dark_gray5"}
+"ui.virtual.jump-label"      = { fg = "dark_gray", modifiers = ["bold"] }
+"ui.highlight.frameline"     = { bg = "#4b4b18" }
+"ui.debug.active"            = { fg = "#ffcc00" }
+"ui.debug.breakpoint"        = { fg = "#e51400" }
+"warning"                    = { fg = "gold2" }
+"error"                      = { fg = "red" }
+"info"                       = { fg = "light_blue" }
+"hint"                       = { fg = "light_gray3" }
 "diagnostic.error".underline = { color = "red", style = "curl" }
-"diagnostic".underline = { color = "gold", style = "curl" }
-"diagnostic.unnecessary" = { modifiers = ["dim"] }
-"diagnostic.deprecated" = { modifiers = ["crossed_out"] }
+"diagnostic".underline       = { color = "gold", style = "curl" }
+"diagnostic.unnecessary"     = { modifiers = ["dim"] }
+"diagnostic.deprecated"      = { modifiers = ["crossed_out"] }
 
 [palette]
 white = "#ffffff"